LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySetPrimitive
ficlWord *ficlDictionarySetPrimitive(ficlDictionary *dictionary, 
                          char *name, 
                          ficlPrimitive code,
                          ficlUnsigned8 flags)
{
    ficlString s;
    ficlWord *word;

	FICL_STRING_SET_FROM_CSTRING(s, name);
    word = ficlDictionaryLookup(dictionary, s);

    if (word == NULL)
    {
        word = ficlDictionaryAppendPrimitive(dictionary, name, code, flags);
    }
    else
    {
		word->code = (ficlPrimitive)code;
		word->flags = flags;
    }
	return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x30e0
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xba0d
testq %rax, %rax
je 0xbc25
movq %rbx, 0x18(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbbab
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryCreateHashed
ficlDictionary  *ficlDictionaryCreateHashed(ficlSystem *system, unsigned size, unsigned bucketCount)
{
    ficlDictionary *dictionary;
    size_t nAlloc;

    nAlloc =  sizeof(ficlDictionary) + (size * sizeof (ficlCell))
            + sizeof(ficlHash) + (bucketCount - 1) * sizeof (ficlWord *);

    dictionary = ficlMalloc(nAlloc);
    FICL_SYSTEM_ASSERT(system, dictionary != NULL);

    dictionary->size = size;
	dictionary->system = system;

    ficlDictionaryEmpty(dictionary, bucketCount);
    return dictionary;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
leal -0x1(%rbx), %ecx
addq %rax, %rcx
leaq 0xe0(,%rcx,8), %rdi
callq 0xac87
movq %rax, %r15
movl %ebp, 0xac(%rax)
movq %r14, 0xb0(%rax)
movq %rax, %rdi
movl %ebx, %esi
callq 0xbcd5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryEmpty
void ficlDictionaryEmpty(ficlDictionary *dictionary, unsigned bucketCount)
{
    ficlHash *hash;

    dictionary->here = dictionary->base;

    ficlDictionaryAlign(dictionary);
    hash = (ficlHash *)dictionary->here;
    ficlDictionaryAllot(dictionary, 
              sizeof (ficlHash) + (bucketCount - 1) * sizeof (ficlWord *));

    hash->size = bucketCount;
    ficlHashReset(hash);

    dictionary->forthWordlist = hash;
    dictionary->smudge = NULL;
    ficlDictionaryResetSearchOrder(dictionary);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0xb8(%rdi), %rax
movq %rax, (%rdi)
callq 0xb7aa
movq (%r14), %r15
leal 0x18(,%rbx,8), %eax
cltq
addq %r15, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0xb190
movq %r15, 0x18(%r14)
andq $0x0, 0x10(%r14)
movq %r15, 0x20(%r14)
movl $0x1, 0xa8(%r14)
movq %r15, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryCreateWordlist
ficlHash *ficlDictionaryCreateWordlist(ficlDictionary *dictionary, int bucketCount)
{
    ficlHash *hash;
    
    ficlDictionaryAlign(dictionary);
    hash    = (ficlHash *)dictionary->here;
    ficlDictionaryAllot(dictionary, sizeof (ficlHash) 
        + (bucketCount - 1) * sizeof (ficlWord *));

    hash->size = bucketCount;
    ficlHashReset(hash);
    return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0xb7aa
movq (%r14), %r15
leal 0x18(,%rbx,8), %eax
cltq
addq %r15, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0xb190
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryIsAWord
int ficlDictionaryIsAWord(ficlDictionary *dictionary, ficlWord *word)
{
	if ( (((ficlInstruction)word) > ficlInstructionInvalid)
		&& (((ficlInstruction)word) < ficlInstructionLast) )
		return 1;

    if (!ficlDictionaryIncludes(dictionary, word))
       return 0;

    if (!ficlDictionaryIncludes(dictionary, word->name))
        return 0;

	if ((word->link != NULL) && !ficlDictionaryIncludes(dictionary, word->link))
		return 0;

    if ((word->length <= 0) || (word->name[word->length] != '\0'))
		return 0;

	if (strlen(word->name) != word->length)
		return 0;

	return 1;
}

// Assembly:
testq %rsi, %rsi
setg %al
cmpq $0xb4, %rsi
setl %cl
testb %cl, %al
je 0xbd98
pushq $0x1
popq %rax
retq
leaq 0xb8(%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
ja 0xbd97
movl 0xac(%rdi), %edx
leaq (%rcx,%rdx,8), %rdx
cmpq %rsi, %rdx
jbe 0xbd97
movq 0x10(%rsi), %rdi
cmpq %rdi, %rcx
seta %r8b
cmpq %rdi, %rdx
setbe %r9b
orb %r8b, %r9b
jne 0xbd97
movq (%rsi), %r8
testq %r8, %r8
je 0xbde4
cmpq %r8, %rcx
seta %cl
cmpq %r8, %rdx
setbe %dl
orb %cl, %dl
jne 0xbd97
pushq %rbx
movzbl 0xb(%rsi), %ebx
testq %rbx, %rbx
je 0xbe04
cmpb $0x0, (%rdi,%rbx)
jne 0xbe04
callq 0x30e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryFindEnclosingWord
ficlWord *ficlDictionaryFindEnclosingWord(ficlDictionary *dictionary, ficlCell *cell)
{
    ficlWord *word;
    int i;

    if (!ficlDictionaryIncludes(dictionary, (void *)cell))
        return NULL;

    for (i = nSEARCH_CELLS; i > 0; --i, --cell)
    {
        word = (ficlWord *)(cell + 1 - (sizeof(ficlWord) / sizeof(ficlCell)));
        if (ficlDictionaryIsAWord(dictionary, word))
            return word;
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xb8(%rdi), %rax
cmpq %rsi, %rax
ja 0xbe76
movq %rsi, %rbx
movq %rdi, %r14
movl 0xac(%rdi), %ecx
leaq (%rax,%rcx,8), %rax
cmpq %rsi, %rax
jbe 0xbe76
pushq $-0x28
popq %r12
cmpl $0xfffffcb8, %r12d      # imm = 0xFFFFFCB8
je 0xbe76
leaq (%rbx,%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xbd80
testl %eax, %eax
jne 0xbe79
addq $-0x8, %r12
jmp 0xbe54
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveIncludeFile
static void ficlPrimitiveIncludeFile(ficlVm *vm) /* ( i*x fileid -- j*x ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    ficlCell id = vm->sourceId;
    int  except = FICL_VM_STATUS_OUT_OF_TEXT;
    long currentPosition, totalSize;
    long size;
	ficlString s;
    vm->sourceId.p = (void *)ff;

    currentPosition = ftell(ff->f);
    totalSize = ficlFileSize(ff);
    size = totalSize - currentPosition;

    if ((totalSize != -1) && (currentPosition != -1) && (size > 0))
    {
        char *buffer = (char *)malloc(size);
        long got = fread(buffer, 1, size, ff->f);
        if (got == size)
		{
			FICL_STRING_SET_POINTER(s, buffer);
			FICL_STRING_SET_LENGTH(s, size);
            except = ficlVmExecuteString(vm, s);
		}
    }

    if ((except < 0) && (except != FICL_VM_STATUS_OUT_OF_TEXT))
        ficlVmThrow(vm, except);
	
    /*
    ** Pass an empty line with SOURCE-ID == -1 to flush
    ** any pending REFILLs (as required by FILE wordset)
    */
    vm->sourceId.i = -1;
	FICL_STRING_SET_FROM_CSTRING(s, "");
    ficlVmExecuteString(vm, s);

    vm->sourceId = id;
    ficlFileClose(ff);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq 0x78(%rbx), %r13
movq %rax, 0x78(%rbx)
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r12
movq %r14, %rdi
callq 0xacee
movq %rax, %r15
subq %r12, %r15
cmpq $-0x1, %rax
setne %al
cmpq $-0x1, %r12
setne %cl
andb %al, %cl
testq %r15, %r15
setg %al
andb %cl, %al
cmpb $0x1, %al
jne 0xc510
movq %r15, %rdi
callq 0x3230
movq %rax, %r12
movq (%r14), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x3090
cmpq %r15, %rax
jne 0xc510
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6970
testl %eax, %eax
setns %cl
cmpl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
sete %dl
orb %cl, %dl
jne 0xc510
movq %rbx, %rdi
movl %eax, %esi
callq 0x6517
orq $-0x1, 0x78(%rbx)
leaq 0x1e4e(%rip), %rdx      # 0xe36a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6970
movq %r13, 0x78(%rbx)
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xcc09
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveReadFile
static void ficlPrimitiveReadFile(ficlVm *vm) /* ( c-addr u1 fileid -- u2 ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);
    int result;

    clearerr(ff->f);
    result = fread(address, 1, length, ff->f);

    ficlStackPushInteger(vm->dataStack, result);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x3090
movq 0x60(%rbx), %rdi
movslq %eax, %rsi
callq 0x4298
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcbeb
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveReadLine
static void ficlPrimitiveReadLine(ficlVm *vm) /* ( c-addr u1 fileid -- u2 flag ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    char *address = (char *)ficlStackPopPointer(vm->dataStack);
    int error;
    int flag;

    if (feof(ff->f))
        {
        ficlStackPushInteger(vm->dataStack, -1);
        ficlStackPushInteger(vm->dataStack, 0);
        ficlStackPushInteger(vm->dataStack, 0);
        return;
        }

    clearerr(ff->f);
    *address = 0;
    fgets(address, length, ff->f);

    error = ferror(ff->f);
    if (error != 0)
        {
        ficlStackPushInteger(vm->dataStack, -1);
        ficlStackPushInteger(vm->dataStack, 0);
        ficlStackPushInteger(vm->dataStack, error);
        return;
        }

    length = strlen(address);
    flag = (length > 0);
    if (length && ((address[length - 1] == '\r') || (address[length - 1] == '\n')))
        length--;
    
    ficlStackPushInteger(vm->dataStack, length);
    ficlStackPushInteger(vm->dataStack, flag);
    ficlStackPushInteger(vm->dataStack, 0); /* ior */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x422e
movq %rax, %r12
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r14
movq (%r15), %rdi
callq 0x31d0
testl %eax, %eax
je 0xc60c
movq 0x60(%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x4298
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4298
movq 0x60(%rbx), %rdi
xorl %esi, %esi
jmp 0xc652
movq (%r15), %rdi
callq 0x31f0
movb $0x0, (%r14)
movq (%r15), %rdx
movq %r14, %rdi
movl %r12d, %esi
callq 0x3170
movq (%r15), %rdi
callq 0x3080
testl %eax, %eax
je 0xc65f
movl %eax, %ebp
movq 0x60(%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x4298
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4298
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4298
movq %r14, %rdi
callq 0x30e0
testl %eax, %eax
je 0xc68b
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
movzbl (%r14,%rcx), %edx
cmpl $0xd, %edx
je 0xc683
movq %rax, %rcx
cmpl $0xa, %edx
jne 0xc68d
movq %rax, %rcx
decq %rcx
jmp 0xc68d
xorl %ecx, %ecx
xorl %r14d, %r14d
testl %eax, %eax
setg %r14b
movq 0x60(%rbx), %rdi
movslq %ecx, %rsi
callq 0x4298
movq 0x60(%rbx), %rdi
movq %r14, %rsi
jmp 0xc5ff
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveWriteFile
static void ficlPrimitiveWriteFile(ficlVm *vm) /* ( c-addr u1 fileid -- ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    clearerr(ff->f);
    fwrite(address, 1, length, ff->f);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x3300
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcbeb
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveWriteLine
static void ficlPrimitiveWriteLine(ficlVm *vm) /* ( c-addr u1 fileid -- ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    size_t length = (size_t)ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    clearerr(ff->f);
    if (fwrite(address, 1, length, ff->f) == length)
        fwrite("\n", 1, 1, ff->f);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movq (%r14), %rcx
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3300
cmpq %r15, %rax
jne 0xc771
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x3150
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xcbeb
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFilePosition
static void ficlPrimitiveFilePosition(ficlVm *vm) /* ( fileid -- ud ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    long ud = ftell(ff->f);
    ficlStackPushInteger(vm->dataStack, ud);
    pushIor(vm, ud != -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4298
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcbeb
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFileSize
static void ficlPrimitiveFileSize(ficlVm *vm) /* ( fileid -- ud ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    long ud = ficlFileSize(ff);
    ficlStackPushInteger(vm->dataStack, ud);
    pushIor(vm, ud != -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %rdi
callq 0xacee
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4298
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcbeb
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFileStatus
static void ficlPrimitiveFileStatus(ficlVm *vm) /* ( c-addr u -- x ior ) */
{
	int status;
	int ior;
	
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    char *filename = (char *)malloc(length + 1);
    memcpy(filename, address, length);
    filename[length] = 0;

	ior = ficlFileStatus(filename, &status);
	free(filename);

    ficlStackPushInteger(vm->dataStack, status);
    ficlStackPushInteger(vm->dataStack, ior);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x422e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r15
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r12
movslq %r14d, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3200
movb $0x0, (%r12,%r14)
leaq 0xc(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0xacb8
movl %eax, %ebp
movq %r12, %rdi
callq 0x3030
movq 0x60(%rbx), %rdi
movslq (%r14), %rsi
callq 0x4298
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
callq 0x4298
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveDeleteFile
static void ficlPrimitiveDeleteFile(ficlVm *vm) /* ( c-addr u -- ior ) */
{
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    char *filename = (char *)malloc(length + 1);
    memcpy(filename, address, length);
    filename[length] = 0;

    pushIor(vm, !unlink(filename));
	free(filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x422e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r15
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r12
movslq %r14d, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3200
movb $0x0, (%r12,%r14)
movq %r12, %rdi
callq 0x3050
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0xcbeb
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveRenameFile
static void ficlPrimitiveRenameFile(ficlVm *vm) /* ( c-addr1 u1 c-addr2 u2 -- ior ) */
{
    int length;
    void *address;
    char *from;
    char *to;

    length = ficlStackPopInteger(vm->dataStack);
    address = (void *)ficlStackPopPointer(vm->dataStack);
    to = (char *)malloc(length + 1);
    memcpy(to, address, length);
    to[length] = 0;

    length = ficlStackPopInteger(vm->dataStack);
    address = (void *)ficlStackPopPointer(vm->dataStack);

    from = (char *)malloc(length + 1);
    memcpy(from, address, length);
    from[length] = 0;

    pushIor(vm, !rename(from, to));

	free(from);
	free(to);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
xorl %ebp, %ebp
movb %bpl, (%r14,%r15)
movq 0x60(%rbx), %rdi
callq 0x422e
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r13
movslq %r15d, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movb %bpl, (%r13,%r15)
movq %r13, %rdi
movq %r14, %rsi
callq 0x32c0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0xcbeb
movq %r13, %rdi
callq 0x3030
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/fileaccess.c
// Function: pushIor
static void pushIor(ficlVm *vm, int success)
{
    int ior;
    if (success)
        ior = 0;
    else
        ior = errno;
    ficlStackPushInteger(vm->dataStack, ior);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0xcbf7
xorl %esi, %esi
jmp 0xcbff
callq 0x3040
movslq (%rax), %rsi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x4298
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedMultiplyAccumulate
ficl2Unsigned ficl2UnsignedMultiplyAccumulate(ficl2Unsigned u, ficlUnsigned mul, ficlUnsigned add)
{
    ficl2Unsigned resultLo = ficl2UnsignedMultiply(u.low, mul);
    ficl2Unsigned resultHi = ficl2UnsignedMultiply(u.high, mul);
    resultLo.high += resultHi.low;
    resultHi.low = resultLo.low + add;

    if (resultHi.low < resultLo.low)
        resultLo.high++;

    resultLo.low = resultHi.low;

    return resultLo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xcc8b
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xcc8b
addq %rbx, %r13
adcq %rdx, %r12
movq %r12, %rax
movq %r13, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedMultiply
ficl2Unsigned ficl2UnsignedMultiply(ficlUnsigned x, ficlUnsigned y)
{
    ficl2Unsigned result = { 0, 0 };
    ficl2Unsigned addend;
    
    addend.low = y;
    addend.high = 0; /* No sign extension--arguments are unsigned */
    
    while (x != 0) 
    {
        if ( x & 1) 
        {
            result = ficl2UnsignedAdd(result, addend);
        }
        x >>= 1;
        addend = ficl2UnsignedArithmeticShiftLeft(addend);
    }
    return result;
}

// Assembly:
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
testq %rdi, %rdi
je 0xccc7
testb $0x1, %dil
je 0xccba
addq %rcx, %rax
movq %rdx, %r8
orq %rsi, %r8
sets %r8b
addq %rsi, %rdx
setns %r9b
andb %r8b, %r9b
movzbl %r9b, %r8d
addq %r8, %rax
shrq %rdi
shldq $0x1, %rsi, %rcx
addq %rsi, %rsi
jmp 0xcc91
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2IntegerMultiply
ficl2Integer ficl2IntegerMultiply(ficlInteger x, ficlInteger y)
{
    ficl2Unsigned prod;
    int sign = 1;

    if (x < 0)
    {
        sign = -sign;
        x = -x;
    }

    if (y < 0)
    {
        sign = -sign;
        y = -y;
    }

    prod = ficl2UnsignedMultiply(x, y);
    if (sign > 0)
        return FICL_2UNSIGNED_TO_2INTEGER(prod);
    else
        return ficl2IntegerNegate(FICL_2UNSIGNED_TO_2INTEGER(prod));
}

// Assembly:
pushq %rbx
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
sarq $0x3f, %rdi
orl $0x1, %edi
movl %edi, %ebx
negl %ebx
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
testq %rsi, %rsi
cmovnsl %edi, %ebx
movq %rax, %rdi
movq %rcx, %rsi
callq 0xcc8b
testl %ebx, %ebx
jg 0xcd10
movq %rax, %rcx
notq %rcx
negq %rax
testq %rdx, %rdx
cmovneq %rcx, %rax
negq %rdx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedCompare
int ficl2UnsignedCompare(ficl2Unsigned x, ficl2Unsigned y)
{
    if (x.high > y.high) 
        return 1;
    if (x.high < y.high) 
        return -1;

	/* High parts are equal */

    if (x.low > y.low) 
        return 1;
    else if (x.low < y.low) 
        return -1;
    
    return 0;
}

// Assembly:
pushq $0x1
popq %rax
cmpq %rdx, %rdi
jbe 0xcd89
retq
jae 0xcd8f
pushq $-0x1
popq %rax
retq
cmpq %rcx, %rsi
ja 0xcd88
xorl %eax, %eax
cmpq %rcx, %rsi
sbbl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedDivide
ficl2UnsignedQR ficl2UnsignedDivide(ficl2Unsigned q, ficlUnsigned y)
{
    ficl2UnsignedQR result;
    ficl2Unsigned quotient;
    ficl2Unsigned subtrahend;
    ficl2Unsigned mask;

    quotient.low = 0;
    quotient.high = 0;
    
    subtrahend.low = y;
    subtrahend.high = 0;
    
    mask.low = 1;
    mask.high = 0;
    
    while ((ficl2UnsignedCompare(subtrahend, q) < 0) &&
           (subtrahend.high & FICL_CELL_HIGH_BIT) == 0)
    {
        mask = ficl2UnsignedArithmeticShiftLeft(mask);
        subtrahend = ficl2UnsignedArithmeticShiftLeft(subtrahend);
    }
    
    while (mask.low != 0 || mask.high != 0) 
    {
        if (ficl2UnsignedCompare(subtrahend, q) <= 0) 
        {
            q = ficl2UnsignedSubtract( q, subtrahend);
            quotient = ficl2UnsignedOr(quotient, mask);
        }
        mask = ficl2UnsignedArithmeticShiftRight(mask);
        subtrahend = ficl2UnsignedArithmeticShiftRight(subtrahend);
    }
    
    result.quotient = quotient;
    result.remainder = q.low;
    return result;
}

// Assembly:
movq %rdi, %rax
movabsq $0x1, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rsi, %r9
ja 0xcddb
setb %r10b
cmpq %rdx, %rcx
setb %r11b
testq %r9, %r9
js 0xcddb
orb %r11b, %r10b
je 0xcddb
shldq $0x1, %rdi, %r8
addq %rdi, %rdi
shldq $0x1, %rcx, %r9
addq %rcx, %rcx
jmp 0xcdaf
pushq %rbx
xorl %r10d, %r10d
xorl %r11d, %r11d
movq %rdi, %rbx
orq %r8, %rbx
je 0xce14
cmpq %r9, %rsi
jb 0xce02
ja 0xcdf6
cmpq %rdx, %rcx
ja 0xce02
subq %rcx, %rdx
sbbq %r9, %rsi
orq %r8, %r10
orq %rdi, %r11
shrdq $0x1, %r8, %rdi
shrq %r8
shrdq $0x1, %r9, %rcx
shrq %r9
jmp 0xcde2
movq %r10, (%rax)
movq %r11, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2IntegerDivideFloored
ficl2IntegerQR ficl2IntegerDivideFloored(ficl2Integer num, ficlInteger den)
{
    ficl2IntegerQR qr;
    ficl2UnsignedQR uqr;
    int signRem = 1;
    int signQuot = 1;

    if (ficl2IntegerIsNegative(num))
    {
        num = ficl2IntegerNegate(num);
        signQuot = -signQuot;
    }

    if (den < 0)
    {
        den      = -den;
        signRem  = -signRem;
        signQuot = -signQuot;
    }

    uqr = ficl2UnsignedDivide(FICL_2INTEGER_TO_2UNSIGNED(num), (ficlUnsigned)den);
    qr = FICL_2UNSIGNEDQR_TO_2INTEGERQR(uqr);
    if (signQuot < 0)
    {
        qr.quotient = ficl2IntegerNegate(qr.quotient);
        if (qr.remainder != 0)
        {
            qr.quotient = ficl2IntegerDecrement(qr.quotient);
            qr.remainder = den - qr.remainder;
        }
    }

    if (signRem < 0)
        qr.remainder = -qr.remainder;

    return qr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
js 0xce57
pushq $0x1
jmp 0xce6c
movq %rsi, %rax
notq %rax
negq %rsi
testq %rdx, %rdx
cmovneq %rax, %rsi
negq %rdx
pushq $-0x1
popq %rax
movl %eax, %ebp
negl %ebp
testq %r14, %r14
cmovnsl %eax, %ebp
movq %r14, %r15
negq %r15
cmovsq %r14, %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0xcd9c
testl %ebp, %ebp
jns 0xcedf
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
notq %rdx
negq %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
movq %rcx, %rdx
negq %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0xcedf
movl $0x80000000, %esi       # imm = 0x80000000
xorl %edi, %edi
cmpq %rsi, %rcx
sete %dil
subq %rdi, %rax
notq %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
subq %rdx, %r15
movq %r15, 0x10(%rbx)
testq %r14, %r14
jns 0xcee8
negq 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/double.c
// Function: ficl2IntegerDivideSymmetric
ficl2IntegerQR ficl2IntegerDivideSymmetric(ficl2Integer num, ficlInteger den)
{
    ficl2IntegerQR qr;
    ficl2UnsignedQR uqr;
    int signRem = 1;
    int signQuot = 1;

    if (ficl2IntegerIsNegative(num))
    {
        num = ficl2IntegerNegate(num);
        signRem  = -signRem;
        signQuot = -signQuot;
    }

    if (den < 0)
    {
        den      = -den;
        signQuot = -signQuot;
    }

    uqr = ficl2UnsignedDivide(FICL_2INTEGER_TO_2UNSIGNED(num), (ficlUnsigned)den);
    qr = FICL_2UNSIGNEDQR_TO_2INTEGERQR(uqr);
    if (signRem < 0)
        qr.remainder = -qr.remainder;

    if (signQuot < 0)
        qr.quotient = ficl2IntegerNegate(qr.quotient);

    return qr;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
js 0xcf0d
pushq $0x1
popq %rax
movq %r14, %rsi
jmp 0xcf26
movq %r14, %rax
notq %rax
movq %r14, %rsi
negq %rsi
testq %rdx, %rdx
cmovneq %rax, %rsi
negq %rdx
pushq $-0x1
popq %rax
movl %eax, %ebp
negl %ebp
testq %rcx, %rcx
cmovnsl %eax, %ebp
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
movq %rbx, %rdi
movq %rax, %rcx
callq 0xcd9c
testq %r14, %r14
jns 0xcf4e
negq 0x10(%rbx)
testl %ebp, %ebp
jns 0xcf73
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
notq %rdx
negq %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
negq %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSearchPush
static void ficlPrimitiveSearchPush(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryLock(dictionary, FICL_TRUE);
    if (dictionary->wordlistCount > FICL_MAX_WORDLISTS)
    {
        ficlVmThrowError(vm, ">search error: search order overflow");
    }
    dictionary->wordlists[dictionary->wordlistCount++] = ficlStackPopPointer(vm->dataStack);
    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6643
movq %rax, %rbx
cmpl $0x11, 0xa8(%rax)
jl 0xd137
leaq 0x2805(%rip), %rsi      # 0xf932
movq %r14, %rdi
xorl %eax, %eax
callq 0x6527
movq 0x60(%r14), %rdi
callq 0x420e
movslq 0xa8(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0xa8(%rbx)
movq %rax, 0x28(%rbx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSearchPop
static void ficlPrimitiveSearchPop(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    int wordlistCount;

    ficlDictionaryLock(dictionary, FICL_TRUE);
    wordlistCount = dictionary->wordlistCount;
    if (wordlistCount == 0)
    {
        ficlVmThrowError(vm, "search> error: empty search order");
    }
    ficlStackPushPointer(vm->dataStack, dictionary->wordlists[--dictionary->wordlistCount]);
    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6643
movq %rax, %rbx
movl 0xa8(%rax), %eax
testl %eax, %eax
jne 0xd18d
leaq 0x27da(%rip), %rsi      # 0xf957
movq %r14, %rdi
xorl %eax, %eax
callq 0x6527
movl 0xa8(%rbx), %eax
movq 0x60(%r14), %rdi
leal -0x1(%rax), %ecx
movl %ecx, 0xa8(%rbx)
cltq
movq 0x20(%rbx,%rax,8), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4287
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveDefinitions
static void ficlPrimitiveDefinitions(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    FICL_VM_ASSERT(vm, dictionary);
    if (dictionary->wordlistCount < 1)
    {
        ficlVmThrowError(vm, "DEFINITIONS error - empty search order");
    }

    dictionary->compilationWordlist = dictionary->wordlists[dictionary->wordlistCount-1];
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6643
movq %rax, %rbx
movl 0xa8(%rax), %eax
testl %eax, %eax
jg 0xd1dd
leaq 0x27ac(%rip), %rsi      # 0xf979
movq %r14, %rdi
xorl %eax, %eax
callq 0x6527
movl 0xa8(%rbx), %eax
cltq
movq 0x20(%rbx,%rax,8), %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveGetOrder
static void ficlPrimitiveGetOrder(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    int wordlistCount = dictionary->wordlistCount;
    int i;

    ficlDictionaryLock(dictionary, FICL_TRUE);
    for (i = 0; i < wordlistCount; i++)
    {
        ficlStackPushPointer(vm->dataStack, dictionary->wordlists[i]);
    }

    ficlStackPushUnsigned(vm->dataStack, wordlistCount);
    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6643
movq %rax, %r15
movslq 0xa8(%rax), %r14
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
movq 0x60(%rbx), %rdi
cmpq %r12, %r13
je 0xd261
movq 0x28(%r15,%r12,8), %rsi
callq 0x4287
incq %r12
jmp 0xd249
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42a9
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSearchWordlist
static void ficlPrimitiveSearchWordlist(ficlVm *vm)
{
    ficlString name;
    ficlUnsigned16 hashCode;
    ficlWord *word;
    ficlHash *hash = ficlStackPopPointer(vm->dataStack);

    name.length         = (ficlUnsigned8)ficlStackPopUnsigned(vm->dataStack);
    name.text            = ficlStackPopPointer(vm->dataStack);
    hashCode         = ficlHashCode(name);

    ficlDictionaryLock(ficlVmGetDictionary(vm), FICL_TRUE);
    word = ficlHashLookup(hash, name, hashCode);
    ficlDictionaryLock(ficlVmGetDictionary(vm), FICL_FALSE);

    if (word)
    {
        ficlStackPushPointer(vm->dataStack, word);
        ficlStackPushInteger(vm->dataStack, (ficlWordIsImmediate(word) ? 1 : -1));
    }
    else
    {
        ficlStackPushUnsigned(vm->dataStack, 0);
    }

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x421e
movzbl %al, %r15d
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xb08a
movzwl %ax, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb10c
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xd2fd
movq %rax, %r14
movq %rax, %rsi
callq 0x4287
movq 0x60(%rbx), %rbx
movq %r14, %rdi
callq 0xb26c
xorl %esi, %esi
cmpl $0x1, %eax
sbbq %rsi, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4298
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x42a9
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSetOrder
static void ficlPrimitiveSetOrder(ficlVm *vm)
{
    int i;
    int wordlistCount = ficlStackPopInteger(vm->dataStack);
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    if (wordlistCount > FICL_MAX_WORDLISTS)
    {
        ficlVmThrowError(vm, "set-order error: list would be too large");
    }

    ficlDictionaryLock(dictionary, FICL_TRUE);

    if (wordlistCount >= 0)
    {
        dictionary->wordlistCount = wordlistCount;
        for (i = wordlistCount-1; i >= 0; --i)
        {
            dictionary->wordlists[i] = ficlStackPopPointer(vm->dataStack);
        }
    }
    else
    {
        ficlDictionaryResetSearchOrder(dictionary);
    }

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x422e
movq %rax, %r15
movq %rbx, %rdi
callq 0x6643
movq %rax, %r14
cmpl $0x11, %r15d
jl 0xd371
leaq 0x263b(%rip), %rsi      # 0xf9a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6527
jmp 0xd376
testl %r15d, %r15d
js 0xd3a8
movl %r15d, 0xa8(%r14)
movl %r15d, %r15d
testl %r15d, %r15d
jle 0xd39c
leaq -0x1(%r15), %r12
movq 0x60(%rbx), %rdi
callq 0x420e
movq %rax, 0x20(%r14,%r15,8)
movq %r12, %r15
jmp 0xd380
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbd69
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveFiclWordlist
static void ficlPrimitiveFiclWordlist(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash;
    ficlUnsigned nBuckets;
    
    FICL_STACK_CHECK(vm->dataStack, 1, 1);

    nBuckets = ficlStackPopUnsigned(vm->dataStack);
    hash = ficlDictionaryCreateWordlist(dictionary, nBuckets);
    ficlStackPushPointer(vm->dataStack, hash);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6643
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x421e
movq %r14, %rdi
movl %eax, %esi
callq 0xbd2e
movq 0x60(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4287
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveWidGetName
static void ficlPrimitiveWidGetName(ficlVm *vm)
{
    ficlHash *hash;
    char *name;
    ficlInteger length;

    hash = ficlVmPop(vm).p;
    name = hash->name;
    
    if (name != NULL)
        length = strlen(name);
	else
		length = 0;

    ficlVmPush(vm, FICL_LVALUE_TO_CELL(name));
    ficlVmPush(vm, FICL_LVALUE_TO_CELL(length));
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6823
movq 0x8(%rax), %r14
testq %r14, %r14
je 0xd413
movq %r14, %rdi
callq 0x30e0
movq %rax, %r15
jmp 0xd416
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x682c
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x682c
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/bit.c
// Function: ficlBitSet
void ficlBitSet(unsigned char *bits, size_t index, int value)
	{
	int byteIndex = index >> 3;
	int bitIndex = index & 7;
	unsigned char mask = (unsigned char)(128 >> bitIndex);

	if (value)
		bits[byteIndex] |= mask;
	else
		bits[byteIndex] &= ~mask;
	}

// Assembly:
movq %rsi, %rcx
movq %rsi, %rax
shrq $0x3, %rax
andb $0x7, %cl
movb $-0x80, %sil
shrb %cl, %sil
testl %edx, %edx
je 0xd4b2
cltq
orb %sil, (%rdi,%rax)
retq
notb %sil
cltq
andb %sil, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/eric-lo[P]3150/9-File/no_buf.c
// Function: main
int main(void)
{
	if(setvbuf(stdout, NULL, _IONBF, 0) != 0)
	{
		perror("setvbuf");
		exit(1);
	}

	printf("H");	sleep(1);
	printf("E");	sleep(1);
	printf("L");	sleep(1);
	printf("L");	sleep(1);
	printf("O");	sleep(1);
	printf("\n");	sleep(1);

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x2e5a(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1040
testl %eax, %eax
jne 0x1200
pushq $0x48
popq %rdi
callq 0x1030
pushq $0x1
popq %rbx
movl %ebx, %edi
callq 0x1070
pushq $0x45
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0x4c
popq %rbp
movl %ebp, %edi
callq 0x1030
movl %ebx, %edi
callq 0x1070
movl %ebp, %edi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0x4f
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
pushq $0xa
popq %rdi
callq 0x1030
movl %ebx, %edi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdfd(%rip), %rdi       # 0x2004
callq 0x1050
pushq $0x1
popq %rdi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/tests/stop_wait.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(pipe(pipe_fds) == 0);
  check(fcntl(pipe_fds[0], F_SETFL, O_NONBLOCK) != -1);

  check(libforks_start(&conn) == libforks_OK);

  check(close(pipe_fds[1]) == 0);

  check(libforks_fork(
    conn,
    NULL, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  // Fails because the pipe is non-blocking and the child
  // is currently sleeping.
  char c;
  check(read(pipe_fds[0], &c, 1) == -1);
  check(errno == EAGAIN);

  check(libforks_stop(conn) == libforks_OK); // SIGTERM sent but ignored by the child

  while (true) {
    int r = read(pipe_fds[0], &c, 1);
    if (r == -1) {
      check(errno == EAGAIN);
    } else {
      check(r == 1);
      break;
    }
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x4e00(%rip), %rdi      # 0x611c
callq 0x1100
testl %eax, %eax
jne 0x141a
movl 0x4ded(%rip), %edi      # 0x611c
pushq $0x4
popq %rsi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x1080
cmpl $-0x1, %eax
je 0x1425
leaq 0x8(%rsp), %rdi
callq 0x1866
testl %eax, %eax
jne 0x1430
movl 0x4dc1(%rip), %edi      # 0x6120
callq 0x10e0
testl %eax, %eax
jne 0x143b
movq 0x8(%rsp), %rdi
leaq 0x125(%rip), %r8        # 0x149d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2162
testl %eax, %eax
jne 0x1446
movl 0x4d8b(%rip), %edi      # 0x611c
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x1110
cmpq $-0x1, %rax
jne 0x1451
callq 0x1050
cmpl $0xb, (%rax)
jne 0x145c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2306
testl %eax, %eax
jne 0x1467
leaq 0x7(%rsp), %r14
pushq $0x1
popq %r15
movl 0x4d42(%rip), %edi      # 0x611c
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
cmpl $-0x1, %eax
jne 0x13fa
cmpl $0xb, (%rbx)
je 0x13d4
leaq 0x1d01(%rip), %rdi      # 0x30f7
pushq $0x34
jmp 0x1414
cmpl $0x1, %eax
jne 0x140b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1d18(%rip), %rdi      # 0x312a
pushq $0x36
popq %rsi
callq 0x1472
leaq 0x1be3(%rip), %rdi      # 0x3004
pushq $0x1a
jmp 0x1414
leaq 0x1bfe(%rip), %rdi      # 0x302a
pushq $0x1b
jmp 0x1414
leaq 0x1c21(%rip), %rdi      # 0x3058
pushq $0x1d
jmp 0x1414
leaq 0x1c3b(%rip), %rdi      # 0x307d
pushq $0x1f
jmp 0x1414
leaq 0x1c48(%rip), %rdi      # 0x3095
pushq $0x27
jmp 0x1414
leaq 0x1c80(%rip), %rdi      # 0x30d8
pushq $0x2c
jmp 0x1414
leaq 0x1c94(%rip), %rdi      # 0x30f7
pushq $0x2d
jmp 0x1414
leaq 0x1c99(%rip), %rdi      # 0x3107
pushq $0x2f
jmp 0x1414
// File: /workspace/github_c_makefile_star2_O2/motet-a[P]libforks/tests/stop_wait.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;
  (void)socket_fd;

  check(signal(SIGTERM, SIG_IGN) != SIG_ERR);

  // sleep 10ms
  struct timespec ts = {
    .tv_sec = 0,
    .tv_nsec = 10 * 1000 * 1000,
  };
  check(nanosleep(&ts, NULL) == 0);

  check(write(pipe_fds[1], "a", 1) == 1);
}

// Assembly:
subq $0x18, %rsp
pushq $0xf
popq %rdi
pushq $0x1
popq %rsi
callq 0x1120
cmpq $-0x1, %rax
je 0x14ea
movups 0x1cf7(%rip), %xmm0     # 0x31b0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x10c0
testl %eax, %eax
jne 0x14f5
movl 0x4c50(%rip), %edi      # 0x6120
leaq 0x1cb4(%rip), %rsi      # 0x318b
pushq $0x1
popq %rdx
callq 0x1090
cmpq $0x1, %rax
jne 0x1500
addq $0x18, %rsp
retq
leaq 0x1c5c(%rip), %rdi      # 0x314d
pushq $0xb
jmp 0x1509
leaq 0x1c75(%rip), %rdi      # 0x3171
pushq $0x12
jmp 0x1509
leaq 0x1c86(%rip), %rdi      # 0x318d
pushq $0x14
popq %rsi
callq 0x1472
nop
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/test/test_queue.c
// Function: main
int main(void)
{

	QUEUE_s *pQ = QUEUE_create(sizeof(int),16);
	for (int i = 0;i < DIM_OF(arr);i++) {
		QUEUE_enqueue(pQ,&arr[i]);
	}

	int val;
	while(QUEUE_dequeue(pQ,&val) != QUEUE_EMPTY) {
		printf("val:%d\n",val);
	}

	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x4
popq %rdi
pushq $0x10
popq %rsi
callq 0x11e0
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x2ec3(%rip), %r15      # 0x4050
cmpq $0x18, %r14
je 0x11a5
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x12d9
addq $0x4, %r14
jmp 0x118d
leaq 0xc(%rsp), %r14
leaq 0xe53(%rip), %r15       # 0x2004
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1346
cmpl $-0x2, %eax
je 0x11d1
movl 0xc(%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
jmp 0x11b1
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_create
QUEUE_s *QUEUE_create(int itemSize,int nMax)
{
	QUEUE_s *pQ = (QUEUE_s *)malloc(sizeof(QUEUE_s));
	CHECK_EXPR_RET(pQ == NULL,NULL);

	pQ->data = (void *)malloc(itemSize * nMax);
	CHECK_EXPR_RET(pQ->data == NULL,NULL);
	pQ->itemSize = itemSize;
	pQ->nMax = nMax;
	pQ->head = 0;
	pQ->tail = 0;
	return pQ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x18
popq %rdi
callq 0x1050
testq %rax, %rax
je 0x121d
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
movslq %eax, %rdi
callq 0x1050
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1238
movl %r14d, 0x14(%rbx)
movl %ebp, 0x10(%rbx)
andq $0x0, (%rbx)
jmp 0x1259
leaq 0xde8(%rip), %rdi       # 0x200c
leaq 0xdf7(%rip), %rsi       # 0x2022
leaq 0xdf8(%rip), %rdx       # 0x202a
xorl %ebx, %ebx
pushq $0x9
jmp 0x1251
leaq 0xdcd(%rip), %rdi       # 0x200c
leaq 0xddc(%rip), %rsi       # 0x2022
leaq 0xddd(%rip), %rdx       # 0x202a
xorl %ebx, %ebx
pushq $0xc
popq %rcx
xorl %eax, %eax
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_empty
BOOL QUEUE_empty(QUEUE_s *pQ)
{
	CHECK_EXPR_RET(pQ == NULL,TRUE);

	if (pQ->head == pQ->tail ) {
		return TRUE;
	}

	return FALSE;
}

// Assembly:
testq %rdi, %rdi
je 0x126f
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
sete %al
retq
pushq %rax
leaq 0xd95(%rip), %rdi       # 0x200c
leaq 0xda4(%rip), %rsi       # 0x2022
leaq 0xdb2(%rip), %rdx       # 0x2037
pushq $0x17
popq %rcx
xorl %eax, %eax
callq 0x1030
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_enqueue
int QUEUE_enqueue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_full(pQ) == TRUE) {
		printf("Queue is full!\n");
		return QUEUE_FULL;
	}
	
	memcpy((char *)pQ->data + pQ->tail*pQ->itemSize,item,pQ->itemSize);
	pQ->tail++;
	pQ->tail %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1322
movq %rdi, %rbx
movl (%rdi), %eax
movslq 0x4(%rdi), %rdi
cmpl %edi, %eax
jne 0x1301
cmpl 0x10(%rbx), %eax
jne 0x1301
leaq 0xd67(%rip), %rdi       # 0x205f
callq 0x1060
pushq $-0x3
jmp 0x1343
movslq 0x14(%rbx), %rdx
imulq %rdx, %rdi
addq 0x8(%rbx), %rdi
callq 0x1040
movl 0x4(%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, 0x4(%rbx)
xorl %eax, %eax
jmp 0x1344
leaq 0xce3(%rip), %rdi       # 0x200c
leaq 0xcf2(%rip), %rsi       # 0x2022
leaq 0xd0c(%rip), %rdx       # 0x2043
pushq $0x36
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_dequeue
int QUEUE_dequeue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_empty(pQ) == TRUE) {
		return QUEUE_EMPTY;
	}

	memcpy(item,(char *)pQ->data + pQ->head*pQ->itemSize,pQ->itemSize);
	pQ->head++;
	pQ->head %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x135b
movq %rdi, %rbx
movslq (%rdi), %rax
cmpl 0x4(%rdi), %eax
jne 0x137f
pushq $-0x2
jmp 0x137c
leaq 0xcaa(%rip), %rdi       # 0x200c
leaq 0xcb9(%rip), %rsi       # 0x2022
leaq 0xce1(%rip), %rdx       # 0x2051
pushq $0x46
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x13a2
movslq 0x14(%rbx), %rdx
imulq %rdx, %rax
addq 0x8(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1040
movl (%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/init.c
// Function: gt_lib_clean
int gt_lib_clean(void)
{
  int fa_fptr_rval, fa_mmap_rval, gt_rval;
  if (spacepeak) {
    gt_ma_show_space_peak(stdout);
    gt_fa_show_space_peak(stdout);
    gt_spacepeak_show_space_peak(stdout);
    gt_ma_disable_global_spacepeak();
  }
  fa_fptr_rval = gt_fa_check_fptr_leak();
  fa_mmap_rval = gt_fa_check_mmap_leak();
  gt_fa_clean();
  gt_symbol_clean();
  gt_class_alloc_clean();
  gt_class_alloc_lock_clean();
  gt_ya_rand_clean();
  gt_log_clean();
  gt_spacepeak_clean();
  gt_combinatorics_clean();
  gt_rval = gt_ma_check_space_leak();
  gt_ma_clean();
#ifdef HAVE_MYSQL
  mysql_library_end();
#endif
  return fa_fptr_rval || fa_mmap_rval || gt_rval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x1234b3(%rip)    # 0x12f9d1
jne 0xc544
movq 0x121a21(%rip), %rbx    # 0x12df48
movq (%rbx), %rdi
callq 0xd4ce
movq (%rbx), %rdi
callq 0x536b9
movq (%rbx), %rdi
callq 0x1242e
callq 0xd3f0
callq 0x533b5
movl %eax, %ebx
callq 0x534c6
movl %eax, %ebp
callq 0x53734
callq 0x15a6f
callq 0x4f1a1
callq 0x4f213
callq 0x167d8
callq 0xc694
callq 0x124a7
callq 0x4f42e
callq 0xd54d
movl %eax, %r14d
callq 0xd87c
orl %ebx, %ebp
xorl %eax, %eax
orl %r14d, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop