LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sfeakes[P]unifi-motion/config.c
// Function: print_config
void print_config(umConfig *config)
{
  int i;

  fprintf(stderr, "CFG mqtt address '%s'\n", config->mqtt_address );
  fprintf(stderr, "CFG mqtt user '%s'\n", config->mqtt_user );
  fprintf(stderr, "CFG mqtt passwd '%s'\n", config->mqtt_passwd );
  fprintf(stderr, "CFG mqtt topic '%s'\n", config->mqtt_pub_topic );
  fprintf(stderr, "CFG log regexp '%s'\n", config->regexString );
  fprintf(stderr, "CFG log to monitor '%s'\n", config->log_file_to_monitor );
  fprintf(stderr, "CFG watch filename '%s'\n", config->watchFile );
  fprintf(stderr, "CFG watch directory '%s'\n", config->watchDir );

  for (i = 0; i < config->numMotions; i++) {
    fprintf(stderr, "CFG Motion '%s'='%s'\n", config->motions[i]->name, config->motions[i]->action);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xafc7(%rip), %r15      # 0x1dff0
movq (%r15), %rdi
movq (%rbx), %rdx
leaq 0x3a79(%rip), %rsi      # 0x16aaf
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x8(%rbx), %rdx
leaq 0x3a7b(%rip), %rsi      # 0x16ac6
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
leaq 0x3a7a(%rip), %rsi      # 0x16ada
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x18(%rbx), %rdx
leaq 0x3a7b(%rip), %rsi      # 0x16af0
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x28(%rbx), %rdx
leaq 0x3a7b(%rip), %rsi      # 0x16b05
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x20(%rbx), %rdx
leaq 0x3a7b(%rip), %rsi      # 0x16b1a
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x50(%rbx), %rdx
leaq 0x3a7f(%rip), %rsi      # 0x16b33
xorl %eax, %eax
callq 0x3340
movq (%r15), %rdi
movq 0x48(%rbx), %rdx
leaq 0x3a83(%rip), %rsi      # 0x16b4c
xorl %eax, %eax
callq 0x3340
leaq 0x3a8f(%rip), %r14      # 0x16b66
xorl %r12d, %r12d
movslq 0x1d8(%rbx), %rax
cmpq %rax, %r12
jge 0x13104
movq (%r15), %rdi
movq 0x98(%rbx,%r12,8), %rdx
leaq 0x28(%rdx), %rcx
movq %r14, %rsi
xorl %eax, %eax
callq 0x3340
incq %r12
jmp 0x130da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sfeakes[P]unifi-motion/config.c
// Function: free_config
void free_config(umConfig *config)
{
  int i;

  for (i=0; i<config->numMotions; i++){
    free(config->motions[i]);
  }

  free(config->mqtt_address);
  free(config->mqtt_user);
  free(config->mqtt_passwd);
  free(config->mqtt_pub_topic);
  free(config->log_file_to_monitor);
  free(config->regexString);
  free(config->watchDir);
  free(config->watchFile);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x1d8(%rbx), %rax
cmpq %rax, %r14
jge 0x13138
movq 0x98(%rbx,%r14,8), %rdi
callq 0x3060
incq %r14
jmp 0x1311a
movq (%rbx), %rdi
callq 0x3060
movq 0x8(%rbx), %rdi
callq 0x3060
movq 0x10(%rbx), %rdi
callq 0x3060
movq 0x18(%rbx), %rdi
callq 0x3060
movq 0x20(%rbx), %rdi
callq 0x3060
movq 0x28(%rbx), %rdi
callq 0x3060
movq 0x48(%rbx), %rdi
callq 0x3060
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O2/erik[P]gamut/rotate.c
// Function: interpolate
pixel_t interpolate(pixel_t a, pixel_t b, double t)
{
    double s = 1.0 - t;
    return (pixel_t){
        a.r * s + b.r * t,
        a.g * s + b.g * t,
        a.b * s + b.b * t,
        a.a * s + b.a * t
    };
}

// Assembly:
pushq %rbx
movl %edi, %r11d
shrl $0x10, %r11d
movq %rdi, %r9
shrq $0x20, %r9
movq %rdi, %rdx
movl %esi, %ebx
movq %rsi, %r10
movq %rsi, %r8
movl $0xffff, %ecx           # imm = 0xFFFF
andl %ecx, %edi
cvtsi2sd %edi, %xmm2
movsd 0xd8d(%rip), %xmm1      # 0x2008
andl %ecx, %esi
cvtsi2sd %esi, %xmm3
subsd %xmm0, %xmm1
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
cvttsd2si %xmm2, %eax
cvtsi2sd %r11d, %xmm2
shrl $0x10, %ebx
cvtsi2sd %ebx, %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
cvttsd2si %xmm2, %esi
shrq $0x30, %rdx
andl %ecx, %r9d
cvtsi2sd %r9d, %xmm2
shrq $0x20, %r10
andl %ecx, %r10d
cvtsi2sd %r10d, %xmm3
shrq $0x30, %r8
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
cvttsd2si %xmm2, %edi
cvtsi2sd %edx, %xmm2
cvtsi2sd %r8d, %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
cvttsd2si %xmm2, %edx
shlq $0x30, %rdx
andl %ecx, %edi
shlq $0x20, %rdi
orq %rdx, %rdi
shll $0x10, %esi
orq %rdi, %rsi
andl %ecx, %eax
orq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/erik[P]gamut/rotate.c
// Function: main
int main(int argc, char** argv)
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s ANGLE\n", argv[0]);
        return 1;
    }

    double angle = atof(argv[1]);

    return rotate(angle);
}

// Assembly:
pushq %rax
cmpl $0x2, %edi
jne 0x194c
movq 0x8(%rsi), %rdi
callq 0x1050
popq %rax
jmp 0x1310
movq 0x26a5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0x6f9(%rip), %rsi       # 0x2059
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/seakeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    SeaKeyak_Instance instance;

    SeaKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    SeaKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
movq 0x210(%rsp), %rsi
movq 0x208(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
leaq 0x20(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x53b0
leaq (%rbx,%rbp), %rax
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x5670
addq $0x10, %rbx
movq 0x18(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/seakeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    SeaKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    SeaKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( SeaKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char*)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
cmpq $0x10, %r8
jae 0x10fb0
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rsi, %rbp
movq %rdi, %r15
movq 0x210(%rsp), %rsi
movq 0x208(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andq $0x0, (%rsp)
pushq $0x1
popq %r12
movl %r12d, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x53b0
leaq -0x10(%r13), %rcx
movq %rcx, (%rbp)
leaq (%r14,%r13), %rax
addq $-0x10, %rax
movl %r12d, 0x8(%rsp)
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
movq 0x200(%rsp), %r9
callq 0x5670
movl %eax, %ecx
xorl %eax, %eax
cmpl %r12d, %ecx
setne %al
negl %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/main.c
// Function: main
int main(int argc, char **argv)
{
    int returnValue = 0;
    char buffer[256];
    ficlVm *vm;
	ficlSystem *system;

    system = ficlSystemCreate(NULL);
    ficlSystemCompileExtras(system);
    vm = ficlSystemCreateVm(system);

    returnValue = ficlVmEvaluate(vm, ".ver .( " __DATE__ " ) cr quit");

    /*
    ** load files specified on command-line
    */
    if (argc  > 1)
    {
        sprintf(buffer, ".( loading %s ) cr load %s\n cr", argv[1], argv[1]);
        returnValue = ficlVmEvaluate(vm, buffer);
    }

    while (returnValue != FICL_VM_STATUS_USER_EXIT)
    {
        fputs(FICL_PROMPT, stdout);
        if (fgets(buffer, sizeof(buffer), stdin) == NULL) break;
        returnValue = ficlVmEvaluate(vm, buffer);
    }

    ficlSystemDestroy(system);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r15
movl %edi, %ebp
xorl %edi, %edi
callq 0x3504
movq %rax, %rbx
movq %rax, %rdi
callq 0xb340
movq %rbx, %rdi
callq 0x389b
movq %rax, %r14
leaq 0xab82(%rip), %rsi      # 0xe004
movq %rax, %rdi
callq 0x693c
cmpl $0x2, %ebp
jl 0x34b2
movq 0x8(%r15), %rcx
leaq 0xab88(%rip), %rsi      # 0xe022
movq %rsp, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x32f0
movq %rsp, %rsi
movq %r14, %rdi
callq 0x693c
cmpl $0xfffffefd, %eax       # imm = 0xFFFFFEFD
je 0x34eb
movq 0x12b18(%rip), %rax     # 0x15fd8
movq (%rax), %rsi
leaq 0xab77(%rip), %rdi      # 0xe041
callq 0x3120
movq 0x12b0a(%rip), %rax     # 0x15fe0
movq (%rax), %rdx
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3170
testq %rax, %rax
jne 0x34a7
movq %rbx, %rdi
callq 0x390a
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/system.c
// Function: ficlSystemAddPrimitiveParseStep
void ficlSystemAddPrimitiveParseStep(ficlSystem *system, char *name, ficlParseStep pStep)
{
    ficlDictionary *dictionary = system->dictionary;
    ficlWord *word = ficlDictionaryAppendPrimitive(dictionary, name, ficlPrimitiveParseStepParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(pStep));
    ficlSystemAddParseStep(system, word);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
leaq 0x34e3(%rip), %rdx      # 0x6d50
movq %r15, %rdi
xorl %ecx, %ecx
callq 0xbbab
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb7cd
movq %r14, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3955
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/system.c
// Function: ficlSystemCreateVm
ficlVm *ficlSystemCreateVm(ficlSystem *system)
{
    ficlVm *vm = ficlVmCreate(NULL, system->stackSize, system->stackSize);
    vm->link = system->vmList;

	memcpy(&(vm->callback), &(system->callback), sizeof(system->callback));
	vm->callback.vm = vm;
	vm->callback.system = system;

    system->vmList = vm;
    return vm;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xb0(%rdi), %edx
xorl %edi, %edi
movl %edx, %esi
callq 0x5140
movq 0x30(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq %rax, 0x20(%rax)
movq %rbx, 0x18(%rax)
movq %rax, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveFLiteralImmediate
static void ficlPrimitiveFLiteralImmediate(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlCell cell;


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


	cell = ficlStackPop(vm->floatStack);
	if (cell.f == 1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF1);
	}
	else if (cell.f == 0.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF0);
	}
	else if (cell.f == -1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFNeg1);
	}
	else
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFLiteralParen);
		ficlDictionaryAppendCell(dictionary, cell);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6643
movq %rax, %rbx
movq 0x70(%r14), %rdi
callq 0x41fe
movq %rax, %r14
movd %r14d, %xmm0
ucomiss 0xa508(%rip), %xmm0     # 0xe1e8
jne 0x3ce8
jp 0x3ce8
pushq $0x23
jmp 0x3d03
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3cf6
jp 0x3cf6
pushq $0x22
jmp 0x3d03
ucomiss 0xa4ef(%rip), %xmm0     # 0xe1ec
jne 0x3d13
jp 0x3d13
pushq $0x24
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7e8
movl $0x88, %esi
movq %rbx, %rdi
callq 0xb7e8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveFConstant
static void ficlPrimitiveFConstant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionFConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6643
movq %rax, %r14
movq %rbx, %rdi
callq 0x6713
movl $0x89, %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xb893
movq 0x70(%rbx), %rdi
callq 0x41fe
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveF2Constant
static void ficlPrimitiveF2Constant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionF2ConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6643
movq %rax, %rbx
movq %r14, %rdi
callq 0x6713
movl $0x8a, %ecx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xb893
movq 0x70(%r14), %rdi
callq 0x41fe
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb7cd
movq 0x70(%r14), %rdi
callq 0x41fe
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb7cd
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/prefix.c
// Function: ficlVmParsePrefix
int ficlVmParsePrefix(ficlVm *vm, ficlString s)
{
    int i;
    ficlHash *hash;
    ficlWord *word = ficlSystemLookup(vm->callback.system, list_name);

    /* 
    ** Make sure we found the prefix dictionary - otherwise silently fail
    ** If forth-wordlist is not in the search order, we won't find the prefixes.
    */
    if (!word)
        return 0; /* false */

    hash = (ficlHash *)(word->param[0].p);
    /*
    ** Walk the list looking for a match with the beginning of the incoming token
    */
    for (i = 0; i < (int)hash->size; i++)
    {
        word = hash->table[i];
        while (word != NULL)
        {
            int n;
            n = word->length;
            /*
            ** If we find a match, adjust the TIB to give back the non-prefix characters
            ** and execute the prefix word.
            */
            if (!ficlStrincmp(FICL_STRING_GET_POINTER(s), word->name, (ficlUnsigned)n))
            {
                /* (sadler) fixed off-by-one error when the token has no trailing space in the TIB */
                ficlVmSetTibIndex(vm, s.text + n - vm->tib.text);
                ficlVmExecuteWord(vm, word);

                return 1; /* true */
            }
            word = word->link;
        }
    }

    return 0; /* false */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x12204(%rip), %rsi     # 0x161c0
callq 0x3977
testq %rax, %rax
je 0x4031
movq 0x28(%rax), %rbp
leaq 0x18(%rbp), %rcx
xorl %r15d, %r15d
movq %rcx, (%rsp)
movslq 0x10(%rbp), %rax
cmpq %rax, %r15
jge 0x4031
leaq (%rcx,%r15,8), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x4007
movzbl 0xb(%r12), %r13d
movq 0x10(%r12), %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0xaf4e
testl %eax, %eax
jne 0x3fe2
jmp 0x4010
incq %r15
movq (%rsp), %rcx
jmp 0x3fd5
addq %r13, %r14
subq 0x90(%rbx), %r14
movq %r14, 0x80(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x523a
pushq $0x1
popq %rax
jmp 0x4033
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/prefix.c
// Function: ficlPrimitiveTempBase
static void ficlPrimitiveTempBase(ficlVm *vm)
{
    int oldbase = vm->base;
    ficlString number = ficlVmGetWord0(vm);
    int base = ficlStackPopInteger(vm->dataStack);

    vm->base = base;
    if (!ficlVmParseNumber(vm, number)) 
        ficlVmThrowError(vm, "%.*s not recognized", FICL_STRING_GET_LENGTH(number), FICL_STRING_GET_POINTER(number));

    vm->base = oldbase;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r12
callq 0x6744
movq %rax, %r14
movq %rdx, %r15
movq 0x60(%rbx), %rdi
callq 0x422e
cltq
movq %rax, 0x58(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6b7b
testl %eax, %eax
jne 0x40d3
leaq 0xa1ee(%rip), %rsi      # 0xe2b1
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x6527
movslq %r12d, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/softcore.c
// Function: ficlSystemCompileSoftCore
void ficlSystemCompileSoftCore(ficlSystem *system)
{
    ficlVm *vm = system->vmList;
    int returnValue;
    ficlCell oldSourceID = vm->sourceId;
    ficlString s;
#if FICL_WANT_LZ_SOFTCORE
    char *ficlSoftcoreUncompressed = NULL;
    size_t gotUncompressedSize = 0;
    returnValue = ficlLzUncompress(ficlSoftcoreCompressed, (unsigned char **)&ficlSoftcoreUncompressed, &gotUncompressedSize);
    FICL_VM_ASSERT(vm, returnValue == 0);
    FICL_VM_ASSERT(vm, gotUncompressedSize == ficlSoftcoreUncompressedSize);
#endif /* FICL_WANT_LZ_SOFTCORE */
    vm->sourceId.i = -1;
    FICL_STRING_SET_POINTER(s, (char *)(ficlSoftcoreUncompressed));
    FICL_STRING_SET_LENGTH(s, ficlSoftcoreUncompressedSize);
    returnValue = ficlVmExecuteString(vm, s);
    vm->sourceId = oldSourceID;
#if FICL_WANT_LZ_SOFTCORE
    free(ficlSoftcoreUncompressed);
#endif /* FICL_WANT_LZ_SOFTCORE */
    FICL_VM_ASSERT(vm, returnValue != FICL_VM_STATUS_ERROR_EXIT);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %rbx
movq 0x78(%rbx), %r15
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsp, %rdx
andq $0x0, (%rdx)
leaq 0x120c0(%rip), %rdi     # 0x161d0
movq %r14, %rsi
callq 0xaaea
orq $-0x1, 0x78(%rbx)
movq (%r14), %rdx
movl $0x6457, %esi           # imm = 0x6457
movq %rbx, %rdi
callq 0x6970
movq %r15, 0x78(%rbx)
movq (%r14), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/stack.c
// Function: ficlStackCreate
ficlStack *ficlStackCreate(ficlVm *vm, char *name, unsigned size)
{
    size_t totalSize = sizeof (ficlStack) + (size * sizeof (ficlCell));
    ficlStack *stack = ficlMalloc(totalSize);

    FICL_VM_ASSERT(vm, size != 0);
    FICL_VM_ASSERT(vm, stack != NULL);

    stack->size = size;
    stack->frame = NULL;

	stack->vm = vm;
	stack->name = name;

	ficlStackReset(stack);
    return stack;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
leaq 0x30(,%r15,8), %rdi
callq 0xac87
movq %r15, (%rax)
andq $0x0, 0x8(%rax)
movq %r14, 0x18(%rax)
leaq 0x20(%rax), %rcx
movq %rbx, 0x20(%rax)
movq %rcx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/stack.c
// Function: ficlStackWalk
void ficlStackWalk(ficlStack *stack, ficlStackWalkFunction callback, void *context, ficlInteger bottomToTop)
{
    int i;
    int depth;
	ficlCell *cell;
    FICL_STACK_CHECK(stack, 0, 0);

	depth = ficlStackDepth(stack);
	cell = bottomToTop ? stack->base : stack->top;
    for (i = 0; i < depth; i++)
    {
        if (callback(context, cell) == FICL_FALSE)
			break;
        cell += bottomToTop ? 1 : -1;
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
addq $0x28, %r15
movq %rax, %rdx
subq %r15, %rdx
shrq $0x3, %rdx
incl %edx
xorl %r12d, %r12d
testq %rcx, %rcx
setne %r12b
cmoveq %rax, %r15
shll $0x4, %r12d
addq $-0x8, %r12
xorl %ebp, %ebp
testl %edx, %edx
cmovgl %edx, %ebp
subl $0x1, %ebp
jb 0x43be
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
testq %rax, %rax
je 0x43be
addq %r12, %r15
jmp 0x43a6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveHashSummary
void ficlPrimitiveHashSummary(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *pFHash;
    ficlWord **hash;
    unsigned size;
    ficlWord *word;
    unsigned i;
    int nMax = 0;
    int nWords = 0;
    int nFilled;
    double avg = 0.0;
    double best;
    int nAvg, nRem, nDepth;

    FICL_VM_DICTIONARY_CHECK(vm, dictionary, 0);

    pFHash = dictionary->wordlists[dictionary->wordlistCount - 1];
    hash  = pFHash->table;
    size   = pFHash->size;
    nFilled = size;

    for (i = 0; i < size; i++)
    {
        int n = 0;
        word = hash[i];

        while (word)
        {
            ++n;
            ++nWords;
            word = word->link;
        }

        avg += (double)(n * (n+1)) / 2.0;

        if (n > nMax)
            nMax = n;
        if (n == 0)
            --nFilled;
    }

    /* Calc actual avg search depth for this hash */
    avg = avg / nWords;

    /* Calc best possible performance with this size hash */
    nAvg = nWords / size;
    nRem = nWords % size;
    nDepth = size * (nAvg * (nAvg+1))/2 + (nAvg+1)*nRem;
    best = (double)nDepth/nWords;

    sprintf(vm->pad, 
        "%d bins, %2.0f%% filled, Depth: Max=%d, Avg=%2.1f, Best=%2.1f, Score: %2.0f%%\n", 
        size,
        (double)nFilled * 100.0 / size, nMax,
        avg, 
        best,
        100.0 * best / avg);

    ficlVmTextOut(vm, vm->pad);

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6643
movslq 0xa8(%rax), %rcx
movq 0x20(%rax,%rcx,8), %rax
movl 0x10(%rax), %r8d
addq $0x18, %rax
xorl %edx, %edx
xorpd %xmm0, %xmm0
movsd 0x9ed1(%rip), %xmm1     # 0xe2c8
movl %r8d, %edi
xorl %esi, %esi
xorl %ecx, %ecx
cmpq %r8, %rdx
je 0x4447
leaq (%rax,%rdx,8), %r10
xorl %r9d, %r9d
movq (%r10), %r10
testq %r10, %r10
je 0x4417
decl %r9d
jmp 0x440a
movl %r9d, %r10d
negl %r10d
subl %r9d, %esi
subl $0x1, %r9d
sbbl $0x0, %edi
negl %r9d
imull %r10d, %r9d
cvtsi2sd %r9d, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
cmpl %ecx, %r10d
cmovgl %r10d, %ecx
incq %rdx
jmp 0x43fe
movl %esi, %eax
xorl %edx, %edx
divl %r8d
cvtsi2sd %esi, %xmm1
leal 0x1(%rax), %esi
imull %r8d, %eax
imull %esi, %eax
shrl %eax
imull %esi, %edx
addl %eax, %edx
cvtsi2sd %edx, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm2
leaq 0x118(%rbx), %r14
cvtsi2sd %edi, %xmm0
movsd 0x9e4a(%rip), %xmm3     # 0xe2d0
mulsd %xmm3, %xmm0
movl %r8d, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm3
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
divsd %xmm1, %xmm3
leaq 0x9e6f(%rip), %rsi      # 0xe31c
movq %r14, %rdi
movl %r8d, %edx
movb $0x4, %al
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68f1
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplay
void ficlStackDisplay(ficlStack *stack, ficlStackWalkFunction callback, void *context)
{
	ficlVm *vm = stack->vm;
	char buffer[128];
	struct stackContext myContext;

    FICL_STACK_CHECK(stack, 0, 0);

	sprintf(buffer, "[%s stack has %d entries, top at 0x%08x]\n", stack->name, ficlStackDepth(stack), stack->top);
	ficlVmTextOut(vm, buffer);

    if (callback == NULL)
    {
        myContext.vm = vm;
	    myContext.count = 0;
		context = &myContext;
		callback = ficlStackDisplayCallback;
    }
	ficlStackWalk(stack, callback, context, FICL_FALSE);

	sprintf(buffer, "[%s stack base at 0x%08x]\n", stack->name, stack->base);
	ficlVmTextOut(vm, buffer);

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r13
callq 0x4191
movq 0x10(%r14), %r8
leaq 0x9e6d(%rip), %rsi      # 0xe36b
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x68f1
testq %r12, %r12
jne 0x4536
leaq 0x8(%rsp), %r15
movq %rbx, (%r15)
andl $0x0, 0x10(%r15)
leaq 0x4e(%rip), %r12        # 0x4584
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x4364
movq 0x20(%r14), %rdx
addq $0x28, %r14
leaq 0x9e40(%rip), %rsi      # 0xe395
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x68f1
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayDataStackSimple
void ficlVmDisplayDataStackSimple(ficlVm *vm)
{
    ficlStack *stack = vm->dataStack;
    char buffer[32];
    struct stackContext context;

    FICL_STACK_CHECK(stack, 0, 0);

    sprintf(buffer, "[%d] ", ficlStackDepth(stack));
    ficlVmTextOut(vm, buffer);

    context.vm = vm;
    context.count = 0;
    ficlStackWalk(stack, ficlStackDisplaySimpleCallback, &context, FICL_TRUE);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x4191
leaq 0x9dba(%rip), %rsi      # 0xe3b0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x68f1
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
andl $0x0, 0x10(%rdx)
leaq 0x15(%rip), %rsi        # 0x463a
pushq $-0x1
popq %rcx
movq %r14, %rdi
callq 0x4364
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplaySimpleCallback
static ficlInteger ficlStackDisplaySimpleCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[32];
    sprintf(buffer, "%s%d", context->count ? " " : "", cell->i);
    context->count++;
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
leaq 0x9d1b(%rip), %rax      # 0xe36a
leaq 0xb01d(%rip), %rdx      # 0xf673
cmoveq %rax, %rdx
movq (%rsi), %rcx
leaq 0x9e10(%rip), %rsi      # 0xe474
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x32f0
incl 0x10(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x68f1
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayReturnStack
void ficlVmDisplayReturnStack(ficlVm *vm)
{
    struct stackContext context;
	context.vm = vm;
	context.count = 0;
	context.dictionary = ficlVmGetDictionary(vm);
    ficlStackDisplay(vm->returnStack, ficlReturnStackDisplayCallback, &context);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
andl $0x0, 0x10(%r14)
callq 0x6643
movq %rax, 0x8(%r14)
movq 0x68(%rbx), %rdi
leaq 0x10(%rip), %rsi        # 0x46c3
movq %r14, %rdx
callq 0x44cc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlReturnStackDisplayCallback
static ficlInteger ficlReturnStackDisplayCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[128];

    sprintf(buffer, "[0x%08x %3d] %12d (0x%08x)", cell, context->count++, cell->i, cell->i);

    /*
    ** Attempt to find the word that contains the return
    ** stack address (as if it is part of a colon definition).
    ** If this works, also print the name of the word.
    */
    if (ficlDictionaryIncludes(context->dictionary, cell->p))
    {
        ficlWord *word = ficlDictionaryFindEnclosingWord(context->dictionary, cell->p);
        if (word)
        {
            int offset = (ficlCell *)cell->p - &word->param[0];
            sprintf(buffer + strlen(buffer), ", %s + %d ", word->name, offset);
        }
    }
	strcat(buffer, "\n");
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
movq (%rsi), %r8
leaq 0x9d91(%rip), %rsi      # 0xe479
movq %rsp, %rdi
movq %r14, %rdx
movq %r8, %r9
xorl %eax, %eax
callq 0x32f0
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0xbe06
testl %eax, %eax
je 0x474b
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0xbe27
testq %rax, %rax
je 0x474b
movq %rax, %r15
movq (%r14), %r14
subq %rax, %r14
addq $-0x28, %r14
shrq $0x3, %r14
movq %rsp, %rdi
callq 0x30e0
leaq (%rsp,%rax), %rdi
movq 0x10(%r15), %rdx
leaq 0x9d53(%rip), %rsi      # 0xe494
movl %r14d, %ecx
xorl %eax, %eax
callq 0x32f0
movq %rsp, %r14
movq %r14, %rdi
callq 0x30e0
movw $0xa, (%rsp,%rax)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x68f1
pushq $-0x1
popq %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveParseStepList
void ficlPrimitiveParseStepList(ficlVm *vm)
{
    int i;
    ficlSystem *system = vm->callback.system;
    FICL_VM_ASSERT(vm, system);

    ficlVmTextOut(vm, "Parse steps:\n");
    ficlVmTextOut(vm, "lookup\n");

    for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
    {
        if (system->parseList[i] != NULL)
        {
            ficlVmTextOut(vm, system->parseList[i]->name);
            ficlVmTextOut(vm, "\n");
        }
        else break;
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0x9c29(%rip), %rsi      # 0xe3b6
callq 0x68f1
leaq 0x9c2b(%rip), %rsi      # 0xe3c4
movq %rbx, %rdi
callq 0x68f1
xorl %r12d, %r12d
leaq 0x9bbe(%rip), %r14      # 0xe369
cmpq $0x8, %r12
je 0x47d7
movq 0x60(%r15,%r12,8), %rax
testq %rax, %rax
je 0x47d7
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x68f1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f1
incq %r12
jmp 0x47ab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveForget
static void ficlPrimitiveForget(ficlVm *vm)
{
    void *where;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash = dictionary->compilationWordlist;

    ficlPrimitiveTick(vm);
    where = ((ficlWord *)ficlStackPopPointer(vm->dataStack))->name;
    ficlHashForget(hash, where);
    dictionary->here = FICL_POINTER_TO_CELL(where);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6643
movq %rax, %r14
movq 0x20(%rax), %r15
movq %rbx, %rdi
callq 0x6df1
movq 0x60(%rbx), %rdi
callq 0x420e
movq 0x10(%rax), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb064
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveWords
static void ficlPrimitiveWords(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash = dictionary->wordlists[dictionary->wordlistCount - 1];
    ficlWord *wp;
    int nChars = 0;
    int len;
    unsigned i;
    int nWords = 0;
    char *cp;
    char *pPad = vm->pad;

    for (i = 0; i < hash->size; i++)
    {
        for (wp = hash->table[i]; wp != NULL; wp = wp->link, nWords++)
        {
            if (wp->length == 0) /* ignore :noname defs */
                continue;

            cp = wp->name;
            nChars += sprintf(pPad + nChars, "%s", cp);

            if (nChars > 70)
            {
                pPad[nChars++] = '\n';
                pPad[nChars] = '\0';
                nChars = 0;
                ficlVmTextOut(vm, pPad);
            }
            else
            {
                len = nCOLWIDTH - nChars % nCOLWIDTH;
                while (len-- > 0)
                    pPad[nChars++] = ' ';
            }

            if (nChars > 70)
            {
                pPad[nChars++] = '\n';
                pPad[nChars] = '\0';
                nChars = 0;
                ficlVmTextOut(vm, pPad);
            }
        }
    }

    if (nChars > 0)
    {
        pPad[nChars++] = '\n';
        pPad[nChars] = '\0';
        nChars = 0;
        ficlVmTextOut(vm, pPad);
    }

    sprintf(vm->pad, "Dictionary: %d words, %ld cells used of %u total\n", 
        nWords, (long) (dictionary->here - dictionary->base), dictionary->size);
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x6643
movslq 0xa8(%rax), %rcx
movq %rax, 0x8(%rsp)
movq 0x20(%rax,%rcx,8), %rax
leaq 0x118(%rbx), %r14
movq %rax, 0x18(%rsp)
addq $0x18, %rax
movq %rax, 0x10(%rsp)
xorl %edx, %edx
xorl %ebp, %ebp
xorl %eax, %eax
movq 0x18(%rsp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rdx
jae 0x4ae2
movq 0x10(%rsp), %rcx
movq %rdx, 0x20(%rsp)
leaq (%rcx,%rdx,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4ad5
cmpb $0x0, 0xb(%r15)
je 0x4ad1
movq 0x10(%r15), %rsi
movslq %eax, %r12
leaq (%r14,%r12), %r13
movq %r13, %rdi
callq 0x30d0
subl %r13d, %eax
addl %eax, %r12d
cmpl $0x47, %r12d
jl 0x4a94
movl %r12d, %eax
jmp 0x4aba
movl %r12d, %eax
cltd
pushq $0x8
popq %rcx
idivl %ecx
subl %edx, %ecx
movslq %r12d, %rax
testl %ecx, %ecx
jle 0x4ab2
decl %ecx
movb $0x20, (%r14,%rax)
incq %rax
jmp 0x4aa2
cmpq $0x47, %rax
jl 0x4ad1
movl %eax, %eax
movw $0xa, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f1
xorl %eax, %eax
incl %ebp
jmp 0x4a61
movq 0x20(%rsp), %rdx
incq %rdx
jmp 0x4a42
testl %eax, %eax
jle 0x4afd
movl %eax, %eax
movw $0xa, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f1
movq 0x8(%rsp), %rax
movq (%rax), %rcx
subq %rax, %rcx
addq $-0xb8, %rcx
sarq $0x3, %rcx
movl 0xac(%rax), %r8d
leaq 0x997e(%rip), %rsi      # 0xe49f
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x68f1
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveListEnv
static void ficlPrimitiveListEnv(ficlVm *vm)
{
    ficlDictionary *dictionary = vm->callback.system->environment;
    ficlHash *hash = dictionary->forthWordlist;
    ficlWord *word;
    unsigned i;
    int counter = 0;

    for (i = 0; i < hash->size; i++)
    {
        for (word = hash->table[i]; word != NULL; word = word->link, counter++)
        {
            ficlVmTextOut(vm, word->name);
            ficlVmTextOut(vm, "\n");
        }
    }

    sprintf(vm->pad, "Environment: %d words, %ld cells used of %u total\n", 
        counter, (long) (dictionary->here - dictionary->base), dictionary->size);
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rax), %r12
leaq 0x18(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
leaq 0x97ed(%rip), %r14      # 0xe369
xorl %ebp, %ebp
movl 0x10(%r12), %eax
cmpq %rax, %r15
jae 0x4bba
movq 0x10(%rsp), %rax
leaq (%rax,%r15,8), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x4bb5
movq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x68f1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f1
incl %ebp
jmp 0x4b91
incq %r15
jmp 0x4b7e
leaq 0x118(%rbx), %r14
movq 0x8(%rsp), %rax
movq (%rax), %rcx
subq %rax, %rcx
addq $-0xb8, %rcx
sarq $0x3, %rcx
movl 0xac(%rax), %r8d
leaq 0x98ec(%rip), %rsi      # 0xe4d1
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x68f1
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveDebugXT
static void ficlPrimitiveDebugXT(ficlVm *vm)
{
    ficlWord *xt    = ficlStackPopPointer(vm->dataStack);
    ficlWordKind   wk    = ficlWordClassify(xt);

    ficlStackPushPointer(vm->dataStack, xt);
    ficlPrimitiveSeeXT(vm);

    switch (wk)
    {
    case FICL_WORDKIND_COLON:
    case FICL_WORDKIND_DOES:
        /*
        ** Run the colon code and set a breakpoint at the next instruction
        */
        ficlVmExecuteWord(vm, xt);
        ficlVmSetBreak(vm, &(vm->callback.system->breakpoint));
        break;

    default:
        ficlVmExecuteWord(vm, xt);
        break;
    }

    return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x420e
movq %rax, %r14
movq %rax, %rdi
callq 0xb28e
movl %eax, %ebp
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x4287
movq %rbx, %rdi
callq 0x4f3a
cmpl $0x7, %ebp
je 0x4cc4
cmpl $0x2, %ebp
jne 0x4ce4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x523a
movl $0xb8, %esi
addq 0x18(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x50cb
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x523a
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/tools.c
// Function: ficlVmSetBreak
static void ficlVmSetBreak(ficlVm *vm, ficlBreakpoint *pBP)
{
    ficlWord *pStep = ficlSystemLookup(vm->callback.system, "step-break");
    FICL_VM_ASSERT(vm, pStep);

    pBP->address = vm->ip;
    pBP->oldXT = *vm->ip;
    *vm->ip = pStep;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x9354(%rip), %rsi      # 0xe434
callq 0x3977
movq 0x40(%r14), %rcx
movq %rcx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmCreate
ficlVm *ficlVmCreate(ficlVm *vm, unsigned nPStack, unsigned nRStack)
{
    if (vm == NULL)
    {
        vm = (ficlVm *)ficlMalloc(sizeof (ficlVm));
        FICL_ASSERT(NULL, vm);
        memset(vm, 0, sizeof (ficlVm));
    }

    if (vm->dataStack)
        ficlStackDestroy(vm->dataStack);
    vm->dataStack = ficlStackCreate(vm, "data", nPStack);

    if (vm->returnStack)
        ficlStackDestroy(vm->returnStack);
    vm->returnStack = ficlStackCreate(vm, "return", nRStack);

#if FICL_WANT_FLOAT
    if (vm->floatStack)
        ficlStackDestroy(vm->floatStack);
    vm->floatStack = ficlStackCreate(vm, "float", nPStack);
#endif

    ficlVmReset(vm);
    return vm;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x516d
movl $0x918, %edi            # imm = 0x918
callq 0xac87
movq %rax, %rbx
movl $0x918, %edx            # imm = 0x918
movq %rax, %rdi
xorl %esi, %esi
callq 0x3130
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x517b
callq 0x4187
leaq 0x9806(%rip), %rsi      # 0xe988
movq %rbx, %rdi
movl %ebp, %edx
callq 0x4145
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x519e
callq 0x4187
leaq 0x97e8(%rip), %rsi      # 0xe98d
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4145
movq %rax, 0x68(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x51c2
callq 0x4187
leaq 0x99f4(%rip), %rsi      # 0xebbd
movq %rbx, %rdi
movl %ebp, %edx
callq 0x4145
movq %rax, 0x70(%rbx)
movq %rbx, %rdi
callq 0x51e7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmReset
void ficlVmReset(ficlVm *vm)
{
    ficlVmQuit(vm);
    ficlStackReset(vm->dataStack);
#if FICL_WANT_FLOAT
    ficlStackReset(vm->floatStack);
#endif
    vm->base        = 10;
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68ba
movq 0x60(%rbx), %rdi
callq 0x417e
movq 0x70(%rbx), %rdi
callq 0x417e
movq $0xa, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmDestroy
void ficlVmDestroy(ficlVm *vm)
{
    if (vm)
    {
        ficlFree(vm->dataStack);
        ficlFree(vm->returnStack);
#if FICL_WANT_FLOAT
        ficlFree(vm->floatStack);
#endif
        ficlFree(vm);
    }

    return;
}

// Assembly:
testq %rdi, %rdi
je 0x5239
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xac91
movq 0x68(%rbx), %rdi
callq 0xac91
movq 0x70(%rbx), %rdi
callq 0xac91
movq %rbx, %rdi
popq %rbx
jmp 0xac91
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmOptimizeJumpToJump
static void ficlVmOptimizeJumpToJump(ficlVm *vm, ficlIp ip)
	{
	ficlIp destination;
	switch ((ficlInstruction)(*ip))
		{
		case ficlInstructionBranchParenWithCheck:
			*ip = (ficlWord *)ficlInstructionBranchParen;
			goto RUNTIME_FIXUP;

		case ficlInstructionBranch0ParenWithCheck:
			*ip = (ficlWord *)ficlInstructionBranch0Paren;
RUNTIME_FIXUP:
			ip++;
			destination = ip + *(int *)ip;
			switch ((ficlInstruction)*destination)
			{
				case ficlInstructionBranchParenWithCheck:
					/* preoptimize where we're jumping to */
					ficlVmOptimizeJumpToJump(vm, destination);
				case ficlInstructionBranchParen:
				{
					destination++;
					destination += *(int *)destination;
					*ip = (ficlWord *)(destination - ip);
					break;
				}
			}
		}
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x30, %rax
je 0x65f8
cmpq $0x32, %rax
jne 0x663b
pushq $0x33
jmp 0x65fa
pushq $0x31
popq %rax
movq %rax, (%rbx)
movslq 0x8(%rbx), %rax
leaq (%rbx,%rax,8), %r14
addq $0x8, %r14
movq (%r14), %rax
cmpq $0x31, %rax
je 0x6621
cmpq $0x30, %rax
jne 0x663b
movq %r14, %rdi
callq 0x65de
addq $0x8, %rbx
movslq 0x8(%r14), %rax
leaq (%r14,%rax,8), %rax
addq $0x8, %rax
subq %rbx, %rax
sarq $0x3, %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmParseStringEx
ficlString ficlVmParseStringEx(ficlVm *vm, char delimiter, char skipLeadingDelimiters)
{
    ficlString s;
    char *trace      = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    char c;

    if (skipLeadingDelimiters)
    {
        while ((trace != stop) && (*trace == delimiter))
            trace++;
    }

    FICL_STRING_SET_POINTER(s, trace);    /* mark start of text */

    for (c = *trace;
		(trace != stop) && (c != delimiter)
			&& (c != '\r') && (c != '\n');
		c = *++trace)
    {
        ;                   /* find next delimiter or end of line */
    }

                            /* set length of result */
    FICL_STRING_SET_LENGTH(s, trace - FICL_STRING_GET_POINTER(s));

    if ((trace != stop) && (*trace == delimiter))     /* gobble trailing delimiter */
        trace++;

    ficlVmUpdateTib(vm, trace);
    return s;
}

// Assembly:
movl %edx, %eax
movq 0x88(%rdi), %r8
movq 0x90(%rdi), %rcx
movq 0x80(%rdi), %rdx
addq %rcx, %rdx
testb %al, %al
je 0x66bf
cmpq %r8, %rdx
je 0x66bc
cmpb %sil, (%rdx)
jne 0x66bf
incq %rdx
jmp 0x66ad
movq %r8, %rdx
movq %rdx, %rax
negq %rax
movq %rdx, %r9
cmpq %r8, %r9
je 0x66ed
movb (%r9), %r10b
cmpb %sil, %r10b
je 0x66f2
cmpb $0xa, %r10b
je 0x66f5
movzbl %r10b, %r11d
cmpl $0xd, %r11d
je 0x66f5
incq %r9
decq %rax
jmp 0x66c8
movq %r8, %rax
jmp 0x6705
movl %esi, %r10d
xorl %r8d, %r8d
cmpb %sil, %r10b
sete %r8b
subq %rax, %r8
negq %rax
subq %rdx, %rax
subq %rcx, %r8
movq %r8, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmGetWord
ficlString ficlVmGetWord(ficlVm *vm)
{
    ficlString s = ficlVmGetWord0(vm);

    if (FICL_STRING_GET_LENGTH(s) == 0)
    {
        ficlVmThrow(vm, FICL_VM_STATUS_RESTART);
    }

    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x6744
movq %rax, %rbx
movq %rdx, %r14
testq %rax, %rax
jne 0x6738
movq %r15, %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x6517
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmGetWord0
ficlString ficlVmGetWord0(ficlVm *vm)
{
    char *trace      = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    ficlString s;
    ficlUnsigned length = 0;
    char c = 0;

    trace = ficlStringSkipSpace(trace, stop);
    FICL_STRING_SET_POINTER(s, trace);


	/* Please leave this loop this way; it makes Purify happier.  --lch */
    for (;;)
    {
		if (trace == stop)
			break;
		c = *trace;
		if (isspace((unsigned char)c))
			break;
        length++;
		trace++;
    }

    FICL_STRING_SET_LENGTH(s, length);

    if ((trace != stop) && isspace((unsigned char)c))    /* skip one trailing delimiter */
        trace++;

    ficlVmUpdateTib(vm, trace);

    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %r14
movq 0x90(%rdi), %rdi
addq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0xaf98
movq %r14, %r12
subq %rax, %r12
xorl %r13d, %r13d
movq %rax, (%rsp)
movq %rax, %rbp
cmpq %r14, %rbp
je 0x67a1
movzbl (%rbp), %r15d
callq 0x3340
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x67a7
incq %rbp
decq %r13
jmp 0x677f
movq (%rsp), %rdx
jmp 0x67ba
movq (%rsp), %rdx
movq %rdx, %r14
subq %r13, %r14
incq %r14
negq %r13
movq %r13, %r12
subq 0x90(%rbx), %r14
movq %r14, 0x80(%rbx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmPushTib
void ficlVmPushTib(ficlVm *vm, char *text, ficlInteger nChars, ficlTIB *pSaveTib)
{
    if (pSaveTib)
    {
        *pSaveTib = vm->tib;
    }

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

// Assembly:
testq %rcx, %rcx
je 0x6885
movq 0x90(%rdi), %rax
movq %rax, 0x10(%rcx)
movups 0x80(%rdi), %xmm0
movups %xmm0, (%rcx)
movq %rsi, 0x90(%rdi)
addq %rsi, %rdx
movq %rdx, 0x88(%rdi)
andq $0x0, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmQuit
void ficlVmQuit(ficlVm *vm)
{
    ficlStackReset(vm->returnStack);
    vm->restart    = 0;
    vm->ip          = NULL;
    vm->runningWord = NULL;
    vm->state       = FICL_VM_STATE_INTERPRET;
    vm->tib.text    = NULL;
    vm->tib.end     = NULL;
    vm->tib.index   = 0;
    vm->pad[0]      = '\0';
    vm->sourceId.i  = 0;
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x417e
andw $0x0, 0x38(%rbx)
movb $0x0, 0x118(%rbx)
andq $0x0, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hoobaa[P]ficl/vm.c
// Function: ficlVmThrowErrorVararg
void ficlVmThrowErrorVararg(ficlVm *vm, char *fmt, va_list list)
{
    vsprintf(vm->pad, fmt, list);
	/* well, we can try anyway, we're certainly not returning to our caller! */
    va_end(list);
	strcat(vm->pad, "\n");
	
    ficlVmErrorOut(vm, vm->pad);
    longjmp(*(vm->exceptionHandler), FICL_VM_STATUS_ERROR_EXIT);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movq %r14, %rdi
callq 0x32a0
movq %r14, %rdi
callq 0x30e0
movw $0xa, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x68f6
movq 0x30(%rbx), %rdi
movl $0xfffffefc, %esi       # imm = 0xFFFFFEFC
callq 0x3280