LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %rbx
cmpq $0x0, 0x50(%r14)
je 0x9c4b
pushq $0x51
popq %rsi
movq %rbx, %rdi
callq 0xb7e8
movq (%rbx), %rsi
pushq $0x22
popq %rdx
movq %r14, %rdi
callq 0x664c
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb7aa
movq (%rbx), %r15
pushq $0x22
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x664c
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0x4287
movzbl (%r15), %edx
incl %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6caa
// File: /workspace/github_c_makefile_star2_O2/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 0x422e
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x668f
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rdx, %rsi
callq 0x4287
movq 0x60(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42a9
// File: /workspace/github_c_makefile_star2_O2/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 0x9cfe
cmpw $0x0, 0x38(%rbx)
jne 0x9cfe
movq %rbx, %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x6517
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
negq %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4298
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movq 0x88(%rdi), %rdx
addq %rax, %rcx
incq %rcx
leaq -0x1(%rcx), %rsi
cmpq %rdx, %rsi
je 0x9eaa
movzbl (%rsi), %esi
cmpl $0xa, %esi
je 0x9e8d
cmpl $0xd, %esi
je 0x9e8d
incq %rcx
jmp 0x9e72
cmpq %rdx, %rcx
je 0x9eaa
movzbl (%rcx), %edx
cmpb %dl, %sil
je 0x9ea7
cmpl $0xa, %edx
je 0x9ea4
cmpl $0xd, %edx
jne 0x9ea7
incq %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %r14
pushq $0x4a
popq %rsi
movq %rax, %rdi
callq 0xb7e8
movq 0x60(%rbx), %rdi
callq 0x41fe
movq %r14, %rdi
movq %rax, %rsi
callq 0xb7cd
movq 0x60(%rbx), %rdi
callq 0x41fe
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %r14
movq %rbx, %rdi
callq 0x6713
pushq $0x47
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xb893
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6cb4
// File: /workspace/github_c_makefile_star2_O2/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 0x422e
movq %rax, %rdi
callq 0xac87
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4287
xorl %esi, %esi
testq %r14, %r14
sete %sil
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4298
// File: /workspace/github_c_makefile_star2_O2/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 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xac8c
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xa1ec
movq %rax, %rsi
callq 0x4287
xorl %esi, %esi
jmp 0xa1f7
movq %r14, %rsi
callq 0x4287
pushq $0x1
popq %rsi
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4298
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x41fe
testq %rax, %rax
je 0xa287
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xbd80
testl %eax, %eax
je 0xa287
movq 0x18(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3955
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x420e
testq %rax, %rax
je 0xa340
movb 0xa(%rax), %al
shlb $0x4, %al
sarb $0x7, %al
movsbq %al, %rsi
jmp 0xa342
xorl %esi, %esi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x4298
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %rbx
movq 0x60(%r15), %rdi
callq 0x421e
movq %rax, %r14
movq 0x60(%r15), %rdi
callq 0x420e
movq %rax, %r15
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0xb7e8
movq (%rbx), %rdi
movb %r14b, (%rdi)
addq $0x2, %rdi
negq %r14
pushq $0x1
popq %rax
leaq (%r14,%rax), %rcx
cmpq $0x1, %rcx
je 0xa40a
movb -0x1(%r15,%rax), %cl
movb %cl, -0x1(%rdi)
incq %rax
incq %rdi
jmp 0xa3f0
movb $0x0, -0x1(%rdi)
callq 0xad30
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x421e
leaq 0x118(%rbx), %r14
pushq $0x10
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0xae8b
movq %r14, %rdi
callq 0x30e0
movw $0x20, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68f1
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %rbx
movq %r12, %rdi
callq 0x6713
movq %rax, %r14
movq %rdx, %r15
movq 0x60(%r12), %rdi
callq 0x41fe
movq %rax, %r13
cmpq $0x10, %rax
jl 0xa75d
leaq 0x4b4d(%rip), %rsi      # 0xf2a0
movq %r12, %rdi
xorl %eax, %eax
callq 0x6527
movl $0x87, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xb893
movq %rbx, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/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 0x6744
movq %rax, %r14
movq %rdx, %r15
testq %rax, %rax
jne 0xa7b6
movq %rbx, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x6517
xorl %ebp, %ebp
cmpq $0x8, %rbp
je 0xa820
movq 0x60(%r13,%rbp,8), %r12
testq %r12, %r12
je 0xa820
leaq -0x3a7f(%rip), %rax     # 0x6d50
cmpq %rax, 0x18(%r12)
je 0xa809
movq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x4287
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x42a9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6ad4
movq 0x60(%rbx), %rdi
callq 0x422e
testq %rax, %rax
je 0xa81b
jmp 0xa845
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%r12)
testl %eax, %eax
jne 0xa845
incq %rbp
jmp 0xa7b8
leaq 0x41b2(%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 0x6527
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa94a
movq 0x60(%rbx), %rdi
callq 0x420e
subq (%r14), %rax
sarq $0x3, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/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 0x420e
leaq 0xe5c7(%rip), %rcx      # 0x18eb5
cmpq %rcx, %rax
je 0xa933
leaq 0xe5bb(%rip), %rsi      # 0x18eb5
movq %rax, %rdi
callq 0x31a0
testl %eax, %eax
je 0xa933
leaq 0x492f(%rip), %rsi      # 0xf23c
movq %r14, %rdi
callq 0x68f1
leaq 0xe599(%rip), %rsi      # 0x18eb5
movq %r14, %rdi
callq 0x68f1
leaq 0x3a3e(%rip), %rsi      # 0xe369
movq %r14, %rdi
callq 0x68f1
movq 0x60(%r14), %rdi
callq 0x420e
movq (%rbx), %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6643
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xba0d
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xaa2f
movq %rax, %r15
movq %rax, %rsi
callq 0x4287
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0xb26c
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 0x4298
movq %r14, %rsi
callq 0x4287
movq 0x60(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42a9
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/primitives.c
// Function: resolveForwardBranch
static void resolveForwardBranch(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 = dictionary->here - patchAddr;
    *patchAddr = FICL_LVALUE_TO_CELL(offset);

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe46f(%rip), %rsi      # 0x18ecd
movq %rbx, %rdi
callq 0xa94a
movq 0x60(%rbx), %rdi
callq 0x420e
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_O2/hoobaa[P]ficl/lzuncompress.c
// Function: ficlLzDecodeHeaderField
int ficlLzDecodeHeaderField(const unsigned char *data, int *byteOffset)
	{
	unsigned char id;
	int networkOrder;
	int length;

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

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

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

	return ficlNetworkUnsigned32(networkOrder);
	}

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30e0
cmpl $0x2, %eax
jl 0xad77
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rbx, %rax
decq %rax
movq %rbx, %rcx
cmpq %rax, %rcx
jae 0xad77
movb (%rax), %dl
movb (%rcx), %sil
movb %sil, (%rax)
movb %dl, (%rcx)
incq %rcx
decq %rax
jmp 0xad60
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/utility.c
// Function: ficlLtoa
char *ficlLtoa( ficlInteger value, char *string, int radix )
{                               /* convert long to string, any base */
    char *cp = string;
    int sign = ((radix == 10) && (value < 0));
    int pwr;

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

    pwr = ficlIsPowerOfTwo((ficlUnsigned)radix);

    if (sign)
        value = -value;

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

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

    *cp++ = '\0';

    return ficlStringReverse(string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpl $0xa, %edx
sete %al
testq %rdi, %rdi
sets %bpl
andb %al, %bpl
movslq %edx, %r14
movq %r14, %rdi
callq 0xad8a
movq %r15, %rdx
negq %rdx
testb %bpl, %bpl
cmoveq %r15, %rdx
testq %rdx, %rdx
je 0xae1b
testl %eax, %eax
je 0xae4e
pushq $-0x1
popq %rsi
movl %eax, %ecx
shll %cl, %esi
notl %esi
movl %eax, %ecx
leaq 0x45d1(%rip), %rax      # 0xf3d0
movq %rbx, %r12
testq %rdx, %rdx
je 0xae22
movl %edx, %edi
andl %esi, %edi
movb (%rdi,%rax), %dil
movb %dil, (%r12)
incq %r12
shrq %cl, %rdx
jmp 0xae02
leaq 0x1(%rbx), %r12
movb $0x30, (%rbx)
testb %bpl, %bpl
je 0xae2f
movb $0x2d, (%r12)
incq %r12
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xad44
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
movq %rsp, %r15
leaq 0x4576(%rip), %r13      # 0xf3d0
movq %rbx, %r12
movq %rsi, %rax
orq %rdx, %rax
je 0xae22
movq %r15, %rdi
movq %r14, %rcx
callq 0xcd9c
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movb (%rax,%r13), %al
movb %al, (%r12)
incq %r12
jmp 0xae5d
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/utility.c
// Function: ficlUltoa
char *ficlUltoa(ficlUnsigned value, char *string, int radix )
{                               /* convert long to string, any base */
    char *cp = string;
    ficl2Unsigned ud;
    ficl2UnsignedQR result;

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

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

    *cp++ = '\0';

    return ficlStringReverse(string);
}

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

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

    return oldCp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
movzbl (%r14), %r15d
testq %r15, %r15
je 0xaf45
callq 0x3340
movq (%rax), %rax
testb $0x1, 0x1(%rax,%r15,2)
je 0xaf40
callq 0x3330
movq (%rax), %rax
movb (%rax,%r15,4), %al
movb %al, (%r14)
incq %r14
jmp 0xaf18
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/utility.c
// Function: ficlStrincmp
int ficlStrincmp(char *cp1, char *cp2, ficlUnsigned count)
{
    int i = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xaf8a
callq 0x3330
movq (%rax), %rdx
movzbl (%r15,%r12), %ecx
movl (%rdx,%rcx,4), %eax
movzbl (%r14,%r12), %esi
subl (%rdx,%rsi,4), %eax
jne 0xaf8c
testb %cl, %cl
je 0xaf8a
incq %r12
jmp 0xaf62
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/utility.c
// Function: ficlStringSkipSpace
char *ficlStringSkipSpace(char *cp, char *end)
{
    FICL_ASSERT(NULL, cp);

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

    return cp;
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb04a
movq %rsi, %r14
movq %rax, %r12
pushq $0x1
popq %rbp
movq %rsp, %r15
movb (%r14), %cl
testb %cl, %cl
je 0xb03a
xorl %edx, %edx
xorl %eax, %eax
testb %cl, %cl
je 0xb02a
cmpq $0xfe, %rax
jg 0xb02a
cmpb $0xa, %cl
je 0xb01f
movzbl %cl, %esi
cmpl $0xd, %esi
je 0xb021
movb %cl, (%rsp,%rax)
incq %rax
jmp 0xb021
movl %ebp, %edx
movb 0x1(%r14), %cl
incq %r14
jmp 0xaffe
movb $0x0, (%rsp,%rax)
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq *%r12
jmp 0xaff3
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/hash.c
// Function: ficlHashCode
ficlUnsigned16 ficlHashCode(ficlString s)
{   
    /* hashPJW */
    ficlUnsigned8 *trace;
    ficlUnsigned16 code = (ficlUnsigned16)s.length;
    ficlUnsigned16 shift = 0;

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

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

    return (ficlUnsigned16)code;
}

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

    if (nCmp > FICL_NAME_LENGTH)
        nCmp = FICL_NAME_LENGTH;

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

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

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x1f, %rsi
pushq $0x1f
popq %r13
cmovbq %rsi, %r13
testq %r12, %r12
je 0xb17c
movl 0x10(%r12), %ecx
cmpl $0x2, %ecx
jb 0xb145
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
jmp 0xb147
xorl %edx, %edx
leaq (%r12,%rdx,8), %rbp
addq $0x18, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xb176
movzbl 0xb(%rbp), %eax
cmpq %r15, %rax
jne 0xb14f
movq 0x10(%rbp), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0xaf4e
testl %eax, %eax
jne 0xb14f
jmp 0xb17e
movq (%r12), %r12
jmp 0xb12e
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/callback.c
// Function: ficlCallbackTextOut
void ficlCallbackTextOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction textOut = NULL;

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

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

    (textOut)(callback, text);

    return;
}

// Assembly:
movq %rdi, %rax
movq %rax, %rdi
testq %rax, %rax
je 0xb1d5
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jne 0xb1d7
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xb1d5
movl $0x0, %ecx
cmpq %rdi, %rax
jne 0xb1af
jmp 0xb1d7
xorl %ecx, %ecx
testq %rcx, %rcx
sete %dl
leaq 0xe2b4(%rip), %rax      # 0x19498
movq (%rax), %rax
testq %rax, %rax
setne %r8b
andb %dl, %r8b
cmpb $0x1, %r8b
jne 0xb1fe
movq 0x8(%rax), %rcx
movq %rax, %rdi
testq %rcx, %rcx
jne 0xb20a
leaq -0x574(%rip), %rcx      # 0xac96
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/callback.c
// Function: ficlCallbackErrorOut
void ficlCallbackErrorOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction errorOut = NULL;

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

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

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

    (errorOut)(callback, text);

    return;
}

// Assembly:
movq %rdi, %rax
movq %rax, %rdi
testq %rax, %rax
je 0xb235
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0xb237
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xb235
movl $0x0, %ecx
cmpq %rdi, %rax
jne 0xb20f
jmp 0xb237
xorl %ecx, %ecx
testq %rcx, %rcx
sete %dl
leaq 0xe254(%rip), %rax      # 0x19498
movq (%rax), %rax
testq %rax, %rax
setne %r8b
andb %dl, %r8b
cmpb $0x1, %r8b
jne 0xb25e
movq 0x10(%rax), %rcx
movq %rax, %rdi
testq %rcx, %rcx
je 0xb265
jmpq *%rcx
jmp 0xb1ac
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/extras.c
// Function: ficlSystemCompileExtras
void ficlSystemCompileExtras(ficlSystem *system)
{
    ficlDictionary *dictionary = ficlSystemGetDictionary(system);

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

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

    return;
}

// Assembly:
pushq %rbx
callq 0x399f
movq %rax, %rbx
leaq 0x30e9(%rip), %rsi      # 0xe439
leaq 0xaf(%rip), %rdx        # 0xb406
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x4128(%rip), %rsi      # 0xf490
leaq 0x98(%rip), %rdx        # 0xb407
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x4115(%rip), %rsi      # 0xf495
leaq 0x1f1(%rip), %rdx       # 0xb578
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x4106(%rip), %rsi      # 0xf49e
leaq 0x2cd(%rip), %rdx       # 0xb66c
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x40f5(%rip), %rsi      # 0xf4a5
leaq 0x335(%rip), %rdx       # 0xb6ec
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x40e3(%rip), %rsi      # 0xf4ab
movl $0xf4240, %edx          # imm = 0xF4240
movq %rbx, %rdi
callq 0xba61
leaq 0x40da(%rip), %rsi      # 0xf4b6
leaq 0x31f(%rip), %rdx       # 0xb702
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xbbe5
leaq 0x40c6(%rip), %rsi      # 0xf4ba
leaq 0x344(%rip), %rdx       # 0xb73f
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xbbe5
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSpewHash
static void ficlPrimitiveSpewHash(ficlVm *vm)
{
    ficlHash *hash = ficlVmGetDictionary(vm)->forthWordlist;
    ficlWord *word;
    FILE *f;
    unsigned i;
    unsigned hashSize = hash->size;

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

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

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

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

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

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

        fprintf(f, "\n");
    }

    fclose(f);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x6643
movq 0x18(%rax), %r13
movl 0x10(%r13), %r14d
movq %r15, %rdi
callq 0x67da
testl %eax, %eax
jne 0xb5ac
movq %r15, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x6517
leaq 0x118(%r15), %rdi
leaq 0x439b(%rip), %rsi      # 0xf955
callq 0x32b0
testq %rax, %rax
je 0xb64f
movq %rax, %rbx
addq $0x18, %r13
leaq 0x3f59(%rip), %r15      # 0xf52f
xorl %r12d, %r12d
cmpq %r14, %r12
je 0xb639
leaq (,%r12,8), %rbp
addq %r13, %rbp
pushq $-0x1
popq %rcx
movq %rbp, %rax
movq (%rax), %rax
incl %ecx
testq %rax, %rax
jne 0xb5ef
movq %rbx, %rdi
leaq 0x3f26(%rip), %rsi      # 0xf529
movl %r12d, %edx
xorl %eax, %eax
callq 0x31b0
movq (%rbp), %rbp
testq %rbp, %rbp
je 0xb629
movq 0x10(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31b0
jmp 0xb60d
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x3150
incq %r12
jmp 0xb5d9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
leaq 0x3ebe(%rip), %rsi      # 0xf514
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x68f1
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSystem
static void ficlPrimitiveSystem(ficlVm *vm)
{
    ficlCountedString *counted = (ficlCountedString *)vm->pad;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
pushq $0xa
popq %rdx
movq %r14, %rsi
callq 0x664c
cmpb $0x0, 0x118(%rbx)
je 0xb6ce
leaq 0x119(%rbx), %rdi
callq 0x3100
testl %eax, %eax
je 0xb6e4
leaq 0x3e8e(%rip), %rsi      # 0xf533
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f1
pushq $-0x38
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6517
leaq 0x3e77(%rip), %rsi      # 0xf54c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68f1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveGetCwd
static void ficlPrimitiveGetCwd(ficlVm *vm)
{
    char *directory;

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x118(%rdi), %rsi
pushq $0xa
popq %rdx
callq 0x664c
cmpb $0x0, 0x118(%rbx)
je 0xb786
leaq 0x119(%rbx), %rdi
callq 0x30f0
testl %eax, %eax
je 0xb796
leaq 0x3dfe(%rip), %rsi      # 0xf570
movq %rbx, %rdi
callq 0x68f1
pushq $-0x38
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x6517
leaq 0x3dfa(%rip), %rsi      # 0xf587
movq %rbx, %rdi
popq %rbx
jmp 0x68f1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendData
void *ficlDictionaryAppendData(ficlDictionary *dictionary, void *data, ficlInteger length)
{
    char *here    = (char *)dictionary->here;
    char *oldHere = here;
	char *from    = (char *)data;
 
    if (length == 0)
    {
        ficlDictionaryAlign(dictionary);
        return (char *)dictionary->here;
    }

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

    *here++ = '\0';

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0xb83b
movq (%rbx), %r14
negq %rdx
leaq 0x1(%r14), %rax
pushq $0x1
popq %rcx
leaq (%rdx,%rcx), %rdi
cmpq $0x1, %rdi
je 0xb82a
movb -0x1(%rsi,%rcx), %dil
movb %dil, -0x1(%rax)
incq %rcx
incq %rax
jmp 0xb80f
movb $0x0, -0x1(%rax)
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xb7aa
jmp 0xb846
movq %rbx, %rdi
callq 0xb7aa
movq (%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendConstantInstruction
ficlWord *ficlDictionaryAppendConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
		ficlDictionaryAppendUnsigned(dictionary, value);
	return word;
}

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

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

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

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return word;
}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0xba0d
testq %rax, %rax
je 0xb9f0
movq %r14, 0x18(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb867
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryLookup
ficlWord *ficlDictionaryLookup(ficlDictionary *dictionary, ficlString name)
{
    ficlWord *word = NULL;
    ficlHash *hash;
    int i;
    ficlUnsigned16 hashCode   = ficlHashCode(name);

    FICL_DICTIONARY_ASSERT(dictionary, dictionary != NULL);

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

    ficlDictionaryLock(dictionary, FICL_TRUE);
    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xb08a
movl %eax, %ecx
movl 0xa8(%r15), %r12d
xorl %eax, %eax
movzwl %cx, %ebp
testl %r12d, %r12d
jle 0xba58
testq %rax, %rax
jne 0xba58
movq 0x20(%r15,%r12,8), %rdi
decq %r12
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb10c
jmp 0xba37
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySet2ConstantInstruction
ficlWord *ficlDictionarySet2ConstantInstruction(ficlDictionary *dictionary, ficlString s, ficlInstruction instruction, ficl2Integer value)
{
    ficlWord *word;
    word = ficlDictionaryLookup(dictionary, s);

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

    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0xba0d
testq %rax, %rax
je 0xbae5
movq 0x18(%rax), %rcx
cmpq $0x8a, %rcx
je 0xbaca
cmpq $0x49, %rcx
jne 0xbae5
movq %r15, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb914