LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: resolveAbsBranch
static void resolveAbsBranch(ficlDictionary *dictionary, ficlVm *vm, char *wantTag)
{
    ficlCell *patchAddr;
    char *tag;

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

    tag = ficlStackPopPointer(vm->dataStack);
    /*
    ** Changed the comparison below to compare the pointers first (by popular demand)
    */
    if ((tag != wantTag) && strcmp(tag, wantTag))
    {
        ficlVmTextOut(vm, "Warning -- Unmatched control word: ");
        ficlVmTextOut(vm, wantTag);
        ficlVmTextOut(vm, "\n");
    }

    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
    *patchAddr = FICL_LVALUE_TO_CELL(dictionary->here);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xf47e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
cmpl $0x0, %eax
je 0xf47e
movq -0x10(%rbp), %rdi
leaq 0x6f57(%rip), %rsi      # 0x163b3
callq 0x95e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95e0
movq -0x10(%rbp), %rdi
leaq 0x5f2c(%rip), %rsi      # 0x153a5
callq 0x95e0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: matchControlTag
static void matchControlTag(ficlVm *vm, char *wantTag)
{
    char *tag;

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

    tag = (char *)ficlStackPopPointer(vm->dataStack);
    /*
    ** Changed the code below to compare the pointers first (by popular demand)
    */
    if ( (tag != wantTag) && strcmp(tag, wantTag) )
    {
        ficlVmThrowError(vm, "Error -- unmatched control structure \"%s\"", wantTag);
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0xf503
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3180
cmpl $0x0, %eax
je 0xf503
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6e8d(%rip), %rsi      # 0x16389
movb $0x0, %al
callq 0x8dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: do_find
static void do_find(ficlVm *vm, ficlString name, void *returnForFailure)
{
    ficlWord *word;

    word = ficlDictionaryLookup(ficlVmGetDictionary(vm), name);
    if (word)
    {
        ficlStackPushPointer(vm->dataStack, word);
        ficlStackPushInteger(vm->dataStack, (ficlWordIsImmediate(word) ? 1 : -1));
    }
    else
    {
        ficlStackPushPointer(vm->dataStack, returnForFailure);
        ficlStackPushUnsigned(vm->dataStack, 0);
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8f80
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x114a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xf602
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4c60
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x106a0
movq -0x30(%rbp), %rdi
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rsi
callq 0x4c90
jmp 0xf624
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4c60
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4cc0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: resolveForwardBranch
static void resolveForwardBranch(ficlDictionary *dictionary, ficlVm *vm, char *tag)
{
    ficlInteger offset;
    ficlCell *patchAddr;

    matchControlTag(vm, tag);

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

    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
    offset = dictionary->here - patchAddr;
    *patchAddr = FICL_LVALUE_TO_CELL(offset);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf4b0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/lzuncompress.c
// Function: ficlLzDecodeHeaderField
int ficlLzDecodeHeaderField(const unsigned char *data, int *byteOffset)
	{
	unsigned char id;
	int networkOrder;
	int length;

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

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

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

	return ficlNetworkUnsigned32(networkOrder);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movl (%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rdx)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0xfc, %eax
jge 0xf6ce
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf727
movl $0x0, -0x20(%rbp)
movzbl -0x19(%rbp), %edx
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0xfd, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %edx
shll $0x3, %edx
movl -0x24(%rbp), %ecx
shll $0x3, %ecx
leaq -0x20(%rbp), %rdi
movl $0x20, %r8d
callq 0x14470
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %edi
callq 0x14520
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/ficlplatform/unix.c
// Function: ficlCallbackDefaultTextOut
void  ficlCallbackDefaultTextOut(ficlCallback *callback, char *message)
{
    FICL_IGNORE(callback);
    if (message != NULL)
        fputs(message, stdout);
    else
        fflush(stdout);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf9cc
movq -0x10(%rbp), %rdi
movq 0xc616(%rip), %rax      # 0x1bfd8
movq (%rax), %rsi
callq 0x3110
jmp 0xf9db
movq 0xc605(%rip), %rax      # 0x1bfd8
movq (%rax), %rdi
callq 0x3220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/ficlplatform/unix.c
// Function: ficlFileStatus
int ficlFileStatus(char *filename, int *status)
{
    struct stat statbuf;
    if (stat(filename, &statbuf) == 0)
    {
        *status = statbuf.st_mode;
        return 0;
    }
    *status = ENOENT;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x31c0
cmpl $0x0, %eax
jne 0xfa2d
movl -0x90(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xfa3e
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/ficlplatform/unix.c
// Function: ficlFileSize
long ficlFileSize(ficlFile *ff)
{
    struct stat statbuf;
    if (ff == NULL)
        return -1;
	
    statbuf.st_size = -1;
    if (fstat(fileno(ff->f), &statbuf) != 0)
        return -1;
	
    return statbuf.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfa70
movq $-0x1, -0x8(%rbp)
jmp 0xfaa9
movq $-0x1, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31f0
movl %eax, %edi
leaq -0xa0(%rbp), %rsi
callq 0x32f0
cmpl $0x0, %eax
je 0xfaa1
movq $-0x1, -0x8(%rbp)
jmp 0xfaa9
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlAlignPointer
void *ficlAlignPointer(void *ptr)
{
#if FICL_PLATFORM_ALIGNMENT > 1
	intptr_t p = (intptr_t)ptr;
	if (p & (FICL_PLATFORM_ALIGNMENT - 1))
		ptr = (void *)((p & ~(FICL_PLATFORM_ALIGNMENT - 1)) + FICL_PLATFORM_ALIGNMENT);
#endif
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0xfafe
movq -0x10(%rbp), %rax
andq $-0x8, %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlStringReverse
char *ficlStringReverse( char *string )    
{                               /* reverse a string in-place */
    int i = strlen(string);
    char *p1 = string;          /* first char of string */
    char *p2 = string + i - 1;  /* last non-NULL char of string */
    char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xfb8f
jmp 0xfb4b
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xfb8d
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movb -0x21(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xfb4b
jmp 0xfb8f
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlIsPowerOfTwo
int ficlIsPowerOfTwo(ficlUnsigned u)
{
    int i = 1;
    ficlUnsigned t = 2;

    for (; ((t <= u) && (t != 0)); i++, t <<= 1)
    {
        if (u == t)
            return i;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq $0x2, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
ja 0xfbf1
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xfbfa
jmp 0xfc24
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xfc0c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfc2b
jmp 0xfc0e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0xfbd7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlUltoa
char *ficlUltoa(ficlUnsigned value, char *string, int radix )
{                               /* convert long to string, any base */
    char *cp = string;
    ficl2Unsigned ud;
    ficl2UnsignedQR result;

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

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

    *cp++ = '\0';

    return ficlStringReverse(string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xfe4c
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x30, (%rax)
jmp 0xfeec
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, %al
cmpq $0x0, -0x30(%rbp)
movb %al, -0x71(%rbp)
jne 0xfe83
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xfe8c
jmp 0xfeea
movslq -0x14(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x13740
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
leaq 0xf00c(%rip), %rax      # 0x1eee0
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xfe6c
jmp 0xfeec
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0xfb10
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlStringCaseFold
char *ficlStringCaseFold(char *cp)
{
    char *oldCp = cp;

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

    return oldCp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xff6f
callq 0x3310
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xff61
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
callq 0x3200
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xff24
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlStrincmp
int ficlStrincmp(char *cp1, char *cp2, ficlUnsigned count)
{
    int i = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jae 0x10015
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x3200
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %edi
callq 0x3200
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xffd6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1001c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xffeb
movl $0x0, -0x4(%rbp)
jmp 0x1001c
jmp 0xffed
jmp 0xffef
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xff9b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlStringSkipSpace
char *ficlStringSkipSpace(char *cp, char *end)
{
    FICL_ASSERT(NULL, cp);

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

    return cp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x11(%rbp)
je 0x10073
callq 0x3310
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1007c
jmp 0x1008a
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10040
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/utility.c
// Function: ficlCompatibilityTextOutCallback
void ficlCompatibilityTextOutCallback(ficlCallback *callback, char *text, ficlCompatibilityOutputFunction outputFunction)
{
	char buffer[256];
	char *bufferStop = buffer + sizeof(buffer) - 1;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x120(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
addq $-0x1, %rax
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x100ef
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
jmp 0x101eb
jmp 0x100f1
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x101eb
movl $0x0, -0x12c(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x139(%rbp)
je 0x10141
movq -0x138(%rbp), %rax
cmpq -0x128(%rbp), %rax
setb %al
movb %al, -0x139(%rbp)
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x1014d
jmp 0x101c1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x140(%rbp)
subl $0xa, %eax
je 0x1017c
jmp 0x10161
movl -0x140(%rbp), %eax
subl $0xd, %eax
jne 0x10194
jmp 0x1016e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x10116
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x12c(%rbp)
jmp 0x101bc
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x138(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x138(%rbp)
movb %cl, (%rax)
jmp 0x10116
movq -0x138(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdi
leaq -0x120(%rbp), %rsi
movl -0x12c(%rbp), %edx
callq *%rax
jmp 0x100f1
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/hash.c
// Function: ficlHashForget
void ficlHashForget(ficlHash *hash, void *where)
{
    ficlWord *pWord;
    unsigned i;

    FICL_ASSERT_PHASH(hash, hash);
    FICL_ASSERT_PHASH(hash, where);

    for (i = 0; i < hash->size; i++)
    {
        pWord = hash->table[i];

        while ((void *)pWord >= where)
        {
            pWord = pWord->link;
        }

        hash->table[i] = pWord;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x10261
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x10246
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1022f
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, 0x18(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10213
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/hash.c
// Function: ficlHashCode
ficlUnsigned16 ficlHashCode(ficlString s)
{   
    /* hashPJW */
    ficlUnsigned8 *trace;
    ficlUnsigned16 code = (ficlUnsigned16)s.length;
    ficlUnsigned16 shift = 0;

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

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

    return (ficlUnsigned16)code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x18(%rbp), %rax
movw %ax, -0x22(%rbp)
movw $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x102a0
movw $0x0, -0x2(%rbp)
jmp 0x1034b
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0x102c4
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x102cd
jmp 0x10343
movzwl -0x22(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x3200
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
movw %ax, -0x24(%rbp)
cmpw $0x0, -0x24(%rbp)
je 0x10324
movzwl -0x24(%rbp), %eax
sarl $0x8, %eax
movzwl %ax, %ecx
movzwl -0x22(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0x22(%rbp)
movzwl -0x24(%rbp), %ecx
movzwl -0x22(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0x22(%rbp)
jmp 0x10326
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x102a8
movw -0x22(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/hash.c
// Function: ficlHashInsertWord
void ficlHashInsertWord(ficlHash *hash, ficlWord *word)
{
    ficlWord **pList;

    FICL_ASSERT_PHASH(hash, hash);
    FICL_ASSERT_PHASH(hash, word);

    if (hash->size == 1)
    {
        pList = hash->table;
    }
    else
    {
        pList = hash->table + (word->hash % hash->size);
    }

    word->link = *pList;
    *pList = word;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x10384
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x103b2
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movq -0x20(%rbp), %rax
movl %edx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/hash.c
// Function: ficlHashLookup
ficlWord *ficlHashLookup(ficlHash *hash, ficlString name, ficlUnsigned16 hashCode)
{
    ficlUnsigned nCmp = name.length;
    ficlWord *word;
    ficlUnsigned16 hashIdx;

    if (nCmp > FICL_NAME_LENGTH)
        nCmp = FICL_NAME_LENGTH;

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

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

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1f, -0x30(%rbp)
jbe 0x10402
movq $0x1f, -0x30(%rbp)
jmp 0x10404
cmpq $0x0, -0x20(%rbp)
je 0x104a0
movq -0x20(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jbe 0x1042f
movzwl -0x22(%rbp), %eax
movq -0x20(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movw %dx, %ax
movw %ax, -0x3a(%rbp)
jmp 0x10435
movw $0x0, -0x3a(%rbp)
movq -0x20(%rbp), %rax
movzwl -0x3a(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1048e
movq -0x38(%rbp), %rax
movzbl 0xb(%rax), %eax
cmpq -0x18(%rbp), %rax
jne 0x1047f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0xff80
cmpl $0x0, %eax
jne 0x1047f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x104a8
jmp 0x10481
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x10446
jmp 0x10490
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x10404
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/hash.c
// Function: ficlHashReset
void ficlHashReset(ficlHash *hash)
{
    unsigned i;

    FICL_ASSERT_PHASH(hash, hash);

    for (i = 0; i < hash->size; i++)
    {
        hash->table[i] = NULL;
    }

    hash->link = NULL;
    hash->name = NULL;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x104f6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x104cf
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/callback.c
// Function: ficlCallbackTextOut
void ficlCallbackTextOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction textOut = NULL;

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

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

    (textOut)(callback, text);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1057b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10548
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10579
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10577
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x10577
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10510
jmp 0x105c9
jmp 0x10579
jmp 0x1057b
cmpq $0x0, -0x18(%rbp)
jne 0x105a9
leaq 0xef2f(%rip), %rax      # 0x1f4b8
cmpq $0x0, (%rax)
je 0x105a9
leaq 0xef22(%rip), %rax      # 0x1f4b8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x105bb
leaq -0xc17(%rip), %rax      # 0xf9a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/callback.c
// Function: ficlCallbackErrorOut
void ficlCallbackErrorOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction errorOut = NULL;

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

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

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

    (errorOut)(callback, text);

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1063b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10608
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10639
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10637
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq %rcx, %rax
je 0x10637
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x105d0
jmp 0x1068d
jmp 0x10639
jmp 0x1063b
cmpq $0x0, -0x18(%rbp)
jne 0x10669
leaq 0xee6f(%rip), %rax      # 0x1f4b8
cmpq $0x0, (%rax)
je 0x10669
leaq 0xee62(%rip), %rax      # 0x1f4b8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1067f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10510
jmp 0x1068d
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/extras.c
// Function: ficlSystemCompileExtras
void ficlSystemCompileExtras(ficlSystem *system)
{
    ficlDictionary *dictionary = ficlSystemGetDictionary(system);

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

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

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3cc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4bd1(%rip), %rsi      # 0x15475
leaq 0xc5(%rip), %rdx        # 0x10970
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5ce3(%rip), %rsi      # 0x165a0
leaq 0xcc(%rip), %rdx        # 0x10990
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5ccf(%rip), %rsi      # 0x165a5
leaq 0x343(%rip), %rdx       # 0x10c20
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5cbf(%rip), %rsi      # 0x165ae
leaq 0x47a(%rip), %rdx       # 0x10d70
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5cad(%rip), %rsi      # 0x165b5
leaq 0x511(%rip), %rdx       # 0x10e20
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5c9a(%rip), %rsi      # 0x165bb
movl $0xf4240, %edx          # imm = 0xF4240
callq 0x11540
movq -0x10(%rbp), %rdi
leaq 0x5c90(%rip), %rsi      # 0x165c6
leaq 0x513(%rip), %rdx       # 0x10e50
xorl %ecx, %ecx
callq 0x117d0
movq -0x10(%rbp), %rdi
leaq 0x5c7b(%rip), %rsi      # 0x165ca
leaq 0x54a(%rip), %rdx       # 0x10ea0
xorl %ecx, %ecx
callq 0x117d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSpewHash
static void ficlPrimitiveSpewHash(ficlVm *vm)
{
    ficlHash *hash = ficlVmGetDictionary(vm)->forthWordlist;
    ficlWord *word;
    FILE *f;
    unsigned i;
    unsigned hashSize = hash->size;

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

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

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

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

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

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

        fprintf(f, "\n");
    }

    fclose(f);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x92d0
cmpl $0x0, %eax
jne 0x10c63
movq -0x8(%rbp), %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x8d90
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x5df2(%rip), %rsi      # 0x16a67
callq 0x3290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10c9a
movq -0x8(%rbp), %rdi
leaq 0x5994(%rip), %rsi      # 0x16624
callq 0x95e0
jmp 0x10d60
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x10d57
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10ce1
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10cc4
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x2c(%rbp), %ecx
leaq 0x5947(%rip), %rsi      # 0x16639
movb $0x0, %al
callq 0x3190
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10d37
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x591c(%rip), %rsi      # 0x1663f
movb $0x0, %al
callq 0x3190
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10d09
movq -0x20(%rbp), %rdi
leaq 0x4663(%rip), %rsi      # 0x153a5
movb $0x0, %al
callq 0x3190
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10ca1
movq -0x20(%rbp), %rdi
callq 0x30c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSystem
static void ficlPrimitiveSystem(ficlVm *vm)
{
    ficlCountedString *counted = (ficlCountedString *)vm->pad;

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

// Assembly:
pushq %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), %rdi
movq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x8fa0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x10dfe
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x30f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x10dfc
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
movl -0x14(%rbp), %edx
leaq 0x5870(%rip), %rsi      # 0x16643
movb $0x0, %al
callq 0x32d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
movq -0x8(%rbp), %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
callq 0x8d90
jmp 0x10e0e
movq -0x8(%rbp), %rdi
leaq 0x5853(%rip), %rsi      # 0x1665c
callq 0x95e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveGetCwd
static void ficlPrimitiveGetCwd(ficlVm *vm)
{
    char *directory;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x50, %esi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x95e0
movq -0x8(%rbp), %rdi
leaq 0x451f(%rip), %rsi      # 0x153a5
callq 0x95e0
movq -0x10(%rbp), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveChDir
static void ficlPrimitiveChDir(ficlVm *vm)
{
    ficlCountedString *counted = (ficlCountedString *)vm->pad;
    ficlVmGetString(vm, counted, '\n');
    if (counted->length > 0)
    {
       int err = chdir(counted->text);
       if (err)
        {
            ficlVmTextOut(vm, "Error: path not found\n");
            ficlVmThrow(vm, FICL_VM_STATUS_QUIT);
        }
    }
    else
    {
        ficlVmTextOut(vm, "Warning (chdir): nothing happened\n");
    }
    return;
}

// Assembly:
pushq %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), %rdi
movq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x8fa0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jle 0x10f0e
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x30e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x10f0c
movq -0x8(%rbp), %rdi
leaq 0x5787(%rip), %rsi      # 0x16680
callq 0x95e0
movq -0x8(%rbp), %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
callq 0x8d90
jmp 0x10f1e
movq -0x8(%rbp), %rdi
leaq 0x577e(%rip), %rsi      # 0x16697
callq 0x95e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAbortDefinition
void ficlDictionaryAbortDefinition(ficlDictionary *dictionary)
{
    ficlWord *word;
    ficlDictionaryLock(dictionary, FICL_TRUE);
    word = dictionary->smudge;

    if (word->flags & FICL_WORD_SMUDGED)
        dictionary->here = (ficlCell *)word->name;

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x10f63
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendCharacter
void ficlDictionaryAppendCharacter(ficlDictionary *dictionary, char c)
{
    char *here = (char *)dictionary->here;
    *here++ = c;
    dictionary->here = FICL_POINTER_TO_CELL(here);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendData
void *ficlDictionaryAppendData(ficlDictionary *dictionary, void *data, ficlInteger length)
{
    char *here    = (char *)dictionary->here;
    char *oldHere = here;
	char *from    = (char *)data;
 
    if (length == 0)
    {
        ficlDictionaryAlign(dictionary);
        return (char *)dictionary->here;
    }

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

    *here++ = '\0';

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x110fc
movq -0x10(%rbp), %rdi
callq 0x10f70
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11163
jmp 0x110fe
cmpq $0x0, -0x20(%rbp)
je 0x11135
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x110fe
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb $0x0, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10f70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendString
char *ficlDictionaryAppendString(ficlDictionary *dictionary, ficlString s)
{
	void *data = FICL_STRING_GET_POINTER(s);
	ficlInteger length = FICL_STRING_GET_LENGTH(s);

    if (length > FICL_NAME_LENGTH)
        length = FICL_NAME_LENGTH;
    
	return ficlDictionaryAppendData(dictionary, data, length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x1f, -0x28(%rbp)
jle 0x111a3
movq $0x1f, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x110b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendConstantInstruction
ficlWord *ficlDictionaryAppendConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
		ficlDictionaryAppendUnsigned(dictionary, value);
	return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %r8d, %r8d
callq 0x11220
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1120c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11080
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendWord
ficlWord *ficlDictionaryAppendWord(ficlDictionary *dictionary, 
                           ficlString name, 
                           ficlPrimitive code,
                           ficlUnsigned8 flags)
{
    ficlUnsigned8 length  = (ficlUnsigned8)FICL_STRING_GET_LENGTH(name);
    char *nameCopy;
    ficlWord *word;

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

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

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movb %al, -0x22(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x11170
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x10270
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x2b, 0x20(%rax)
movzbl -0x21(%rbp), %eax
orl $0x4, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0xa(%rax)
movb -0x22(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
addq $0x28, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movzbl -0x21(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x112eb
movq -0x18(%rbp), %rdi
callq 0x11720
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppend2ConstantInstruction
ficlWord *ficlDictionaryAppend2ConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficl2Integer value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
	{
	    ficlDictionaryAppendUnsigned(dictionary, FICL_2UNSIGNED_GET_HIGH(value));
		ficlDictionaryAppendUnsigned(dictionary, FICL_2UNSIGNED_GET_LOW(value));
	}
	return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
xorl %r8d, %r8d
callq 0x11220
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1135d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11080
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11080
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySetConstantInstruction
ficlWord *ficlDictionarySetConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
    ficlWord *word = ficlDictionaryLookup(dictionary, name);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x114a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11477
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x111c0
movq %rax, -0x30(%rbp)
jmp 0x1148f
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)