LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendConstantInstruction
ficlWord *ficlDictionaryAppendConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
		ficlDictionaryAppendUnsigned(dictionary, value);
	return word;
}

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

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

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

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return word;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rdi, %r15
xorl %r8d, %r8d
callq 0xbfcc
testq %rax, %rax
je 0xc0a6
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %r14, (%rcx)
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %rbx, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
callq 0xc1bf
testq %rax, %rax
je 0xc181
movq %rax, %r14
movq %r12, 0x18(%rax)
movq %rax, %rcx
addq $0x28, %rcx
jmp 0xc1aa
xorl %r14d, %r14d
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xbfcc
testq %rax, %rax
je 0xc1ad
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %rax, %r14
movq %rbx, (%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryLookup
ficlWord *ficlDictionaryLookup(ficlDictionary *dictionary, ficlString name)
{
    ficlWord *word = NULL;
    ficlHash *hash;
    int i;
    ficlUnsigned16 hashCode   = ficlHashCode(name);

    FICL_DICTIONARY_ASSERT(dictionary, dictionary != NULL);

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

    ficlDictionaryLock(dictionary, FICL_TRUE);
    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xb769
movslq 0xa8(%r15), %r12
testq %r12, %r12
jle 0xc20c
movzwl %ax, %ebp
movq 0x20(%r15,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb7e9
cmpq $0x2, %r12
jb 0xc20e
decq %r12
testq %rax, %rax
je 0xc1ea
jmp 0xc20e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySet2ConstantInstruction
ficlWord *ficlDictionarySet2ConstantInstruction(ficlDictionary *dictionary, ficlString s, ficlInstruction instruction, ficl2Integer value)
{
    ficlWord *word;
    word = ficlDictionaryLookup(dictionary, s);

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

    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r12
callq 0xc1bf
testq %rax, %rax
je 0xc296
movq %rax, %r15
movq 0x18(%rax), %rax
cmpq $0x8a, %rax
je 0xc285
cmpq $0x49, %rax
jne 0xc296
movq %r13, 0x18(%r15)
movq %r14, 0x28(%r15)
movq %r15, %rcx
addq $0x30, %rcx
jmp 0xc2d0
xorl %r15d, %r15d
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0xbfcc
testq %rax, %rax
je 0xc2d7
movq (%r12), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r12)
movq %r14, (%rcx)
movq (%r12), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r12)
movq %rax, %r15
movq (%rsp), %rax
movq %rax, (%rcx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1bf
testq %rax, %rax
je 0xc408
movq %rbx, 0x18(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x30e0
movzbl %bpl, %r8d
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbfcc
// File: /workspace/github_c_makefile_star2_O3/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 0xb2eb
movq %rax, %r15
movl %ebp, 0xac(%rax)
movq %r14, 0xb0(%rax)
movq %rax, %rdi
movl %ebx, %esi
callq 0xc56b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq (%rdi), %rdi
callq 0xb39c
movq %rax, %r15
leal 0x18(,%rbx,8), %eax
cltq
addq %r15, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0xb870
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %cl
cmpq $0xb4, %rsi
setl %dl
movl $0x1, %eax
testb %dl, %cl
jne 0xc6a2
leaq 0xb8(%rdi), %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
ja 0xc6a2
movl 0xac(%rdi), %edx
leaq (%rcx,%rdx,8), %rdx
cmpq %rsi, %rdx
jbe 0xc6a2
movq 0x10(%rsi), %rdi
cmpq %rdi, %rcx
seta %r8b
cmpq %rdi, %rdx
setbe %r9b
orb %r8b, %r9b
jne 0xc6a2
movq (%rsi), %r8
testq %r8, %r8
je 0xc681
cmpq %r8, %rcx
seta %cl
cmpq %r8, %rdx
setbe %dl
orb %cl, %dl
jne 0xc6a2
pushq %rbx
movzbl 0xb(%rsi), %ebx
testq %rbx, %rbx
je 0xc6a1
cmpb $0x0, (%rdi,%rbx)
jne 0xc6a1
callq 0x30e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
leaq 0xb8(%rdi), %rax
cmpq %rsi, %rax
ja 0xc70c
movq %rsi, %rbx
movq %rdi, %r14
movl 0xac(%rdi), %ecx
leaq (%rax,%rcx,8), %rax
cmpq %rsi, %rax
jbe 0xc70c
addq $-0x28, %rbx
movl $0x65, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc61c
testl %eax, %eax
jne 0xc70e
decl %ebp
addq $-0x8, %rbx
cmpl $0x1, %ebp
ja 0xc6f2
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r14
movq 0x78(%rbx), %r13
movq %rax, 0x78(%rbx)
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r12
movq %r14, %rdi
callq 0xb352
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 0xcdd0
movq %r15, %rdi
callq 0x3230
movq %rax, %r12
movq (%r14), %rcx
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x3090
cmpq %r15, %rax
jne 0xcdd0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6c0b
testl %eax, %eax
setns %cl
cmpl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
sete %dl
orb %cl, %dl
jne 0xcdd0
movq %rbx, %rdi
movl %eax, %esi
callq 0x67c2
movq $-0x1, 0x78(%rbx)
leaq 0x158b(%rip), %rdx      # 0xe36a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6c0b
movq %r13, 0x78(%rbx)
movq (%r14), %rbx
movq %r14, %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x3090
movq 0x60(%rbx), %rdi
movslq %eax, %rsi
callq 0x4327
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 0xd4cf
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42bd
movq %rax, %r12
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r14
movq (%r15), %rdi
callq 0x31d0
testl %eax, %eax
je 0xcee0
movq 0x60(%rbx), %rdi
movq $-0x1, %rsi
callq 0x4327
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4327
movq 0x60(%rbx), %rdi
xorl %esi, %esi
jmp 0xcf2a
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 0xcf37
movl %eax, %ebp
movq 0x60(%rbx), %rdi
movq $-0x1, %rsi
callq 0x4327
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4327
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4327
movq %r14, %rdi
callq 0x30e0
testl %eax, %eax
je 0xcf63
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
movzbl (%r14,%rcx), %edx
cmpl $0xd, %edx
je 0xcf5b
movq %rax, %rcx
cmpl $0xa, %edx
jne 0xcf65
movq %rax, %rcx
decq %rcx
jmp 0xcf65
xorl %ecx, %ecx
xorl %r14d, %r14d
testl %eax, %eax
setg %r14b
movq 0x60(%rbx), %rdi
movslq %ecx, %rsi
callq 0x4327
movq 0x60(%rbx), %rdi
movq %r14, %rsi
jmp 0xced3
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
movl $0x1, %esi
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 0xd4cf
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movq (%r14), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3300
cmpq %r15, %rax
jne 0xd04f
movq (%r14), %rsi
movl $0xa, %edi
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 0xd4cf
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4327
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4cf
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %rdi
callq 0xb352
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4327
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4cf
// File: /workspace/github_c_makefile_star2_O3/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 0x42bd
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x429d
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 0xb31c
movl %eax, %ebp
movq %r12, %rdi
callq 0x3030
movq 0x60(%rbx), %rdi
movslq (%r14), %rsi
callq 0x4327
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
callq 0x4327
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x42bd
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x429d
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 0xd4cf
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/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 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
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 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
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 0xd4cf
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_O3/hoobaa[P]ficl/fileaccess.c
// Function: ficlFileOpen
static void ficlFileOpen(ficlVm *vm, char *writeMode) /* ( c-addr u fam -- fileid ior ) */
{
    int fam = ficlStackPopInteger(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);
    char mode[4];
    FILE *f;
    char *filename = (char *)malloc(length + 1);
    memcpy(filename, address, length);
    filename[length] = 0;

    *mode = 0;

    switch (FICL_FAM_OPEN_MODE(fam))
        {
        case 0:
            ficlStackPushPointer(vm->dataStack, NULL);
            ficlStackPushInteger(vm->dataStack, EINVAL);
            goto EXIT;
        case FICL_FAM_READ:
            strcat(mode, "r");
            break;
        case FICL_FAM_WRITE:
            strcat(mode, writeMode);
            break;
        case FICL_FAM_READ | FICL_FAM_WRITE:
            strcat(mode, writeMode);
            strcat(mode, "+");
            break;
        }

    strcat(mode, (fam & FICL_FAM_BINARY) ? "b" : "t");

    f = fopen(filename, mode);
    if (f == NULL)
        ficlStackPushPointer(vm->dataStack, NULL);
    else
        {
        ficlFile *ff = (ficlFile *)malloc(sizeof(ficlFile));
        strcpy(ff->filename, filename);
        ff->f = f;
        ficlStackPushPointer(vm->dataStack, ff);

        fseek(f, 0, SEEK_SET);
        }
    pushIor(vm, f != NULL);
	
EXIT:
	free(filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42bd
movq %rax, %r13
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %rbp
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r14
movslq %r13d, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x3200
xorl %eax, %eax
movb %al, (%r14,%r13)
movb %al, 0x4(%rsp)
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x3, %eax
ja 0xd42f
leaq 0x23e1(%rip), %rcx      # 0xf7a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4316
movq 0x60(%rbx), %rdi
movl $0x16, %esi
callq 0x4327
jmp 0xd4b8
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
callq 0x32e0
jmp 0xd42f
leaq 0x4(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x32e0
movq %r13, %rdi
callq 0x30e0
movw $0x2b, 0x4(%rsp,%rax)
jmp 0xd42f
leaq 0x4(%rsp), %rdi
callq 0x30e0
movw $0x72, 0x4(%rsp,%rax)
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0x30e0
testb $0x8, %r15b
movl $0x74, %ecx
movl $0x62, %edx
cmovel %ecx, %edx
movw %dx, 0x4(%rsp,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rax, %r15
testq %rax, %rax
je 0xd49c
movl $0x108, %edi            # imm = 0x108
callq 0x3230
movq %rax, %r12
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3070
movq %r15, (%r12)
movq 0x60(%rbx), %rdi
movq %r12, %rsi
callq 0x4316
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3260
jmp 0xd4a7
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x4316
xorl %esi, %esi
testq %r15, %r15
setne %sil
movq %rbx, %rdi
callq 0xd4cf
movq %r14, %rdi
callq 0x3030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd4db
xorl %esi, %esi
jmp 0xd4e3
callq 0x3040
movslq (%rax), %rsi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x4327
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xd553
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xd553
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_O3/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:
testq %rdi, %rdi
je 0xd59a
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
testb $0x1, %dil
je 0xd582
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
movq %rdi, %r8
shldq $0x1, %rsi, %rcx
shrq %r8
addq %rsi, %rsi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0xd55e
retq
xorl %edx, %edx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd553
testl %ebx, %ebx
jg 0xd5e7
movq %rax, %rcx
notq %rcx
negq %rax
testq %rdx, %rdx
cmovneq %rcx, %rax
negq %rdx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rsi, %r8
setb %r10b
cmpq %rdx, %rcx
setb %r11b
testq %r8, %r8
js 0xd6b5
orb %r11b, %r10b
je 0xd6b5
shldq $0x1, %rdi, %r9
addq %rdi, %rdi
shldq $0x1, %rcx, %r8
addq %rcx, %rcx
cmpq %rsi, %r8
jbe 0xd688
movq %rdi, %r10
orq %r9, %r10
je 0xd70b
pushq %rbp
pushq %rbx
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %r8, %rsi
jb 0xd6dd
ja 0xd6d1
cmpq %rdx, %rcx
ja 0xd6dd
subq %rcx, %rdx
sbbq %r8, %rsi
orq %r9, %r11
orq %rdi, %r10
shrdq $0x1, %r9, %rdi
movq %r9, %rbx
shrdq $0x1, %r8, %rcx
shrq %rbx
shrq %r8
testq %rdi, %rdi
setne %bpl
cmpq $0x2, %r9
setae %r9b
orb %bpl, %r9b
movq %rbx, %r9
jne 0xd6c5
popq %rbx
popq %rbp
jmp 0xd711
xorl %r11d, %r11d
xorl %r10d, %r10d
movq %r11, (%rax)
movq %r10, 0x8(%rax)
movq %rdx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %eax
testq %rsi, %rsi
jns 0xd76c
movq %rsi, %rax
notq %rax
negq %rsi
testq %rdx, %rdx
cmovneq %rax, %rsi
negq %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 0xd67a
testl %ebp, %ebp
jns 0xd7de
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 0xd7de
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 0xd7e7
negq 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %eax
testq %rsi, %rsi
js 0xd80e
movq %r14, %rsi
jmp 0xd829
movq %r14, %rax
notq %rax
movq %r14, %rsi
negq %rsi
testq %rdx, %rdx
cmovneq %rax, %rsi
negq %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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 0xd67a
testq %r14, %r14
jns 0xd851
negq 0x10(%rbx)
testl %ebp, %ebp
jns 0xd876
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_O3/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 0x68f3
movq %rax, %rbx
cmpl $0x11, 0xa8(%rax)
jl 0xda42
leaq 0x1efa(%rip), %rsi      # 0xf932
movq %r14, %rdi
xorl %eax, %eax
callq 0x67d2
movq 0x60(%r14), %rdi
callq 0x429d
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_O3/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 0x68f3
movq %rax, %rbx
movl 0xa8(%rax), %eax
testl %eax, %eax
jne 0xda98
leaq 0x1ecf(%rip), %rsi      # 0xf957
movq %r14, %rdi
xorl %eax, %eax
callq 0x67d2
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 0x4316
// File: /workspace/github_c_makefile_star2_O3/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 0x68f3
movq %rax, %rbx
movl 0xa8(%rax), %eax
testl %eax, %eax
jg 0xdae8
leaq 0x1ea1(%rip), %rsi      # 0xf979
movq %r14, %rdi
xorl %eax, %eax
callq 0x67d2
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_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movslq 0xa8(%rax), %r14
testq %r14, %r14
jle 0xdb61
movq %rax, %r15
xorl %r12d, %r12d
movq 0x60(%rbx), %rdi
movq 0x28(%r15,%r12,8), %rsi
callq 0x4316
incq %r12
cmpq %r12, %r14
jne 0xdb4b
movq 0x60(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4338
// File: /workspace/github_c_makefile_star2_O3/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 0x429d
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42ad
movzbl %al, %r15d
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xb769
movzwl %ax, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb7e9
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xdc03
movq %rax, %r14
movq %rax, %rsi
callq 0x4316
movq 0x60(%rbx), %rbx
movq %r14, %rdi
callq 0xb92c
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 0x4327
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4338
// File: /workspace/github_c_makefile_star2_O3/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 0x42bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x68f3
movq %rax, %r15
cmpl $0x11, %r14d
jl 0xdc7e
leaq 0x1d35(%rip), %rsi      # 0xf9a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x67d2
movl %r14d, 0xa8(%r15)
jmp 0xdc8c
testl %r14d, %r14d
js 0xdcba
movl %r14d, 0xa8(%r15)
je 0xdcae
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
leaq -0x1(%r14), %r12
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, 0x20(%r15,%r14,8)
cmpq $0x1, %r14
movq %r12, %r14
ja 0xdc93
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc605
// File: /workspace/github_c_makefile_star2_O3/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 0x68f3
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42ad
movq %r14, %rdi
movl %eax, %esi
callq 0xc5c7
movq 0x60(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4316
// File: /workspace/github_c_makefile_star2_O3/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 0x6ab4
movq 0x8(%rax), %r14
testq %r14, %r14
je 0xdd25
movq %r14, %rdi
callq 0x30e0
movq %rax, %r15
jmp 0xdd28
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6abd
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6abd
// File: /workspace/github_c_makefile_star2_O3/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 0xddc6
cltq
orb %sil, (%rdi,%rax)
retq
notb %sil
cltq
andb %sil, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x4, %edi
movl $0x10, %esi
callq 0x11f0
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x2ebf(%rip), %r15      # 0x4050
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x12f5
addq $0x4, %r14
cmpq $0x18, %r14
jne 0x1191
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1369
cmpl $-0x2, %eax
je 0x11e3
leaq 0xe44(%rip), %r14       # 0x2004
leaq 0xc(%rsp), %r15
movl 0xc(%rsp), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1369
cmpl $-0x2, %eax
jne 0x11c5
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop