LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmGetWordToPad
int ficlVmGetWordToPad(ficlVm *vm)
{
    ficlString s;
    char *pad = (char *)vm->pad;
    s = ficlVmGetWord(vm);

    if (FICL_STRING_GET_LENGTH(s) > FICL_PAD_SIZE)
        FICL_STRING_SET_LENGTH(s, FICL_PAD_SIZE);

    strncpy(pad, FICL_STRING_GET_POINTER(s), FICL_STRING_GET_LENGTH(s));
    pad[FICL_STRING_GET_LENGTH(s)] = '\0';
    return (int)(FICL_STRING_GET_LENGTH(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9180
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x800, -0x18(%rbp)     # imm = 0x800
jbe 0x931d
movq $0x800, -0x18(%rbp)     # imm = 0x800
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3060
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmPushTib
void ficlVmPushTib(ficlVm *vm, char *text, ficlInteger nChars, ficlTIB *pSaveTib)
{
    if (pSaveTib)
    {
        *pSaveTib = vm->tib;
    }

    vm->tib.text = text;
    vm->tib.end = text + nChars;
    vm->tib.index = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x94a3
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x80(%rcx), %rdx
movq %rdx, (%rax)
movq 0x88(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x90(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmQuit
void ficlVmQuit(ficlVm *vm)
{
    ficlStackReset(vm->returnStack);
    vm->restart    = 0;
    vm->ip          = NULL;
    vm->runningWord = NULL;
    vm->state       = FICL_VM_STATE_INTERPRET;
    vm->tib.text    = NULL;
    vm->tib.end     = NULL;
    vm->tib.index   = 0;
    vm->pad[0]      = '\0';
    vm->sourceId.i  = 0;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x4960
movq -0x8(%rbp), %rax
movw $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmThrowErrorVararg
void ficlVmThrowErrorVararg(ficlVm *vm, char *fmt, va_list list)
{
    vsprintf(vm->pad, fmt, list);
	/* well, we can try anyway, we're certainly not returning to our caller! */
    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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3280
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0xbd23(%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: ficlVmEvaluate
int ficlVmEvaluate(ficlVm *vm, char *s)
{
    int returnValue;
    ficlCell id = vm->sourceId;
	ficlString string;
    vm->sourceId.i = -1;
	FICL_STRING_SET_FROM_CSTRING(string, s);
    returnValue = ficlVmExecuteString(vm, string);
    vm->sourceId = id;
    return returnValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, 0x78(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9720
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x78(%rax)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmExecuteXT
int ficlVmExecuteXT(ficlVm *vm, ficlWord *pWord)
{
    int        except;
    jmp_buf    vmState;
    jmp_buf   *oldState;
    ficlWord *oldRunningWord;

    FICL_VM_ASSERT(vm, vm);
    FICL_VM_ASSERT(vm, vm->callback.system->exitInnerWord);
    
    /* 
    ** Save the runningword so that RESTART behaves correctly
    ** over nested calls.
    */
    oldRunningWord = vm->runningWord;
    /*
    ** Save and restore VM's jmp_buf to enable nested calls
    */
    oldState = vm->exceptionHandler;
    vm->exceptionHandler = &vmState; /* This has to come before the setjmp! */
    except = setjmp(vmState);

    if (except)
        ficlVmPopIP(vm);
    else
        ficlVmPushIP(vm, &(vm->callback.system->exitInnerWord));

    switch (except)
    {
    case 0:
        ficlVmExecuteWord(vm, pWord);
        ficlVmInnerLoop(vm, 0);
        break;

    case FICL_VM_STATUS_INNER_EXIT:
    case FICL_VM_STATUS_BREAK:
        break;

    case FICL_VM_STATUS_RESTART:
    case FICL_VM_STATUS_OUT_OF_TEXT:
    case FICL_VM_STATUS_USER_EXIT:
    case FICL_VM_STATUS_QUIT:
    case FICL_VM_STATUS_ERROR_EXIT:
    case FICL_VM_STATUS_ABORT:
    case FICL_VM_STATUS_ABORTQ:
    default:    /* user defined exit code?? */
        if (oldState)
        {
            vm->exceptionHandler = oldState;
            ficlVmThrow(vm, except);
        }
        break;
    }

    vm->exceptionHandler    = oldState;
    vm->runningWord = oldRunningWord;
    return (except);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x30(%rax)
leaq -0xe0(%rbp), %rdi
callq 0x3160
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x99a0
movq -0x8(%rbp), %rdi
callq 0x93f0
jmp 0x99b8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0xa0, %rsi
callq 0x9420
movl -0x14(%rbp), %eax
movl %eax, -0xf4(%rbp)
subl $0xfffffefb, %eax       # imm = 0xFFFFFEFB
je 0x9a30
jmp 0x99ca
movl -0xf4(%rbp), %eax
addl $0x104, %eax            # imm = 0x104
subl $0x4, %eax
jb 0x9a32
jmp 0x99dc
movl -0xf4(%rbp), %eax
subl $0xffffff00, %eax       # imm = 0xFFFFFF00
je 0x9a30
jmp 0x99eb
movl -0xf4(%rbp), %eax
subl $-0x38, %eax
je 0x9a32
jmp 0x99f8
movl -0xf4(%rbp), %eax
addl $0x2, %eax
subl $0x2, %eax
jb 0x9a32
jmp 0x9a08
movl -0xf4(%rbp), %eax
testl %eax, %eax
jne 0x9a34
jmp 0x9a14
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6640
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6670
jmp 0x9a5b
jmp 0x9a5b
jmp 0x9a34
cmpq $0x0, -0xe8(%rbp)
je 0x9a59
movq -0xe8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8d90
jmp 0x9a5b
movq -0xe8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0xf0(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movl -0x14(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/vm.c
// Function: ficlVmParseWord
int ficlVmParseWord(ficlVm *vm, ficlString name)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlWord *tempFW;

    FICL_VM_DICTIONARY_CHECK(vm, dictionary, 0);
    FICL_STACK_CHECK(vm->dataStack, 0, 0);

#if FICL_WANT_LOCALS
    if (vm->callback.system->localsCount > 0)
    {
        tempFW = ficlSystemLookupLocal(vm->callback.system, name);
    }
    else
#endif
    tempFW = ficlDictionaryLookup(dictionary, name);

    if (vm->state == FICL_VM_STATE_INTERPRET)
    {
        if (tempFW != NULL)
        {
            if (ficlWordIsCompileOnly(tempFW))
            {
                ficlVmThrowError(vm, "Error: FICL_VM_STATE_COMPILE only!");
            }

            ficlVmExecuteWord(vm, tempFW);
            return 1; /* true */
        }
    }

    else /* (vm->state == FICL_VM_STATE_COMPILE) */
    {
        if (tempFW != NULL)
        {
            if (ficlWordIsImmediate(tempFW))
            {
                ficlVmExecuteWord(vm, tempFW);
            }
            else
            {
				if (tempFW->flags & FICL_WORD_INSTRUCTION)
	                ficlDictionaryAppendUnsigned(dictionary, (ficlInteger)tempFW->code);
				else
	                ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(tempFW));
            }
            return 1; /* true */
        }
    }

    return 0; /* false */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8f80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x114a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x9da0
cmpq $0x0, -0x30(%rbp)
je 0x9d9e
movq -0x30(%rbp), %rdi
callq 0x106e0
cmpl $0x0, %eax
je 0x9d88
movq -0x20(%rbp), %rdi
leaq 0xbc59(%rip), %rsi      # 0x159da
movb $0x0, %al
callq 0x8dc0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6640
movl $0x1, -0x4(%rbp)
jmp 0x9e08
jmp 0x9e01
cmpq $0x0, -0x30(%rbp)
je 0x9dff
movq -0x30(%rbp), %rdi
callq 0x106a0
cmpl $0x0, %eax
je 0x9dc4
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6640
jmp 0x9df6
movq -0x30(%rbp), %rax
movzbl 0xa(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x9de7
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x11080
jmp 0x9df4
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x11010
jmp 0x9df6
movl $0x1, -0x4(%rbp)
jmp 0x9e08
jmp 0x9e01
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveParseStepParen
void ficlPrimitiveParseStepParen(ficlVm *vm)
{
    ficlString s;
    ficlWord *word = vm->runningWord;
    ficlParseStep pStep = (ficlParseStep)(word->param->fn);

    FICL_STRING_SET_LENGTH(s, ficlStackPopInteger(vm->dataStack));
    FICL_STRING_SET_POINTER(s, ficlStackPopPointer(vm->dataStack));
    
    ficlStackPushInteger(vm->dataStack, (*pStep)(vm, s));

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq *%rax
movq -0x30(%rbp), %rdi
movslq %eax, %rsi
callq 0x4c90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveTick
void ficlPrimitiveTick(ficlVm *vm)
{
    ficlWord *word = NULL;
    ficlString name = ficlVmGetWord(vm);

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

    word = ficlDictionaryLookup(ficlVmGetDictionary(vm), name);
    if (!word)
        ficlVmThrowError(vm, "%.*s not found", FICL_STRING_GET_LENGTH(name), FICL_STRING_GET_POINTER(name));
    ficlStackPushPointer(vm->dataStack, word);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x114a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9fa3
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0xbbb4(%rip), %rsi      # 0x15b50
movb $0x0, %al
callq 0x8dc0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveNumberSign
static void ficlPrimitiveNumberSign(ficlVm *vm)
{
    ficlCountedString *counted;
    ficl2Unsigned u;
    ficl2UnsignedQR uqr;

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

    counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
    u = ficlStackPop2Unsigned(vm->dataStack);
    uqr = ficl2UnsignedDivide(u, (ficlUnsigned16)(vm->base));
    counted->text[counted->length++] = ficlDigitToCharacter(uqr.remainder);
    ficlStackPush2Unsigned(vm->dataStack, uqr.quotient);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4be0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzwl %ax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x13740
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %edi
callq 0xfba0
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movb (%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, (%rsi)
movzbl %cl, %ecx
movb %dl, 0x1(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4cf0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveNumberSignGreater
static void ficlPrimitiveNumberSignGreater(ficlVm *vm)
{
    ficlCountedString *counted;

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

    counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
    counted->text[counted->length] = 0;
    ficlStringReverse(counted->text);
    ficlStackDrop(vm->dataStack, 2);
    ficlStackPushPointer(vm->dataStack, counted->text);
    ficlStackPushUnsigned(vm->dataStack, counted->length);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb $0x0, 0x1(%rax,%rcx)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xfb10
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x2, %esi
callq 0x49e0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %esi
callq 0x4cc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveNumberSignS
static void ficlPrimitiveNumberSignS(ficlVm *vm)
{
    ficlCountedString *counted;
    ficl2Unsigned u;
    ficl2UnsignedQR uqr;

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

    counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
    u = ficlStackPop2Unsigned(vm->dataStack);

    do 
    {
        uqr = ficl2UnsignedDivide(u, (ficlUnsigned16)(vm->base));
        counted->text[counted->length++] = ficlDigitToCharacter(uqr.remainder);
		u = uqr.quotient;
    }
    while (FICL_2UNSIGNED_NOT_ZERO(u));

    ficlStackPush2Unsigned(vm->dataStack, u);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4be0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzwl %ax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x13740
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %edi
callq 0xfba0
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movb (%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, (%rsi)
movzbl %cl, %ecx
movb %dl, 0x1(%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x20(%rbp)
movb %al, -0x61(%rbp)
jne 0xc054
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0xbfcf
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4cf0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitivePlusLoopCoIm
static void ficlPrimitivePlusLoopCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x37, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x12dba(%rip), %rdx     # 0x1eea0
callq 0xf3b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x12da9(%rip), %rdx     # 0x1eea3
callq 0xf410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveDot
static void ficlPrimitiveDot(ficlVm *vm)
{
    ficlCell c;

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

    c = ficlStackPop(vm->dataStack);
    ficlLtoa((c).i, vm->pad, vm->base);
    strcat(vm->pad, " ");
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
callq 0xfc30
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0xa61e(%rip), %rsi      # 0x16783
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveDotQuoteCoIm
static void ficlPrimitiveDotQuoteCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlWord *pType = ficlSystemLookup(vm->callback.system, "type");
    FICL_VM_ASSERT(vm, pType);
    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionStringLiteralParen);
    dictionary->here = FICL_POINTER_TO_CELL(ficlVmGetString(vm, (ficlCountedString *)dictionary->here, '\"'));
    ficlDictionaryAlign(dictionary);
    ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(pType));
    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 0x18(%rax), %rdi
leaq 0xa246(%rip), %rsi      # 0x163fe
callq 0x3c80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x50, %esi
callq 0x11080
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x22, %edx
callq 0x8fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10f70
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveColon
static void ficlPrimitiveColon(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

    vm->state = FICL_VM_STATE_COMPILE;
    markControlTag(vm, colonTag);
    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionColonParen, FICL_WORD_DEFAULT | FICL_WORD_SMUDGED);
#if FICL_WANT_LOCALS
    vm->callback.system->localsCount = 0;
#endif
    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), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x1, 0x50(%rax)
movq -0x8(%rbp), %rdi
leaq 0x12c58(%rip), %rsi     # 0x1eea9
callq 0xf510
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x46, %ecx
movl $0x4, %r8d
callq 0x11220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveSemicolonCoIm
static void ficlPrimitiveSemicolonCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    matchControlTag(vm, colonTag);

#if FICL_WANT_LOCALS
    if (vm->callback.system->localsCount > 0)
    {
        ficlDictionary *locals = ficlSystemGetLocals(vm->callback.system);
        ficlDictionaryEmpty(locals, locals->forthWordlist->size);
            ficlDictionaryAppendUnsigned(dictionary, ficlInstructionUnlinkParen);
    }
    vm->callback.system->localsCount = 0;
#endif

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionSemiParen);
    vm->state = FICL_VM_STATE_INTERPRET;
    ficlDictionaryUnsmudge(dictionary);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12c05(%rip), %rsi     # 0x1eea9
callq 0xf4b0
movq -0x10(%rbp), %rdi
movl $0x2b, %esi
callq 0x11080
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x11720
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveToNumber
static void ficlPrimitiveToNumber(ficlVm *vm)
{
    ficlUnsigned length;
    char *trace;
    ficl2Unsigned accumulator;
    ficlUnsigned base = vm->base;
    ficlUnsigned c;
    ficlUnsigned digit;

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

    length = ficlStackPopUnsigned(vm->dataStack);
    trace = (char *)ficlStackPopPointer(vm->dataStack);
    accumulator = ficlStackPop2Unsigned(vm->dataStack);

    for (c = *trace; length > 0; c = *++trace, length--)
    {
        if (c < '0')
            break;

        digit = c - '0';

        if (digit > 9)
            digit = tolower(c) - 'a' + 10;
        /* 
        ** Note: following test also catches chars between 9 and a
        ** because 'digit' is unsigned! 
        */
        if (digit >= base)
            break;

        accumulator = ficl2UnsignedMultiplyAccumulate(accumulator, base, digit);
    }

    ficlStackPush2Unsigned(vm->dataStack, accumulator);
    ficlStackPushPointer(vm->dataStack, trace);
    ficlStackPushUnsigned(vm->dataStack, length);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4be0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xc47e
cmpq $0x30, -0x38(%rbp)
jae 0xc3f2
jmp 0xc47e
movq -0x38(%rbp), %rax
subq $0x30, %rax
movq %rax, -0x40(%rbp)
cmpq $0x9, -0x40(%rbp)
jbe 0xc41c
movq -0x38(%rbp), %rax
movl %eax, %edi
callq 0x3200
subl $0x61, %eax
addl $0xa, %eax
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0xc428
jmp 0xc47e
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x132b0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbq 0x1(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc3db
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4cf0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4cc0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveAccept
static void ficlPrimitiveAccept(ficlVm *vm)
{
    ficlUnsigned size;
    char *address;

	ficlUnsigned length;
	char *trace;
	char *end;

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

    trace = ficlVmGetInBuf(vm);
    end = ficlVmGetInBufEnd(vm);
    length = end - trace;
    if (length == 0)
        ficlVmThrow(vm, FICL_VM_STATUS_RESTART);

    /*
    ** Now we have something in the text buffer - use it 
    */
    size = ficlStackPopInteger(vm->dataStack);
    address = ficlStackPopPointer(vm->dataStack);

    length = (size < length) ? size : length;
    strncpy(address, trace, length);
    trace += length;
    ficlVmUpdateTib(vm, trace);
    ficlStackPushInteger(vm->dataStack, length);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x80(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc539
movq -0x8(%rbp), %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x8d90
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xc56f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xc577
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3060
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4c90
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveAllot
static void ficlPrimitiveAllot(ficlVm *vm)
{
    ficlDictionary *dictionary;
    ficlInteger i;

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

    dictionary = ficlVmGetDictionary(vm);
    i = ficlStackPopInteger(vm->dataStack);

    FICL_VM_DICTIONARY_CHECK(vm, dictionary, i);

    ficlVmDictionaryAllot(vm, dictionary, i);
    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 0x4b70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x9cc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveConstant
static void ficlPrimitiveConstant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

	ficlDictionaryAppendConstantInstruction(dictionary, name, ficlInstructionConstantParen, ficlStackPopInteger(vm->dataStack));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq -0x28(%rbp), %rdi
movq %rax, %r8
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x48, %ecx
callq 0x111c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveCount
static void ficlPrimitiveCount(ficlVm *vm)
{
    ficlCountedString *counted;

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


    counted = ficlStackPopPointer(vm->dataStack);
    ficlStackPushPointer(vm->dataStack, counted->text);
    ficlStackPushUnsigned(vm->dataStack, counted->length);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %esi
callq 0x4cc0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveCreate
static void ficlPrimitiveCreate(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionCreateParen, FICL_WORD_DEFAULT);
    ficlVmDictionaryAllotCells(vm, dictionary, 1);
    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), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4f, %ecx
xorl %r8d, %r8d
callq 0x11220
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x9cf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveDoCoIm
static void ficlPrimitiveDoCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4c, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x124dd(%rip), %rdx     # 0x1eea3
callq 0xf540
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x124b9(%rip), %rdx     # 0x1eea0
callq 0xf540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveElseCoIm
static void ficlPrimitiveElseCoIm(ficlVm *vm)
{
    ficlCell *patchAddr;
    ficlInteger offset;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x11080
movq -0x8(%rbp), %rdi
leaq 0x12459(%rip), %rsi     # 0x1eebb
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x12434(%rip), %rdx     # 0x1eebb
callq 0xf540
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x11080
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEmit
static void ficlPrimitiveEmit(ficlVm *vm)
{
    char *buffer = vm->pad;
    int i;


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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x95e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEndcaseCoIm
static void ficlPrimitiveEndcaseCoIm(ficlVm *vm)
{
	ficlUnsigned fixupCount;
    ficlDictionary *dictionary;
    ficlCell *patchAddr;
    ficlInteger offset;

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

    matchControlTag(vm, caseTag);

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

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

    dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionDrop);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4a70
movq %rax, -0x30(%rbp)
leaq 0x1237e(%rip), %rax     # 0x1eec2
cmpq %rax, -0x30(%rbp)
jne 0xcbc2
movq -0x8(%rbp), %rdi
leaq 0x1236d(%rip), %rsi     # 0x1eec2
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12340(%rip), %rsi     # 0x1eeb6
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x4cc0
movq -0x8(%rbp), %rdi
leaq 0x122f9(%rip), %rsi     # 0x1eeb6
callq 0xf510
movq -0x8(%rbp), %rdi
leaq 0x122e9(%rip), %rsi     # 0x1eeb6
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x6a, %esi
callq 0x11080
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0xcc47
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xcbfe
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEndofCoIm
static void ficlPrimitiveEndofCoIm(ficlVm *vm)
{
    ficlCell *patchAddr;
    ficlUnsigned fixupCount;
    ficlInteger offset;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1225a(%rip), %rsi     # 0x1eece
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12221(%rip), %rsi     # 0x1eeb6
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl $0x30, %esi
callq 0x11080
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x4cc0
movq -0x8(%rbp), %rdi
leaq 0x121c9(%rip), %rsi     # 0x1eeb6
callq 0xf510
movq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x11080
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEnvironmentQ
static void ficlPrimitiveEnvironmentQ(ficlVm *vm)
{
    ficlDictionary *environment;
    ficlWord *word;
    ficlString name;

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


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

    word = ficlDictionaryLookup(environment, name);

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

// Assembly:
pushq %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 -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x114a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcdad
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6640
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq $-0x1, %rsi
callq 0x4c90
jmp 0xcdbe
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEvaluate
static void ficlPrimitiveEvaluate(ficlVm *vm)
{
    ficlCell id;
    int result;
	ficlString string;

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


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

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, 0x78(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9720
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x78(%rax)
cmpl $0xfffffeff, -0x14(%rbp) # imm = 0xFFFFFEFF
je 0xce4b
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8d90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveFallthroughCoIm
static void ficlPrimitiveFallthroughCoIm(ficlVm *vm)
{
    ficlCell *patchAddr;
    ficlInteger offset;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11fea(%rip), %rsi     # 0x1eece
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11fb1(%rip), %rsi     # 0x1eeb6
callq 0xf4b0
movq -0x8(%rbp), %rdi
leaq 0x11fa1(%rip), %rsi     # 0x1eeb6
callq 0xf510
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x11080
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x4c60
movq -0x8(%rbp), %rdi
leaq 0x11f7b(%rip), %rsi     # 0x1eec2
callq 0xf510
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0x11080
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveFMSlashMod
static void ficlPrimitiveFMSlashMod(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficl2IntegerQR qr;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b90
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x139d0
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4c90
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4c90
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveHold
static void ficlPrimitiveHold(ficlVm *vm)
{
    ficlCountedString *counted;
    int i;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movb (%rsi), %cl
movb %cl, %dil
addb $0x1, %dil
movb %dil, (%rsi)
movzbl %cl, %ecx
movb %dl, 0x1(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveIfCoIm
static void ficlPrimitiveIfCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11d75(%rip), %rdx     # 0x1eebb
callq 0xf540
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveLoopCoIm
static void ficlPrimitiveLoopCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x35, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11cda(%rip), %rdx     # 0x1eea0
callq 0xf3b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11cc9(%rip), %rdx     # 0x1eea3
callq 0xf410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)