LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x10270
movw %ax, -0x2e(%rbp)
movq -0x18(%rbp), %rax
movl 0xa8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x2f(%rbp)
jl 0x114f5
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x2f(%rbp)
movb -0x2f(%rbp), %al
testb $0x1, %al
jne 0x114fe
jmp 0x11536
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x28(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movw -0x2e(%rbp), %ax
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movzwl %ax, %ecx
callq 0x103d0
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x114dd
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x114a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x11610
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x49, %rax
je 0x115ea
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x8a, %rax
jne 0x11610
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x11631
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
callq 0x11300
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryUnsmudge
void ficlDictionaryUnsmudge(ficlDictionary *dictionary)
{
    ficlWord *word = dictionary->smudge;
    ficlHash *hash = dictionary->compilationWordlist;

    FICL_DICTIONARY_ASSERT(dictionary, hash);
    FICL_DICTIONARY_ASSERT(dictionary, word);
    /*
    ** :noname words never get linked into the list...
    */
    if (word->length > 0)
        ficlHashInsertWord(hash, word);
    word->flags &= ~(FICL_WORD_SMUDGED);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jle 0x1175e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10360
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %ecx
andl $-0x5, %ecx
movb %cl, 0xa(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x114a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x11835
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x19(%rbp), %ecx
callq 0x11780
movq %rax, -0x38(%rbp)
jmp 0x1184b
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x19(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
shlq $0x3, %rax
addq $0xc0, %rax
addq $0x20, %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf930
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xac(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x119f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
addq $0xb8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x10f70
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq $0x20, %rax
movl %eax, %esi
callq 0x10fa0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x104c0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x11b00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10f70
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x3, %rax
addq $0x20, %rax
movl %eax, %esi
callq 0x10fa0
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x104c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryResetSearchOrder
void ficlDictionaryResetSearchOrder(ficlDictionary *dictionary)
{
    FICL_DICTIONARY_ASSERT(dictionary, dictionary);
    dictionary->compilationWordlist = dictionary->forthWordlist;
    dictionary->wordlistCount = 1;
    dictionary->wordlists[0] = dictionary->forthWordlist;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
jle 0x11b72
movq -0x18(%rbp), %rax
cmpq $0xb4, %rax
jge 0x11b72
movl $0x1, -0x4(%rbp)
jmp 0x11c33
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11c40
cmpl $0x0, %eax
jne 0x11b90
movl $0x0, -0x4(%rbp)
jmp 0x11c33
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x11c40
cmpl $0x0, %eax
jne 0x11bb2
movl $0x0, -0x4(%rbp)
jmp 0x11c33
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11bda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x11c40
cmpl $0x0, %eax
jne 0x11bda
movl $0x0, -0x4(%rbp)
jmp 0x11c33
movq -0x18(%rbp), %rax
movzbl 0xb(%rax), %eax
cmpl $0x0, %eax
jle 0x11c00
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x11c09
movl $0x0, -0x4(%rbp)
jmp 0x11c33
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x30d0
movq -0x18(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
cmpq %rcx, %rax
je 0x11c2c
movl $0x0, -0x4(%rbp)
jmp 0x11c33
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11c40
cmpl $0x0, %eax
jne 0x11ccc
movq $0x0, -0x8(%rbp)
jmp 0x11d26
movl $0x64, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x11d1e
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $-0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11b40
cmpl $0x0, %eax
je 0x11d05
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11d26
jmp 0x11d07
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x11cd3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xfffffeff, -0x1c(%rbp) # imm = 0xFFFFFEFF
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfa50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x127d4
cmpq $-0x1, -0x28(%rbp)
je 0x127d4
cmpq $0x0, -0x38(%rbp)
jle 0x127d4
movq -0x38(%rbp), %rdi
callq 0x3210
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x3090
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x127d2
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x9720
movl %eax, -0x1c(%rbp)
jmp 0x127d4
cmpl $0x0, -0x1c(%rbp)
jge 0x127ef
cmpl $0xfffffeff, -0x1c(%rbp) # imm = 0xFFFFFEFF
je 0x127ef
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8d90
movq -0x8(%rbp), %rax
movq $-0x1, 0x78(%rax)
leaq 0x2ba4(%rip), %rax      # 0x153a6
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x9720
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rdi
callq 0x131f0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31d0
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x3090
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4c90
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3080
movq -0x30(%rbp), %rdi
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31d0
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x32e0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3080
movq -0x28(%rbp), %rdi
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x32e0
cmpq -0x18(%rbp), %rax
jne 0x12ba5
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0x280d(%rip), %rdi      # 0x153a5
movl $0x1, %edx
movq %rdx, %rsi
callq 0x32e0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3080
movq -0x28(%rbp), %rdi
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x31a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c90
movq -0x8(%rbp), %rdi
cmpq $-0x1, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x31e0
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xf9f0
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4c90
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x4c90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x31e0
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3050
movq -0x28(%rbp), %rdi
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
movq -0x20(%rbp), %rdi
callq 0x3030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x31e0
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x31e0
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x32a0
movq -0x30(%rbp), %rdi
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
callq 0x131b0
movq -0x20(%rbp), %rdi
callq 0x3030
movq -0x28(%rbp), %rdi
callq 0x3030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x131ce
movl $0x0, -0x10(%rbp)
jmp 0x131d8
callq 0x3040
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x10(%rbp), %rsi
callq 0x4c90
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2IntegerNegate
ficl2Integer ficl2IntegerNegate(ficl2Integer x)
{
    x.high = ~x.high;
    x.low = ~x.low;
    x.low ++;
    if (x.low == 0)
        x.high++;

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13293
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13340
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13340
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x13320
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3120
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x133e4
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x133b2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x134f0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x135a0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x13370
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x13430
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x13449
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13340
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x13486
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1349b
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x13250
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2IntegerDecrement
ficl2Integer ficl2IntegerDecrement(ficl2Integer x)
{
	if (x.low == INT_MIN)
		x.high--;
	x.low--;

	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jne 0x134d2
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
decq %rax
movq %rax, -0x18(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedAdd
ficl2Unsigned ficl2UnsignedAdd(ficl2Unsigned x, ficl2Unsigned y)
{
    ficl2Unsigned result;
    int carry;
    
    result.high = x.high + y.high;
    result.low = x.low + y.low;


    carry  = ((x.low | y.low) & FICL_CELL_HIGH_BIT) && !(result.low & FICL_CELL_HIGH_BIT);
    carry |= ((x.low & y.low) & FICL_CELL_HIGH_BIT);

    if (carry)
    {
        result.high++;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rcx
orq -0x28(%rbp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x35(%rbp)
je 0x13556
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x8(%rbp), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rcx
andq -0x28(%rbp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq %rax, %rcx
movslq -0x34(%rbp), %rax
orq %rcx, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x13592
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedArithmeticShiftLeft
ficl2Unsigned ficl2UnsignedArithmeticShiftLeft( ficl2Unsigned x )
{
    ficl2Unsigned result;
    
    result.high = x.high << 1;
    if (x.low & FICL_CELL_HIGH_BIT) 
    {
        result.high++;
    }

    result.low = x.low << 1;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x135d7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedSubtract
ficl2Unsigned ficl2UnsignedSubtract(ficl2Unsigned x, ficl2Unsigned y)
{
    ficl2Unsigned result;
    
    result.high = x.high - y.high;
    result.low = x.low - y.low;

    if (x.low < y.low) 
    {
        result.high--;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x13632
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedArithmeticShiftRight
ficl2Unsigned ficl2UnsignedArithmeticShiftRight( ficl2Unsigned x )
{
    ficl2Unsigned result;
    
    result.low = x.low >> 1;
    if (x.high & 1) 
    {
        result.low |= FICL_CELL_HIGH_BIT;
    }

    result.high = x.high >> 1;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x13677
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x136f7
movl $0x1, -0x4(%rbp)
jmp 0x13739
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1370a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13739
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1371d
movl $0x1, -0x4(%rbp)
jmp 0x13739
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x13730
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13739
jmp 0x13732
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13230
cmpl $0x0, %eax
je 0x13a42
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13250
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x13a63
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x13740
movq -0x90(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x38(%rbp)
jge 0x13b31
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x13250
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
je 0x13b2f
movq -0x90(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x134b0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
subq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x13b31
cmpl $0x0, -0x34(%rbp)
jge 0x13b48
movq -0x90(%rbp), %rax
xorl %ecx, %ecx
subq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13230
cmpl $0x0, %eax
je 0x13bd4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x13250
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x13bed
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x13740
movq -0x80(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x34(%rbp)
jge 0x13c49
movq -0x80(%rbp), %rax
xorl %ecx, %ecx
subq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x38(%rbp)
jge 0x13c7d
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x13250
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0xa8(%rax)
jle 0x13e88
movq -0x8(%rbp), %rdi
leaq 0x2bc3(%rip), %rsi      # 0x16a44
movb $0x0, %al
callq 0x8dc0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movl 0xa8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xa8(%rsi)
movslq %ecx, %rcx
movq %rdx, 0x28(%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x13efe
movq -0x8(%rbp), %rdi
leaq 0x2b72(%rip), %rsi      # 0x16a69
movb $0x0, %al
callq 0x8dc0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0xa8(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa8(%rdx)
movslq %ecx, %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0x4c60
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xa8(%rax)
jge 0x13f68
movq -0x8(%rbp), %rdi
leaq 0x2b2a(%rip), %rsi      # 0x16a8b
movb $0x0, %al
callq 0x8dc0
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xa8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x28(%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xa8(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1406a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq 0x28(%rax,%rcx,8), %rsi
callq 0x4c60
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1403d
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0x4cc0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movzbl %al, %eax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10270
movw %ax, -0x1a(%rbp)
movq -0x30(%rbp), %rdi
movw -0x1a(%rbp), %ax
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movzwl %ax, %ecx
callq 0x103d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1414c
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x106a0
movq -0x38(%rbp), %rdi
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rsi
callq 0x4c90
jmp 0x1415d
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4cc0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)