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


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


	cell = ficlStackPop(vm->floatStack);
	if (cell.f == 1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF1);
	}
	else if (cell.f == 0.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF0);
	}
	else if (cell.f == -1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFNeg1);
	}
	else
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFLiteralParen);
		ficlDictionaryAppendCell(dictionary, cell);
	}
}

// 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
movq 0x70(%rax), %rdi
callq 0x4b00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss 0x10fb9(%rip), %xmm1    # 0x151e8
ucomiss %xmm1, %xmm0
jne 0x4246
jp 0x4246
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x11080
jmp 0x42a8
movss -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4265
jp 0x4265
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x11080
jmp 0x42a6
movss -0x18(%rbp), %xmm0
movss 0x10f7a(%rip), %xmm1    # 0x151ec
ucomiss %xmm1, %xmm0
jne 0x4289
jp 0x4289
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x11080
jmp 0x42a4
movq -0x10(%rbp), %rdi
movl $0x88, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11010
jmp 0x42a6
jmp 0x42a8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveFConstant
static void ficlPrimitiveFConstant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionFConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// 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 -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x89, %ecx
xorl %r8d, %r8d
callq 0x11220
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4b00
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x11010
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveF2Constant
static void ficlPrimitiveF2Constant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionF2ConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// 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), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x8a, %ecx
xorl %r8d, %r8d
callq 0x11220
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4b00
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x11010
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4b00
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x11010
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/prefix.c
// Function: ficlVmParsePrefix
int ficlVmParsePrefix(ficlVm *vm, ficlString s)
{
    int i;
    ficlHash *hash;
    ficlWord *word = ficlSystemLookup(vm->callback.system, list_name);

    /* 
    ** Make sure we found the prefix dictionary - otherwise silently fail
    ** If forth-wordlist is not in the search order, we won't find the prefixes.
    */
    if (!word)
        return 0; /* false */

    hash = (ficlHash *)(word->param[0].p);
    /*
    ** Walk the list looking for a match with the beginning of the incoming token
    */
    for (i = 0; i < (int)hash->size; i++)
    {
        word = hash->table[i];
        while (word != NULL)
        {
            int n;
            n = word->length;
            /*
            ** If we find a match, adjust the TIB to give back the non-prefix characters
            ** and execute the prefix word.
            */
            if (!ficlStrincmp(FICL_STRING_GET_POINTER(s), word->name, (ficlUnsigned)n))
            {
                /* (sadler) fixed off-by-one error when the token has no trailing space in the TIB */
                ficlVmSetTibIndex(vm, s.text + n - vm->tib.text);
                ficlVmExecuteWord(vm, word);

                return 1; /* true */
            }
            word = word->link;
        }
    }

    return 0; /* false */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x17b5d(%rip), %rsi     # 0x1c1a0
callq 0x3c80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x465f
movl $0x0, -0x4(%rbp)
jmp 0x471d
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x4716
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4706
movq -0x38(%rbp), %rax
movzbl 0xb(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x3c(%rbp), %rdx
callq 0xff80
cmpl $0x0, %eax
jne 0x46f9
movq -0x10(%rbp), %rcx
movslq -0x3c(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6640
movl $0x1, -0x4(%rbp)
jmp 0x471d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4693
jmp 0x4708
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4672
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/prefix.c
// Function: ficlPrimitiveTempBase
static void ficlPrimitiveTempBase(ficlVm *vm)
{
    int oldbase = vm->base;
    ficlString number = ficlVmGetWord0(vm);
    int base = ficlStackPopInteger(vm->dataStack);

    vm->base = base;
    if (!ficlVmParseNumber(vm, number)) 
        ficlVmThrowError(vm, "%.*s not recognized", FICL_STRING_GET_LENGTH(number), FICL_STRING_GET_POINTER(number));

    vm->base = oldbase;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x91c0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9a90
cmpl $0x0, %eax
jne 0x4814
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x10a94(%rip), %rsi     # 0x152a1
movb $0x0, %al
callq 0x8dc0
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/softcore.c
// Function: ficlSystemCompileSoftCore
void ficlSystemCompileSoftCore(ficlSystem *system)
{
    ficlVm *vm = system->vmList;
    int returnValue;
    ficlCell oldSourceID = vm->sourceId;
    ficlString s;
#if FICL_WANT_LZ_SOFTCORE
    char *ficlSoftcoreUncompressed = NULL;
    size_t gotUncompressedSize = 0;
    returnValue = ficlLzUncompress(ficlSoftcoreCompressed, (unsigned char **)&ficlSoftcoreUncompressed, &gotUncompressedSize);
    FICL_VM_ASSERT(vm, returnValue == 0);
    FICL_VM_ASSERT(vm, gotUncompressedSize == ficlSoftcoreUncompressedSize);
#endif /* FICL_WANT_LZ_SOFTCORE */
    vm->sourceId.i = -1;
    FICL_STRING_SET_POINTER(s, (char *)(ficlSoftcoreUncompressed));
    FICL_STRING_SET_LENGTH(s, ficlSoftcoreUncompressedSize);
    returnValue = ficlVmExecuteString(vm, s);
    vm->sourceId = oldSourceID;
#if FICL_WANT_LZ_SOFTCORE
    free(ficlSoftcoreUncompressed);
#endif /* FICL_WANT_LZ_SOFTCORE */
    FICL_VM_ASSERT(vm, returnValue != FICL_VM_STATUS_ERROR_EXIT);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq 0x17945(%rip), %rdi     # 0x1c1b0
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xf730
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $-0x1, 0x78(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x1a602(%rip), %rax     # 0x1ee98
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9720
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq -0x38(%rbp), %rdi
callq 0x3030
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/stack.c
// Function: ficlStackCreate
ficlStack *ficlStackCreate(ficlVm *vm, char *name, unsigned size)
{
    size_t totalSize = sizeof (ficlStack) + (size * sizeof (ficlCell));
    ficlStack *stack = ficlMalloc(totalSize);

    FICL_VM_ASSERT(vm, size != 0);
    FICL_VM_ASSERT(vm, stack != NULL);

    stack->size = size;
    stack->frame = NULL;

	stack->vm = vm;
	stack->name = name;

	ficlStackReset(stack);
    return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
shlq $0x3, %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf930
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
callq 0x4960
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/stack.c
// Function: ficlStackPop2Integer
ficl2Integer ficlStackPop2Integer(ficlStack *stack)
{
    ficl2Integer ret;
    ficlInteger high = ficlStackPopInteger(stack);
    ficlInteger low = ficlStackPopInteger(stack);
	FICL_2INTEGER_SET(high, low, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movups -0x38(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/stack.c
// Function: ficlStackPop2Unsigned
ficl2Unsigned ficlStackPop2Unsigned(ficlStack *stack)
{
    ficl2Unsigned ret;
    ficlUnsigned high = ficlStackPopUnsigned(stack);
    ficlUnsigned low = ficlStackPopUnsigned(stack);
	FICL_2UNSIGNED_SET(high, low, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movups -0x38(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/stack.c
// Function: ficlStackRoll
void ficlStackRoll(ficlStack *stack, int n)
{
    ficlCell c;
    ficlCell *cell;

    if (n == 0)
        return;
    else if (n > 0)
    {
        cell = stack->top - n;
        c = *cell;

        for (;n > 0; --n, cell++)
        {
            *cell = cell[1];
        }

        *cell = c;
    }
    else
    {
        cell = stack->top;
        c = *cell;

        for (; n < 0; ++n, cell--)
        {
            *cell = cell[-1];
        }

        *cell = c;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x4da6
jmp 0x4e5e
cmpl $0x0, -0xc(%rbp)
jle 0x4e0c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4dff
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x4dd3
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x4e5a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x4e4f
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x4e23
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x4e5c
jmp 0x4e5e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/stack.c
// Function: ficlStackWalk
void ficlStackWalk(ficlStack *stack, ficlStackWalkFunction callback, void *context, ficlInteger bottomToTop)
{
    int i;
    int depth;
	ficlCell *cell;
    FICL_STACK_CHECK(stack, 0, 0);

	depth = ficlStackDepth(stack);
	cell = bottomToTop ? stack->base : stack->top;
    for (i = 0; i < depth; i++)
    {
        if (callback(context, cell) == FICL_FALSE)
			break;
        cell += bottomToTop ? 1 : -1;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49b0
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4eb9
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
jmp 0x4ec5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x4f24
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpq $0x0, %rax
jne 0x4ef2
jmp 0x4f24
movq -0x20(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl $0x1, %eax
cmpq $0x0, %rdx
cmovnel %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4ed4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplay
void ficlStackDisplay(ficlStack *stack, ficlStackWalkFunction callback, void *context)
{
	ficlVm *vm = stack->vm;
	char buffer[128];
	struct stackContext myContext;

    FICL_STACK_CHECK(stack, 0, 0);

	sprintf(buffer, "[%s stack has %d entries, top at 0x%08x]\n", stack->name, ficlStackDepth(stack), stack->top);
	ficlVmTextOut(vm, buffer);

    if (callback == NULL)
    {
        myContext.vm = vm;
	    myContext.count = 0;
		context = &myContext;
		callback = ficlStackDisplayCallback;
    }
	ficlStackWalk(stack, callback, context, FICL_FALSE);

	sprintf(buffer, "[%s stack base at 0x%08x]\n", stack->name, stack->base);
	ficlVmTextOut(vm, buffer);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x49b0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rdx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0x1020f(%rip), %rsi     # 0x153a7
movb $0x0, %al
callq 0x32d0
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x95e0
cmpq $0x0, -0x10(%rbp)
jne 0x51e1
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0xa8(%rbp)
leaq -0xb8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x63(%rip), %rax        # 0x5240
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4e80
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
leaq 0x101bd(%rip), %rsi     # 0x153d1
movb $0x0, %al
callq 0x32d0
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x95e0
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplayCallback
static ficlInteger ficlStackDisplayCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[64];
    sprintf(buffer, "[0x%08x %3d]: %12d (0x%08x)\n", cell, context->count++, cell->i, cell->i);
	ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %r9
leaq 0x1020f(%rip), %rsi     # 0x15493
movb $0x0, %al
callq 0x32d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
callq 0x95e0
movq $-0x1, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayDataStackSimple
void ficlVmDisplayDataStackSimple(ficlVm *vm)
{
    ficlStack *stack = vm->dataStack;
    char buffer[32];
    struct stackContext context;

    FICL_STACK_CHECK(stack, 0, 0);

    sprintf(buffer, "[%d] ", ficlStackDepth(stack));
    ficlVmTextOut(vm, buffer);

    context.vm = vm;
    context.count = 0;
    ficlStackWalk(stack, ficlStackDisplaySimpleCallback, &context, FICL_TRUE);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49b0
movq -0x50(%rbp), %rdi
movl %eax, %edx
leaq 0x100d6(%rip), %rsi     # 0x153ec
movb $0x0, %al
callq 0x32d0
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95e0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1c(%rip), %rsi        # 0x5360
leaq -0x48(%rbp), %rdx
movq $-0x1, %rcx
callq 0x4e80
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplaySimpleCallback
static ficlInteger ficlStackDisplaySimpleCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[32];
    sprintf(buffer, "%s%d", context->count ? " " : "", cell->i);
    context->count++;
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x1001c(%rip), %rdx     # 0x153a6
leaq 0x113f2(%rip), %rax     # 0x16783
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x1010a(%rip), %rsi     # 0x154b0
movb $0x0, %al
callq 0x32d0
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x95e0
movq $-0x1, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayReturnStack
void ficlVmDisplayReturnStack(ficlVm *vm)
{
    struct stackContext context;
	context.vm = vm;
	context.count = 0;
	context.dictionary = ficlVmGetDictionary(vm);
    ficlStackDisplay(vm->returnStack, ficlReturnStackDisplayCallback, &context);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
leaq 0x19(%rip), %rsi        # 0x5430
leaq -0x20(%rbp), %rdx
callq 0x5130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlReturnStackDisplayCallback
static ficlInteger ficlReturnStackDisplayCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[128];

    sprintf(buffer, "[0x%08x %3d] %12d (0x%08x)", cell, context->count++, cell->i, cell->i);

    /*
    ** Attempt to find the word that contains the return
    ** stack address (as if it is part of a colon definition).
    ** If this works, also print the name of the word.
    */
    if (ficlDictionaryIncludes(context->dictionary, cell->p))
    {
        ficlWord *word = ficlDictionaryFindEnclosingWord(context->dictionary, cell->p);
        if (word)
        {
            int offset = (ficlCell *)cell->p - &word->param[0];
            sprintf(buffer + strlen(buffer), ", %s + %d ", word->name, offset);
        }
    }
	strcat(buffer, "\n");
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq (%rax), %r9
leaq 0x1003b(%rip), %rsi     # 0x154b5
movb $0x0, %al
callq 0x32d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x11c40
cmpl $0x0, %eax
je 0x5527
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x11ca0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x5525
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0xa8(%rbp), %rcx
addq $0x28, %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x30d0
movq -0xb8(%rbp), %rdi
addq %rax, %rdi
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdx
movl -0xac(%rbp), %ecx
leaq 0xffb2(%rip), %rsi      # 0x154d0
movb $0x0, %al
callq 0x32d0
jmp 0x5527
leaq -0xa0(%rbp), %rdi
leaq 0xfe70(%rip), %rsi      # 0x153a5
callq 0x32c0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x95e0
movq $-0x1, %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveParseStepList
void ficlPrimitiveParseStepList(ficlVm *vm)
{
    int i;
    ficlSystem *system = vm->callback.system;
    FICL_VM_ASSERT(vm, system);

    ficlVmTextOut(vm, "Parse steps:\n");
    ficlVmTextOut(vm, "lookup\n");

    for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
    {
        if (system->parseList[i] != NULL)
        {
            ficlVmTextOut(vm, system->parseList[i]->name);
            ficlVmTextOut(vm, "\n");
        }
        else break;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfe6f(%rip), %rsi      # 0x153f2
callq 0x95e0
movq -0x8(%rbp), %rdi
leaq 0xfe6d(%rip), %rsi      # 0x15400
callq 0x95e0
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x55f0
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x60(%rax,%rcx,8)
je 0x55e1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x60(%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
callq 0x95e0
movq -0x8(%rbp), %rdi
leaq 0xfdcb(%rip), %rsi      # 0x153a5
callq 0x95e0
jmp 0x55e3
jmp 0x55f0
jmp 0x55e5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x559f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveForget
static void ficlPrimitiveForget(ficlVm *vm)
{
    void *where;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash = dictionary->compilationWordlist;

    ficlPrimitiveTick(vm);
    where = ((ficlWord *)ficlStackPopPointer(vm->dataStack))->name;
    ficlHashForget(hash, where);
    dictionary->here = FICL_POINTER_TO_CELL(where);

    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 -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f40
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10200
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveListEnv
static void ficlPrimitiveListEnv(ficlVm *vm)
{
    ficlDictionary *dictionary = vm->callback.system->environment;
    ficlHash *hash = dictionary->forthWordlist;
    ficlWord *word;
    unsigned i;
    int counter = 0;

    for (i = 0; i < hash->size; i++)
    {
        for (word = hash->table[i]; word != NULL; word = word->link, counter++)
        {
            ficlVmTextOut(vm, word->name);
            ficlVmTextOut(vm, "\n");
        }
    }

    sprintf(vm->pad, "Environment: %d words, %ld cells used of %u total\n", 
        counter, (long) (dictionary->here - dictionary->base), dictionary->size);
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x5b8d
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5b80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x95e0
movq -0x8(%rbp), %rdi
leaq 0xf840(%rip), %rsi      # 0x153a5
callq 0x95e0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5b42
jmp 0x5b82
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b26
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movl -0x28(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq $0xb8, %rax
subq %rax, %rcx
sarq $0x3, %rcx
movq -0x10(%rbp), %rax
movl 0xac(%rax), %r8d
leaq 0xf948(%rip), %rsi      # 0x1550d
movb $0x0, %al
callq 0x32d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveEnvConstant
static void ficlPrimitiveEnvConstant(ficlVm *vm)
{
    unsigned value;
    FICL_STACK_CHECK(vm->dataStack, 1, 0);

    ficlVmGetWordToPad(vm);
    value = ficlStackPopUnsigned(vm->dataStack);
    ficlDictionarySetConstant(ficlSystemGetEnvironment(vm->callback.system), vm->pad, (ficlUnsigned)value);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92d0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3ce0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x11540
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveEnv2Constant
static void ficlPrimitiveEnv2Constant(ficlVm *vm)
{
    ficl2Integer value;

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

    ficlVmGetWordToPad(vm);
    value = ficlStackPop2Integer(vm->dataStack);
    ficlDictionarySet2Constant(ficlSystemGetEnvironment(vm->callback.system), vm->pad, value);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92d0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b90
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 0x18(%rax), %rdi
callq 0x3ce0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x11640
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveDebugXT
static void ficlPrimitiveDebugXT(ficlVm *vm)
{
    ficlWord *xt    = ficlStackPopPointer(vm->dataStack);
    ficlWordKind   wk    = ficlWordClassify(xt);

    ficlStackPushPointer(vm->dataStack, xt);
    ficlPrimitiveSeeXT(vm);

    switch (wk)
    {
    case FICL_WORDKIND_COLON:
    case FICL_WORDKIND_DOES:
        /*
        ** Run the colon code and set a breakpoint at the next instruction
        */
        ficlVmExecuteWord(vm, xt);
        ficlVmSetBreak(vm, &(vm->callback.system->breakpoint));
        break;

    default:
        ficlVmExecuteWord(vm, xt);
        break;
    }

    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, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10720
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rdi
callq 0x6060
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x2, %eax
je 0x5d0a
jmp 0x5d00
movl -0x18(%rbp), %eax
subl $0x7, %eax
jne 0x5d31
jmp 0x5d0a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6640
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0xb8, %rsi
callq 0x62f0
jmp 0x5d3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6640
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveForgetWid
static void ficlPrimitiveForgetWid(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash;

    hash = (ficlHash *)ficlStackPopPointer(vm->dataStack);
    ficlHashForget(hash, dictionary->here);

    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
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x10200
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlVmSetBreak
static void ficlVmSetBreak(ficlVm *vm, ficlBreakpoint *pBP)
{
    ficlWord *pStep = ficlSystemLookup(vm->callback.system, "step-break");
    FICL_VM_ASSERT(vm, pStep);

    pBP->address = vm->ip;
    pBP->oldXT = *vm->ip;
    *vm->ip = pStep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xf161(%rip), %rsi      # 0x15470
callq 0x3c80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveStepOver
static void ficlPrimitiveStepOver(ficlVm *vm)
{
    ficlWord *word;
    ficlWordKind kind;
    ficlWord *pStep = ficlSystemLookup(vm->callback.system, "step-break");
    FICL_VM_ASSERT(vm, pStep);

    word = *vm->ip;
    kind = ficlWordClassify(word);

    switch (kind)
    {
    case FICL_WORDKIND_COLON: 
    case FICL_WORDKIND_DOES:
        /*
        ** assume that the next ficlCell holds an instruction 
        ** set a breakpoint there and return to the inner interpreter
        */
        vm->callback.system->breakpoint.address = vm->ip + 1;
        vm->callback.system->breakpoint.oldXT =  vm->ip[1];
        vm->ip[1] = pStep;
        break;

    default:
        ficlPrimitiveStepIn(vm);
        break;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xf085(%rip), %rsi      # 0x15470
callq 0x3c80
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10720
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x6426
jmp 0x641c
movl -0x24(%rbp), %eax
subl $0x7, %eax
jne 0x646e
jmp 0x6426
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0xc0(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x6477
movq -0x8(%rbp), %rdi
callq 0x6380
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmCreate
ficlVm *ficlVmCreate(ficlVm *vm, unsigned nPStack, unsigned nRStack)
{
    if (vm == NULL)
    {
        vm = (ficlVm *)ficlMalloc(sizeof (ficlVm));
        FICL_ASSERT(NULL, vm);
        memset(vm, 0, sizeof (ficlVm));
    }

    if (vm->dataStack)
        ficlStackDestroy(vm->dataStack);
    vm->dataStack = ficlStackCreate(vm, "data", nPStack);

    if (vm->returnStack)
        ficlStackDestroy(vm->returnStack);
    vm->returnStack = ficlStackCreate(vm, "return", nRStack);

#if FICL_WANT_FLOAT
    if (vm->floatStack)
        ficlStackDestroy(vm->floatStack);
    vm->floatStack = ficlStackCreate(vm, "float", nPStack);
#endif

    ficlVmReset(vm);
    return vm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x64e7
movl $0x918, %edi            # imm = 0x918
callq 0xf930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x918, %edx            # imm = 0x918
callq 0x3120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x64ff
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4980
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xf49f(%rip), %rsi      # 0x159ac
callq 0x48e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x6535
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x4980
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
leaq 0xf46e(%rip), %rsi      # 0x159b1
callq 0x48e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x656b
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4980
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xf7bb(%rip), %rsi      # 0x15d34
callq 0x48e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rdi
callq 0x65a0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmReset
void ficlVmReset(ficlVm *vm)
{
    ficlVmQuit(vm);
    ficlStackReset(vm->dataStack);
#if FICL_WANT_FLOAT
    ficlStackReset(vm->floatStack);
#endif
    vm->base        = 10;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9520
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4960
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4960
movq -0x8(%rbp), %rax
movq $0xa, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmDestroy
void ficlVmDestroy(ficlVm *vm)
{
    if (vm)
    {
        ficlFree(vm->dataStack);
        ficlFree(vm->returnStack);
#if FICL_WANT_FLOAT
        ficlFree(vm->floatStack);
#endif
        ficlFree(vm);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6633
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xf980
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0xf980
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0xf980
movq -0x8(%rbp), %rdi
callq 0xf980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmThrowError
void ficlVmThrowError(ficlVm *vm, char *fmt, ...)
{
    va_list list;

    va_start(list, fmt);
    vsprintf(vm->pad, fmt, list);
    va_end(list);
	strcat(vm->pad, "\n");

    ficlVmErrorOut(vm, vm->pad);
    longjmp(*(vm->exceptionHandler), FICL_VM_STATUS_ERROR_EXIT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x8df8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3280
leaq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0xc537(%rip), %rsi      # 0x153a5
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x9610
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0xfffffefc, %esi       # imm = 0xFFFFFEFC
callq 0x3260
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmOptimizeJumpToJump
static void ficlVmOptimizeJumpToJump(ficlVm *vm, ficlIp ip)
	{
	ficlIp destination;
	switch ((ficlInstruction)(*ip))
		{
		case ficlInstructionBranchParenWithCheck:
			*ip = (ficlWord *)ficlInstructionBranchParen;
			goto RUNTIME_FIXUP;

		case ficlInstructionBranch0ParenWithCheck:
			*ip = (ficlWord *)ficlInstructionBranch0Paren;
RUNTIME_FIXUP:
			ip++;
			destination = ip + *(int *)ip;
			switch ((ficlInstruction)*destination)
			{
				case ficlInstructionBranchParenWithCheck:
					/* preoptimize where we're jumping to */
					ficlVmOptimizeJumpToJump(vm, destination);
				case ficlInstructionBranchParen:
				{
					destination++;
					destination += *(int *)destination;
					*ip = (ficlWord *)(destination - ip);
					break;
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
subq $0x30, %rax
je 0x8ed2
jmp 0x8ec3
movq -0x20(%rbp), %rax
subq $0x32, %rax
je 0x8ee0
jmp 0x8f6f
movq -0x10(%rbp), %rax
movl $0x31, %ecx
movq %rcx, (%rax)
jmp 0x8eec
movq -0x10(%rbp), %rax
movl $0x33, %ecx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
subq $0x30, %rax
je 0x8f26
jmp 0x8f1a
movq -0x28(%rbp), %rax
subq $0x31, %rax
je 0x8f33
jmp 0x8f6d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8ea0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x3, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x8f6f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmGetString
char *ficlVmGetString(ficlVm *vm, ficlCountedString *counted, char delimiter)
{
    ficlString s = ficlVmParseStringEx(vm, delimiter, 0);

    if (FICL_STRING_GET_LENGTH(s) > FICL_COUNTED_STRING_MAX)
    {
        FICL_STRING_SET_LENGTH(s, FICL_COUNTED_STRING_MAX);
    }

    strncpy(counted->text, FICL_STRING_GET_POINTER(s), FICL_STRING_GET_LENGTH(s));
    counted->text[FICL_STRING_GET_LENGTH(s)] = '\0';
    counted->length = (ficlUnsigned8)FICL_STRING_GET_LENGTH(s);

    return counted->text + FICL_STRING_GET_LENGTH(s) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movsbl -0x11(%rbp), %esi
callq 0x9030
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x100, -0x28(%rbp)     # imm = 0x100
jbe 0x8fde
movq $0x100, -0x28(%rbp)     # imm = 0x100
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3060
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
addq -0x28(%rbp), %rax
addq $0x1, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmParseStringEx
ficlString ficlVmParseStringEx(ficlVm *vm, char delimiter, char skipLeadingDelimiters)
{
    ficlString s;
    char *trace      = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    char c;

    if (skipLeadingDelimiters)
    {
        while ((trace != stop) && (*trace == delimiter))
            trace++;
    }

    FICL_STRING_SET_POINTER(s, trace);    /* mark start of text */

    for (c = *trace;
		(trace != stop) && (c != delimiter)
			&& (c != '\r') && (c != '\n');
		c = *++trace)
    {
        ;                   /* find next delimiter or end of line */
    }

                            /* set length of result */
    FICL_STRING_SET_LENGTH(s, trace - FICL_STRING_GET_POINTER(s));

    if ((trace != stop) && (*trace == delimiter))     /* gobble trailing delimiter */
        trace++;

    ficlVmUpdateTib(vm, trace);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x80(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
cmpb $0x0, -0x1a(%rbp)
je 0x90af
jmp 0x9074
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x32(%rbp)
je 0x9096
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x909f
jmp 0x90ad
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9074
jmp 0x90af
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x33(%rbp)
je 0x90fb
movsbl -0x31(%rbp), %ecx
movsbl -0x19(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x33(%rbp)
je 0x90fb
movsbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0x33(%rbp)
je 0x90fb
movsbl -0x31(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
testb $0x1, %al
jne 0x9104
jmp 0x911d
jmp 0x9106
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb 0x1(%rax), %al
movb %al, -0x31(%rbp)
jmp 0x90c0
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x9151
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x9151
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmGetWord
ficlString ficlVmGetWord(ficlVm *vm)
{
    ficlString s = ficlVmGetWord0(vm);

    if (FICL_STRING_GET_LENGTH(s) == 0)
    {
        ficlVmThrow(vm, FICL_VM_STATUS_RESTART);
    }

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x91c0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x91b2
movq -0x18(%rbp), %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x8d90
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmGetWord0
ficlString ficlVmGetWord0(ficlVm *vm)
{
    char *trace      = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    ficlString s;
    ficlUnsigned length = 0;
    char c = 0;

    trace = ficlStringSkipSpace(trace, stop);
    FICL_STRING_SET_POINTER(s, trace);


	/* Please leave this loop this way; it makes Purify happier.  --lch */
    for (;;)
    {
		if (trace == stop)
			break;
		c = *trace;
		if (isspace((unsigned char)c))
			break;
        length++;
		trace++;
    }

    FICL_STRING_SET_LENGTH(s, length);

    if ((trace != stop) && isspace((unsigned char)c))    /* skip one trailing delimiter */
        trace++;

    ficlVmUpdateTib(vm, trace);

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x18(%rbp), %rcx
addq 0x80(%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x9226
jmp 0x9268
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
callq 0x3310
movq (%rax), %rax
movzbl -0x31(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x924e
jmp 0x9268
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x921a
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x92a3
callq 0x3310
movq (%rax), %rax
movzbl -0x31(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x92a3
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rdx
subq %rdx, %rcx
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)