LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveDeleteFile
static void ficlPrimitiveDeleteFile(ficlVm *vm) /* ( c-addr u -- ior ) */
{
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

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

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

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

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

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

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

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

	free(from);
	free(to);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r14
movslq %r15d, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
xorl %ebp, %ebp
movb %bpl, (%r14,%r15)
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r13
movslq %r15d, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3200
movb %bpl, (%r13,%r15)
movq %r13, %rdi
movq %r14, %rsi
callq 0x32c0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0xd646
movq %r13, %rdi
callq 0x3030
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlFileOpen
static void ficlFileOpen(ficlVm *vm, char *writeMode) /* ( c-addr u fam -- fileid ior ) */
{
    int fam = ficlStackPopInteger(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);
    char mode[4];
    FILE *f;
    char *filename = (char *)malloc(length + 1);
    memcpy(filename, address, length);
    filename[length] = 0;

    *mode = 0;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r13
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %rbp
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r14
movslq %r13d, %r13
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x3200
xorl %eax, %eax
movb %al, (%r14,%r13)
movb %al, 0x4(%rsp)
movl %r15d, %eax
andl $0x7, %eax
cmpl $0x3, %eax
ja 0xd5a6
leaq 0x226a(%rip), %rcx      # 0xf7a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x436a
movq 0x60(%rbx), %rdi
movl $0x16, %esi
callq 0x437b
jmp 0xd62f
leaq 0x4(%rsp), %rdi
movq %r12, %rsi
callq 0x32e0
jmp 0xd5a6
leaq 0x4(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x32e0
movq %r13, %rdi
callq 0x30e0
movw $0x2b, 0x4(%rsp,%rax)
jmp 0xd5a6
leaq 0x4(%rsp), %rdi
callq 0x30e0
movw $0x72, 0x4(%rsp,%rax)
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0x30e0
testb $0x8, %r15b
movl $0x74, %ecx
movl $0x62, %edx
cmovel %ecx, %edx
movw %dx, 0x4(%rsp,%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rax, %r15
testq %rax, %rax
je 0xd613
movl $0x108, %edi            # imm = 0x108
callq 0x3230
movq %rax, %r12
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x3070
movq %r15, (%r12)
movq 0x60(%rbx), %rdi
movq %r12, %rsi
callq 0x436a
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3260
jmp 0xd61e
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x436a
xorl %esi, %esi
testq %r15, %r15
setne %sil
movq %rbx, %rdi
callq 0xd646
movq %r14, %rdi
callq 0x3030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: pushIor
static void pushIor(ficlVm *vm, int success)
{
    int ior;
    if (success)
        ior = 0;
    else
        ior = errno;
    ficlStackPushInteger(vm->dataStack, ior);
}

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

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

    resultLo.low = resultHi.low;

    return resultLo;
}

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

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

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

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

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

// Assembly:
pushq %rbx
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
sarq $0x3f, %rdi
orl $0x1, %edi
movl %edi, %ebx
negl %ebx
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
testq %rsi, %rsi
cmovnsl %edi, %ebx
movq %rax, %rdi
movq %rcx, %rsi
callq 0xd6c7
testl %ebx, %ebx
jg 0xd75b
movq %rax, %rcx
notq %rcx
negq %rax
testq %rdx, %rdx
cmovneq %rcx, %rax
negq %rdx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/double.c
// Function: ficl2UnsignedDivide
ficl2UnsignedQR ficl2UnsignedDivide(ficl2Unsigned q, ficlUnsigned y)
{
    ficl2UnsignedQR result;
    ficl2Unsigned quotient;
    ficl2Unsigned subtrahend;
    ficl2Unsigned mask;

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

// Assembly:
movq %rdi, %rax
movl $0x1, %edi
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpq %rsi, %r8
jbe 0xd806
xorl %r10d, %r10d
jmp 0xd814
setb %r11b
cmpq %rdx, %rcx
setb %r10b
orb %r11b, %r10b
testq %r8, %r8
js 0xd830
testb %r10b, %r10b
je 0xd830
shldq $0x1, %rdi, %r9
addq %rdi, %rdi
shldq $0x1, %rcx, %r8
addq %rcx, %rcx
jmp 0xd7fc
movq %rdi, %r10
orq %r9, %r10
je 0xd886
pushq %rbp
pushq %rbx
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %r8, %rsi
jb 0xd858
ja 0xd84c
cmpq %rcx, %rdx
jb 0xd858
subq %rcx, %rdx
sbbq %r8, %rsi
orq %r9, %r11
orq %rdi, %r10
shrdq $0x1, %r9, %rdi
movq %r9, %rbx
shrdq $0x1, %r8, %rcx
shrq %rbx
shrq %r8
testq %rdi, %rdi
setne %bpl
cmpq $0x2, %r9
setae %r9b
orb %bpl, %r9b
movq %rbx, %r9
jne 0xd840
popq %rbx
popq %rbp
jmp 0xd88c
xorl %r11d, %r11d
xorl %r10d, %r10d
movq %r11, (%rax)
movq %r10, 0x8(%rax)
movq %rdx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/double.c
// Function: ficl2IntegerDivideFloored
ficl2IntegerQR ficl2IntegerDivideFloored(ficl2Integer num, ficlInteger den)
{
    ficl2IntegerQR qr;
    ficl2UnsignedQR uqr;
    int signRem = 1;
    int signQuot = 1;

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

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

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

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

    return qr;
}

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

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

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

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

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

    return qr;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %eax
testq %rsi, %rsi
js 0xd989
movq %r14, %rsi
jmp 0xd9a4
movq %r14, %rax
notq %rax
movq %r14, %rsi
negq %rsi
testq %rdx, %rdx
cmovneq %rax, %rsi
negq %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, %ebp
negl %ebp
testq %rcx, %rcx
cmovnsl %eax, %ebp
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
movq %rbx, %rdi
movq %rax, %rcx
callq 0xd7ee
testq %r14, %r14
jns 0xd9cc
negq 0x10(%rbx)
testl %ebp, %ebp
jns 0xd9f1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, %rdx
notq %rdx
negq %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
negq %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSearchPush
static void ficlPrimitiveSearchPush(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
cmpl $0x0, 0xa8(%rax)
jne 0xdc0d
leaq 0x1d54(%rip), %rsi      # 0xf957
movq %r14, %rdi
xorl %eax, %eax
callq 0x6879
movq 0x60(%r14), %rdi
movslq 0xa8(%rbx), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xa8(%rbx)
movq 0x20(%rbx,%rax,8), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x436a
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveDefinitions
static void ficlPrimitiveDefinitions(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
cmpl $0x0, 0xa8(%rax)
jg 0xdc5c
leaq 0x1d27(%rip), %rsi      # 0xf979
movq %r14, %rdi
xorl %eax, %eax
callq 0x6879
movslq 0xa8(%rbx), %rax
movq 0x20(%rbx,%rax,8), %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveGetOrder
static void ficlPrimitiveGetOrder(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    int wordlistCount = dictionary->wordlistCount;
    int i;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x699a
movslq 0xa8(%rax), %r14
testq %r14, %r14
jle 0xdcda
movq %rax, %r15
xorl %r12d, %r12d
movq 0x60(%rbx), %rdi
movq 0x28(%r15,%r12,8), %rsi
callq 0x436a
incq %r12
cmpq %r12, %r14
jne 0xdcc4
movq 0x60(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x438c
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSearchWordlist
static void ficlPrimitiveSearchWordlist(ficlVm *vm)
{
    ficlString name;
    ficlUnsigned16 hashCode;
    ficlWord *word;
    ficlHash *hash = ficlStackPopPointer(vm->dataStack);

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

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

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

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4301
movzbl %al, %r15d
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xb8a9
movzwl %ax, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb929
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xdd7c
movq %rax, %r14
movq %rax, %rsi
callq 0x436a
movq 0x60(%rbx), %rbx
movq %r14, %rdi
callq 0xba94
xorl %esi, %esi
cmpl $0x1, %eax
sbbq %rsi, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x437b
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x438c
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveSetOrder
static void ficlPrimitiveSetOrder(ficlVm *vm)
{
    int i;
    int wordlistCount = ficlStackPopInteger(vm->dataStack);
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

    ficlDictionaryLock(dictionary, FICL_TRUE);

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

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq %rbx, %rdi
callq 0x699a
movq %rax, %r15
cmpl $0x11, %r14d
jl 0xddee
leaq 0x1bbc(%rip), %rsi      # 0xf9a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6879
testl %r14d, %r14d
js 0xde2a
movl %r14d, 0xa8(%r15)
je 0xde1e
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
leaq -0x1(%r14), %r12
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, 0x20(%r15,%r14,8)
cmpq $0x1, %r14
movq %r12, %r14
jg 0xde03
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc746
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/search.c
// Function: ficlPrimitiveFiclWordlist
static void ficlPrimitiveFiclWordlist(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash;
    ficlUnsigned nBuckets;
    
    FICL_STACK_CHECK(vm->dataStack, 1, 1);

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

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

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

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

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

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

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

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

	return 0;
}

// Assembly:
pushq %rax
movq 0x2e3c(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x1040
testl %eax, %eax
jne 0x1235
movl $0x48, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x45, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4c, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4c, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0x4f, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
movl $0xa, %edi
callq 0x1030
movl $0x1, %edi
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/tests/stop_wait.c
// Function: main
int main() {
  libforks_ServerConn conn;

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

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

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

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

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

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

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

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4de2(%rip), %rdi      # 0x611c
callq 0x1100
testl %eax, %eax
jne 0x1440
movl 0x4dcf(%rip), %edi      # 0x611c
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
xorl %eax, %eax
callq 0x1080
cmpl $-0x1, %eax
je 0x1451
leaq 0x10(%rsp), %rdi
callq 0x18eb
testl %eax, %eax
jne 0x1462
movl 0x4da1(%rip), %edi      # 0x6120
callq 0x10e0
testl %eax, %eax
jne 0x1473
movq 0x10(%rsp), %rdi
leaq 0x15b(%rip), %r8        # 0x14f3
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x233f
testl %eax, %eax
jne 0x1484
movl 0x4d6b(%rip), %edi      # 0x611c
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x1110
cmpq $-0x1, %rax
jne 0x1495
callq 0x1050
cmpl $0xb, (%rax)
jne 0x14a6
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x24fa
testl %eax, %eax
jne 0x14b7
leaq 0xf(%rsp), %r14
movl 0x4d24(%rip), %edi      # 0x611c
movl $0x1, %edx
movq %r14, %rsi
callq 0x1110
cmpl $-0x1, %eax
jne 0x1420
cmpl $0xb, (%rbx)
je 0x13f2
leaq 0x1ce1(%rip), %rdi      # 0x30f7
movl $0x34, %esi
callq 0x14c8
cmpl $0x1, %eax
jne 0x142f
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1cf4(%rip), %rdi      # 0x312a
movl $0x36, %esi
callq 0x14c8
leaq 0x1bbd(%rip), %rdi      # 0x3004
movl $0x1a, %esi
callq 0x14c8
leaq 0x1bd2(%rip), %rdi      # 0x302a
movl $0x1b, %esi
callq 0x14c8
leaq 0x1bef(%rip), %rdi      # 0x3058
movl $0x1d, %esi
callq 0x14c8
leaq 0x1c03(%rip), %rdi      # 0x307d
movl $0x1f, %esi
callq 0x14c8
leaq 0x1c0a(%rip), %rdi      # 0x3095
movl $0x27, %esi
callq 0x14c8
leaq 0x1c3c(%rip), %rdi      # 0x30d8
movl $0x2c, %esi
callq 0x14c8
leaq 0x1c4a(%rip), %rdi      # 0x30f7
movl $0x2d, %esi
callq 0x14c8
leaq 0x1c49(%rip), %rdi      # 0x3107
movl $0x2f, %esi
callq 0x14c8
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/tests/stop_wait.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;
  (void)socket_fd;

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

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

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

// Assembly:
subq $0x18, %rsp
movl $0x1, %esi
movl $0xf, %edi
callq 0x1120
cmpq $-0x1, %rax
je 0x1546
movups 0x1c9d(%rip), %xmm0     # 0x31b0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x10c0
testl %eax, %eax
jne 0x1557
movl 0x4bf6(%rip), %edi      # 0x6120
leaq 0x1c5a(%rip), %rsi      # 0x318b
movl $0x1, %edx
callq 0x1090
cmpq $0x1, %rax
jne 0x1568
addq $0x18, %rsp
retq
leaq 0x1c00(%rip), %rdi      # 0x314d
movl $0xb, %esi
callq 0x14c8
leaq 0x1c13(%rip), %rdi      # 0x3171
movl $0x12, %esi
callq 0x14c8
leaq 0x1c1e(%rip), %rdi      # 0x318d
movl $0x14, %esi
callq 0x14c8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/test/test_queue.c
// Function: main
int main(void)
{

	QUEUE_s *pQ = QUEUE_create(sizeof(int),16);
	for (int i = 0;i < DIM_OF(arr);i++) {
		QUEUE_enqueue(pQ,&arr[i]);
	}

	int val;
	while(QUEUE_dequeue(pQ,&val) != QUEUE_EMPTY) {
		printf("val:%d\n",val);
	}

	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x4, %edi
movl $0x10, %esi
callq 0x11f0
movq %rax, %rbx
xorl %r14d, %r14d
leaq 0x2ebf(%rip), %r15      # 0x4050
leaq (%r15,%r14), %rsi
movq %rbx, %rdi
callq 0x12f5
addq $0x4, %r14
cmpq $0x18, %r14
jne 0x1191
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x1367
cmpl $-0x2, %eax
je 0x11e3
leaq 0xe44(%rip), %r14       # 0x2004
leaq 0xc(%rsp), %r15
movl 0xc(%rsp), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1367
cmpl $-0x2, %eax
jne 0x11c5
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_create
QUEUE_s *QUEUE_create(int itemSize,int nMax)
{
	QUEUE_s *pQ = (QUEUE_s *)malloc(sizeof(QUEUE_s));
	CHECK_EXPR_RET(pQ == NULL,NULL);

	pQ->data = (void *)malloc(itemSize * nMax);
	CHECK_EXPR_RET(pQ->data == NULL,NULL);
	pQ->itemSize = itemSize;
	pQ->nMax = nMax;
	pQ->head = 0;
	pQ->tail = 0;
	return pQ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0x1050
testq %rax, %rax
je 0x1232
movq %rax, %rbx
movl %ebp, %eax
imull %r14d, %eax
movslq %eax, %rdi
callq 0x1050
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1250
movl %r14d, 0x14(%rbx)
movl %ebp, 0x10(%rbx)
movq $0x0, (%rbx)
jmp 0x1273
leaq 0xdd3(%rip), %rdi       # 0x200c
leaq 0xde2(%rip), %rsi       # 0x2022
leaq 0xde3(%rip), %rdx       # 0x202a
xorl %ebx, %ebx
movl $0x9, %ecx
jmp 0x126c
leaq 0xdb5(%rip), %rdi       # 0x200c
leaq 0xdc4(%rip), %rsi       # 0x2022
leaq 0xdc5(%rip), %rdx       # 0x202a
xorl %ebx, %ebx
movl $0xc, %ecx
xorl %eax, %eax
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_empty
BOOL QUEUE_empty(QUEUE_s *pQ)
{
	CHECK_EXPR_RET(pQ == NULL,TRUE);

	if (pQ->head == pQ->tail ) {
		return TRUE;
	}

	return FALSE;
}

// Assembly:
testq %rdi, %rdi
je 0x1289
movl (%rdi), %eax
cmpl 0x4(%rdi), %eax
sete %al
retq
pushq %rax
leaq 0xd7b(%rip), %rdi       # 0x200c
leaq 0xd8a(%rip), %rsi       # 0x2022
leaq 0xd98(%rip), %rdx       # 0x2037
movl $0x17, %ecx
xorl %eax, %eax
callq 0x1030
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_lastItem
int QUEUE_lastItem(QUEUE_s *pQ,void *item)
{
	int last = pQ->tail % pQ->nMax;
	last--;
	if (last < 0) {
		last = pQ->nMax - last;
	}
	memcpy(item,(char *)pQ->data + last*pQ->itemSize,pQ->itemSize);
	return 0;
}

// Assembly:
pushq %rax
movq %rsi, %rcx
movl 0x4(%rdi), %eax
movl 0x10(%rdi), %esi
cltd
idivl %esi
leal -0x1(%rdx), %eax
subl %eax, %esi
testl %edx, %edx
cmovgl %eax, %esi
movslq 0x14(%rdi), %rdx
movslq %esi, %rsi
imulq %rdx, %rsi
addq 0x8(%rdi), %rsi
movq %rcx, %rdi
callq 0x1040
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_enqueue
int QUEUE_enqueue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_full(pQ) == TRUE) {
		printf("Queue is full!\n");
		return QUEUE_FULL;
	}
	
	memcpy((char *)pQ->data + pQ->tail*pQ->itemSize,item,pQ->itemSize);
	pQ->tail++;
	pQ->tail %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x133f
movq %rdi, %rbx
movslq 0x4(%rdi), %rdi
cmpl %edi, (%rbx)
jne 0x131e
cmpl 0x10(%rbx), %edi
jne 0x131e
leaq 0xd4d(%rip), %rdi       # 0x205f
callq 0x1060
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x1365
movslq 0x14(%rbx), %rdx
imulq %rdx, %rdi
addq 0x8(%rbx), %rdi
callq 0x1040
movl 0x4(%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, 0x4(%rbx)
xorl %eax, %eax
jmp 0x1365
leaq 0xcc6(%rip), %rdi       # 0x200c
leaq 0xcd5(%rip), %rsi       # 0x2022
leaq 0xcef(%rip), %rdx       # 0x2043
movl $0x36, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/queue.c
// Function: QUEUE_dequeue
int QUEUE_dequeue(QUEUE_s *pQ,void *item)
{
	CHECK_EXPR_RET(pQ == NULL,-1);

	if (QUEUE_empty(pQ) == TRUE) {
		return QUEUE_EMPTY;
	}

	memcpy(item,(char *)pQ->data + pQ->head*pQ->itemSize,pQ->itemSize);
	pQ->head++;
	pQ->head %= pQ->nMax;
	
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x13a4
movq %rdi, %rbx
movl (%rdi), %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl 0x4(%rdi), %ecx
je 0x13ca
movslq (%rbx), %rax
movslq 0x14(%rbx), %rdx
imulq %rdx, %rax
addq 0x8(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1040
movl (%rbx), %eax
incl %eax
cltd
idivl 0x10(%rbx)
movl %edx, (%rbx)
xorl %eax, %eax
jmp 0x13ca
leaq 0xc61(%rip), %rdi       # 0x200c
leaq 0xc70(%rip), %rsi       # 0x2022
leaq 0xc98(%rip), %rdx       # 0x2051
movl $0x46, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/lauxlib.c
// Function: panic
static int panic (lua_State *L) {
  (void)L;  /* to avoid warnings */
  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",
                   lua_tostring(L, -1));
  return 0;
}

// Assembly:
pushq %rbx
movq 0x138314(%rip), %rax    # 0x150fc0
movq (%rax), %rbx
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x58042
leaq 0xd575f(%rip), %rsi     # 0xee41f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8d0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/lua-5.1.5/src/ldblib.c
// Function: db_debug
static int db_debug (lua_State *L) {
  for (;;) {
    char buffer[250];
    fputs("lua_debug> ", stderr);
    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
        strcmp(buffer, "cont\n") == 0)
      return 0;
    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
        lua_pcall(L, 0, 0, 0)) {
      fputs(lua_tostring(L, -1), stderr);
      fputs("\n", stderr);
    }
    lua_settop(L, 0);  /* remove eventual returns */
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq 0x1382d4(%rip), %rbp    # 0x150fc0
movq (%rbp), %rsi
leaq 0xd5afa(%rip), %rdi     # 0xee7f1
callq 0xb730
movq 0x13828d(%rip), %r15    # 0x150f90
movq (%r15), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0xfa, %esi
callq 0xb9f0
testq %rax, %rax
je 0x18e12
pushq $0x6
popq %r12
movq %rsp, %r13
movq %r14, %rdi
leaq 0xd5acb(%rip), %rsi     # 0xee7fd
movq %r12, %rdx
callq 0xb6b0
testl %eax, %eax
je 0x18e12
movq %r14, %rdi
callq 0xb260
movq %r14, (%rsp)
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x43235(%rip), %rsi     # 0x5bf92
movq %r13, %rdx
leaq 0xd5a9c(%rip), %rcx     # 0xee803
callq 0x59744
testl %eax, %eax
jne 0x18d9e
movq 0x10(%rbx), %rcx
addq $-0x10, %rcx
movq %rcx, (%rsp)
andl $0x0, 0x8(%rsp)
subq 0x40(%rbx), %rcx
movq %rbx, %rdi
leaq 0x408c9(%rip), %rsi     # 0x59658
movq %r13, %rdx
xorl %r8d, %r8d
callq 0x595aa
testl %eax, %eax
je 0x18dc7
movq %rbx, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x58042
movq (%rbp), %rsi
movq %rax, %rdi
callq 0xb730
movq (%rbp), %rsi
leaq 0xdeae7(%rip), %rdi     # 0xf78a9
callq 0xb730
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
cmpq %rax, %rcx
jae 0x18de5
andl $0x0, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jb 0x18dd4
movq %rcx, 0x10(%rbx)
movq %rax, 0x10(%rbx)
movq (%rbp), %rsi
leaq 0xd59fd(%rip), %rdi     # 0xee7f1
callq 0xb730
movq (%r15), %rdx
movq %r14, %rdi
movl $0xfa, %esi
callq 0xb9f0
testq %rax, %rax
jne 0x18d28
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/init.c
// Function: gt_lib_clean
int gt_lib_clean(void)
{
  int fa_fptr_rval, fa_mmap_rval, gt_rval;
  if (spacepeak) {
    gt_ma_show_space_peak(stdout);
    gt_fa_show_space_peak(stdout);
    gt_spacepeak_show_space_peak(stdout);
    gt_ma_disable_global_spacepeak();
  }
  fa_fptr_rval = gt_fa_check_fptr_leak();
  fa_mmap_rval = gt_fa_check_mmap_leak();
  gt_fa_clean();
  gt_symbol_clean();
  gt_class_alloc_clean();
  gt_class_alloc_lock_clean();
  gt_ya_rand_clean();
  gt_log_clean();
  gt_spacepeak_clean();
  gt_combinatorics_clean();
  gt_rval = gt_ma_check_space_leak();
  gt_ma_clean();
#ifdef HAVE_MYSQL
  mysql_library_end();
#endif
  return fa_fptr_rval || fa_mmap_rval || gt_rval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x11d063(%rip)    # 0x1529e1
jne 0x359a4
movq 0x11b5d1(%rip), %rbx    # 0x150f58
movq (%rbx), %rdi
callq 0x363d2
movq (%rbx), %rdi
callq 0x74ea5
movq (%rbx), %rdi
callq 0x3a727
callq 0x3638d
callq 0x74d8e
movl %eax, %ebx
callq 0x74df7
movl %eax, %ebp
callq 0x74eed
callq 0x3d71b
callq 0x71d05
callq 0x71d8f
callq 0x3deea
callq 0x35af4
callq 0x3a76f
callq 0x71f2c
callq 0x3641e
movl %eax, %r14d
callq 0x3658f
orl %ebx, %ebp
xorl %eax, %eax
orl %r14d, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_new
GtLogger* gt_logger_new(bool enabled, const char *prefix, FILE *target)
{
  GtLogger *l;
  gt_assert(target);
  l = (GtLogger*) gt_calloc((size_t) 1, sizeof (GtLogger));
  l->target = target;
  l->prefix = gt_cstr_dup(prefix);
  l->enabled = enabled;
  return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x35b57
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebx
leaq 0xab879(%rip), %rdx     # 0xe1395
movl $0x1, %edi
movl $0x18, %esi
movl $0x24, %ecx
callq 0x3601f
movq %rax, %r12
movq %r15, (%rax)
movq %r14, %rdi
callq 0x722dc
movq %rax, 0x8(%r12)
movb %bl, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xbea1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_force
void gt_logger_log_force(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va_force(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x35c04
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x35c38
testq %rsi, %rsi
je 0x35c40
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x35c45
addq $0xd8, %rsp
retq
callq 0xbfeb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va_force
void gt_logger_log_va_force(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x35c93
movq %rsi, %r15
testq %rsi, %rsi
je 0x35c99
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x35c99
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x35c73
callq 0xb730
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb820
movq (%rbx), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xbc90
popq %rbx
popq %r14
popq %r15
retq
callq 0xc022
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log
void gt_logger_log(GtLogger *logger, const char *format, ...)
{
  va_list ap;
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format);
  va_start(ap, format);
  gt_logger_log_va(logger, format, ap);
  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x35cf4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x35d2e
cmpb $0x1, 0x10(%rdi)
jne 0x35d2e
testq %rsi, %rsi
je 0x35d36
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x35d3b
addq $0xd8, %rsp
retq
callq 0xc059
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/logger.c
// Function: gt_logger_log_va
void gt_logger_log_va(GtLogger *logger, const char *format, va_list ap)
{
  if (!logger) return;
  if (!logger->enabled) return;
  gt_assert(format && logger->target);
  if (logger->prefix != NULL)
    fprintf(logger->target, "%s", logger->prefix);
  (void) vfprintf(logger->target, format, ap);
  (void) putc('\n', logger->target);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x35d8f
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x35d8f
movq %rsi, %r15
testq %rsi, %rsi
je 0x35d95
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x35d95
movq %rdx, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x35d6f
callq 0xb730
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xb820
movq (%rbx), %rsi
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xbc90
popq %rbx
popq %r14
popq %r15
retq
callq 0xc090
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/ma.c
// Function: gt_ma_init
void gt_ma_init(bool bookkeeping)
{
  gt_assert(!ma);
  ma = xcalloc(1, sizeof (MA), 0, __FILE__, __LINE__);
  gt_assert(!ma->bookkeeping);
  ma->allocated_pointer = gt_hashmap_new_no_ma(GT_HASH_DIRECT, NULL,
                                               (GtFree) ma_info_free);
  /* MA is ready to use */
  ma->bookkeeping = bookkeeping;
  bookkeeping_lock = gt_mutex_new();
  ma->global_space_peak = false;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x11cc0f(%rip)    # 0x1529f0
jne 0x35e46
movl %edi, %ebx
leaq 0xab6cb(%rip), %rcx     # 0xe14b7
movl $0x1, %edi
movl $0x28, %esi
xorl %edx, %edx
movl $0x6b, %r8d
callq 0x35e50
movq %rax, 0x11cbe6(%rip)    # 0x1529f0
cmpb $0x1, 0x8(%rax)
je 0x35e4b
leaq 0xc6(%rip), %rdx        # 0x35edd
xorl %edi, %edi
xorl %esi, %esi
callq 0x7703c
movq 0x11cbc9(%rip), %rcx    # 0x1529f0
movq %rax, (%rcx)
movb %bl, 0x8(%rcx)
callq 0x3d96a
movq %rax, 0x11cbbf(%rip)    # 0x1529f8
movq 0x11cbb0(%rip), %rax    # 0x1529f0
movb $0x0, 0x9(%rax)
popq %rbx
retq
callq 0xc0c7
callq 0xc0fe
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/ma.c
// Function: xcalloc
static void* xcalloc(size_t nmemb, size_t size, GtUword current_size,
                     const char *src_file, int src_line)
{
  void *p;
  if ((p = calloc(nmemb, size)) == NULL) {
    fprintf(stderr, "cannot calloc("GT_ZU", "GT_ZU") memory\n", nmemb, size);
    fprintf(stderr, "attempted on line %d in file \"%s\"\n", src_line,
           src_file);
    if (current_size)
      fprintf(stderr, GT_WU " bytes were allocated altogether\n", current_size);
    exit(EXIT_FAILURE);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0xb410
testq %rax, %rax
je 0x35e83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11b136(%rip), %r13    # 0x150fc0
movq (%r13), %rdi
leaq 0xab7f2(%rip), %rsi     # 0xe1687
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb8d0
movq (%r13), %rdi
leaq 0xab67a(%rip), %rsi     # 0xe1527
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8d0
testq %rbx, %rbx
je 0x35ed3
movq (%r13), %rdi
leaq 0xab7de(%rip), %rsi     # 0xe16a7
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8d0
movl $0x1, %edi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/ma.c
// Function: gt_malloc_mem
void* gt_malloc_mem(size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xmalloc(size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xmalloc(size, ma->current_size, src_file, src_line);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x11cb00(%rip), %rax    # 0x1529f0
testq %rax, %rax
je 0x35fb3
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rax)
jne 0x35f9b
movq 0x11cae6(%rip), %rdi    # 0x1529f8
callq 0x3d9b7
movq 0x11cad2(%rip), %rax    # 0x1529f0
incq 0x10(%rax)
movq 0x18(%rax), %rsi
movl $0x18, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35fb8
movq %rax, %r15
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x11caa7(%rip), %rax    # 0x1529f0
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x35fb8
movq %rax, %r14
movq 0x11ca8c(%rip), %rax    # 0x1529f0
movq (%rax), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x77144
movq 0x11ca77(%rip), %rdi    # 0x1529f0
movq %rbx, %rsi
callq 0x35fef
movq 0x11ca70(%rip), %rdi    # 0x1529f8
callq 0x3d9d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35fb8
callq 0xc135
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/ma.c
// Function: add_size
static void add_size(MA* ma, GtUword size)
{
  gt_assert(ma);
  ma->current_size += size;
  if (ma->global_space_peak)
    gt_spacepeak_add(size);
  if (ma->current_size > ma->max_size)
    ma->max_size = ma->current_size;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3601a
movq %rdi, %rbx
addq %rsi, 0x18(%rdi)
cmpb $0x1, 0x9(%rdi)
jne 0x3600a
movq %rsi, %rdi
callq 0x3a69a
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jbe 0x36018
movq %rax, 0x20(%rbx)
popq %rbx
retq
callq 0xc1cf