LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: addCodeRef
ccInt addCodeRef(linkedlist *destCodeLL, searchPath *newAnchor, ccInt *codePtr, ccInt codeID)
{
    code_ref *newCodeRef;
    ccInt rtrn;
    
    rtrn = addElements(destCodeLL, 1, ccFalse);
    if (rtrn != passed)  return out_of_memory_err;
    
    newCodeRef = (code_ref *) element(destCodeLL, destCodeLL->elementNum);
    newCodeRef->PLL_index = codeID;
    newCodeRef->references = (ccInt *) element(&(MasterCodeList.references), codeID);
    newCodeRef->code_ptr = codePtr;
    newCodeRef->anchor = newAnchor;
    
    refCodeRef(newCodeRef);
    
    return passed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %r12
movl %r12d, %esi
xorl %edx, %edx
callq 0x8b0f
testl %eax, %eax
jne 0xefbc
movl (%r15), %esi
movq %r15, %rdi
callq 0x9088
movq %rax, %r15
movl %ebp, (%rax)
leaq 0x1572a(%rip), %rdi     # 0x246c8
movl %ebp, %esi
callq 0x9088
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rdi
callq 0xe54f
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: adjustOffsetAndIW
void adjustOffsetAndIW(ccBool sameWindow, ccInt *offset, ccInt *indexWidth, ccInt insertionOffset, ccInt newIndices)
{
    if ((sameWindow) && (insertionOffset >= *offset))  { 
        *indexWidth += newIndices;
        if (*indexWidth < insertionOffset - (*offset))  {       // can happen if newIndices < 0 
            *indexWidth = insertionOffset - (*offset);
    }   }
    
    else if (insertionOffset <= *offset) {
        *offset += newIndices;
        if (insertionOffset > *offset)  {                       // possible only if newIndices < 0
            *indexWidth -= insertionOffset - (*offset);
            if (*indexWidth < 0)  *indexWidth = 0;
            *offset = insertionOffset;
    }   }
}

// Assembly:
testb %dil, %dil
sete %dil
movl (%rsi), %eax
cmpl %ecx, %eax
setg %r9b
orb %dil, %r9b
je 0xf13a
cmpl %ecx, %eax
jl 0xf139
addl %r8d, %eax
movl %eax, (%rsi)
subl %ecx, %eax
jge 0xf139
addl (%rdx), %eax
xorl %edi, %edi
testl %eax, %eax
cmovgl %eax, %edi
movl %edi, (%rdx)
movl %ecx, (%rsi)
retq
addl (%rdx), %r8d
movl %r8d, (%rdx)
subl (%rsi), %ecx
cmpl %ecx, %r8d
cmovgl %r8d, %ecx
movl %ecx, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: unflagWindow
void unflagWindow(window *theWindow, unsigned char theFlag)
{
    variable *theVariable = theWindow->variable_ptr;
    ccInt counter;
    
    if (!isBusy(theWindow, theFlag))  return;
    clearBusy(theWindow, theFlag);
    
    if (theVariable->type >= composite_type)  {
    for (counter = 1; counter <= theVariable->mem.members.elementNum; counter++)  {
        
        member *loopMember = LL_member(theVariable, counter);
        if (loopMember->memberWindow != NULL)  {
        if ((loopMember->memberWindow->jamStatus == can_jam) && (isBusy(loopMember, busy_overlap_flag)))  {
            clearBusy(loopMember, busy_overlap_flag);
            unflagWindow(loopMember->memberWindow, theFlag);
    }}  }}
    
    return;
}

// Assembly:
movl 0x24(%rdi), %eax
testl %esi, %eax
je 0xf1b2
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rbx
movl %esi, %ecx
notl %ecx
andl %ecx, %eax
movl %eax, 0x24(%rdi)
cmpl $0x5, 0xc0(%rbx)
jl 0xf1ae
addq $0x10, %rbx
pushq $0x1
popq %rbp
movzbl %sil, %r14d
cmpl (%rbx), %ebp
jg 0xf1ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9088
movq (%rax), %rdi
testq %rdi, %rdi
je 0xf1aa
cmpb $0x1, 0x20(%rdi)
jne 0xf1aa
movl 0x44(%rax), %ecx
testb $0x20, %cl
je 0xf1aa
andl $-0x21, %ecx
movl %ecx, 0x44(%rax)
movl %r14d, %esi
callq 0xf14c
incl %ebp
jmp 0xf178
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: jump_if_true
void _jump_if_true()
{
    ccInt *jumpPC = pcCodePtr + *pcCodePtr;
    
    pcCodePtr++;
    callLogicalFunction();
    if (boolRegister)  pcCodePtr = jumpPC;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x15643(%rip), %rbx     # 0x24818
movslq (%rbx), %r14
leaq 0x4(%rbx), %rax
movq %rax, 0x15635(%rip)     # 0x24818
callq 0xf204
cmpb $0x0, 0x155d9(%rip)     # 0x247c8
je 0xf1fc
leaq (%rbx,%r14,4), %rax
movq %rax, 0x1561c(%rip)     # 0x24818
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: callLogicalFunction
void callLogicalFunction()  {
    
    callFunction(bytecodeJumpTable);
    if (errCode != passed)  return;
    
    if (GL_Object.type == var_type)  {
        if (searchView.windowPtr == NULL)  {  setError(void_member_err, pcCodePtr-1);  return;  }
        if (searchView.width != 1)  {  setError(multiple_indices_not_allowed_err, pcCodePtr-1);  return;  }
        if (searchView.windowPtr->variable_ptr->type != bool_type)  {  setError(type_mismatch_err, pcCodePtr-1);  return;  }
        loadBoolRegister(searchView.windowPtr->variable_ptr, searchView.offset);
        GL_Object.type = bool_type;      }
    
    else if (GL_Object.type != bool_type)  {  setError(type_mismatch_err, pcCodePtr-1);  return;  }
}

// Assembly:
pushq %rax
movq 0x1560c(%rip), %rax     # 0x24818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x155fe(%rip)     # 0x24818
leaq 0x1433f(%rip), %rax     # 0x23560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x1554d(%rip)     # 0x24778
je 0xf22f
popq %rax
retq
movl 0x15603(%rip), %eax     # 0x24838
testl %eax, %eax
je 0xf22d
cmpl $-0x1, %eax
jne 0xf260
movq 0x15673(%rip), %rax     # 0x248b8
testq %rax, %rax
je 0xf26f
cmpl $0x1, 0x15673(%rip)     # 0x248c4
jne 0xf27e
movq 0x10(%rax), %rdi
cmpl $0x0, 0xc0(%rdi)
je 0xf292
movq 0x155b1(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x11
jmp 0xf28b
movq 0x155a2(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1a
jmp 0xf28b
movq 0x15593(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1f
popq %rdi
popq %rax
jmp 0xc7c2
movl 0x15628(%rip), %esi     # 0x248c0
callq 0x144d8
andl $0x0, 0x15594(%rip)     # 0x24838
jmp 0xf22d
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: jump_if_false
void _jump_if_false()
{
    ccInt *jumpPC = pcCodePtr + *pcCodePtr;
    
    pcCodePtr++;
    callLogicalFunction();
    if (!boolRegister)  pcCodePtr = jumpPC;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x15567(%rip), %rbx     # 0x24818
movslq (%rbx), %r14
leaq 0x4(%rbx), %rax
movq %rax, 0x15559(%rip)     # 0x24818
callq 0xf204
cmpb $0x0, 0x154fd(%rip)     # 0x247c8
jne 0xf2d8
leaq (%rbx,%r14,4), %rax
movq %rax, 0x15540(%rip)     # 0x24818
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: func_return
void _func_return()
{
    callCodeFunction();         // this allows a step to a void return variable; callBytecodeFunction() wouldn't 
    if (errCode != passed)  return;
    
    returnView = searchView;
    if (GL_Object.type != var_type)  returnView.windowPtr = NULL;
      
    errCode = return_flag;      // not a real error -- just to get runBytecode/Constructor to stop
}

// Assembly:
pushq %rax
callq 0xf33b
cmpl $0x0, 0x15478(%rip)     # 0x24778
jne 0xf339
movq 0x155bf(%rip), %rax     # 0x248c8
movq %rax, 0x15608(%rip)     # 0x24918
movups 0x155a1(%rip), %xmm0    # 0x248b8
movups %xmm0, 0x155ea(%rip)    # 0x24908
cmpl $-0x1, 0x15513(%rip)    # 0x24838
je 0xf32f
andq $0x0, 0x155d9(%rip)     # 0x24908
movl $0x32, 0x1543f(%rip)    # 0x24778
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: callCodeFunction
void callCodeFunction()
{
    ccInt *commandPtr = pcCodePtr;
    
    callFunction(codeJumpTable);
    
    if ((*commandPtr != type_array) && (*commandPtr != define_equate))  {
        resizeLinkedList(&(GL_Object.arrayDimList), 0, ccFalse);        }
}

// Assembly:
pushq %rbx
movq 0x154d5(%rip), %rbx     # 0x24818
movslq (%rbx), %rax
leaq 0x4(%rbx), %rcx
movq %rcx, 0x154c7(%rip)     # 0x24818
leaq 0x14778(%rip), %rcx     # 0x23ad0
callq *(%rcx,%rax,8)
movl (%rbx), %eax
cmpl $0x8, %eax
je 0xf367
cmpl $0x2e, %eax
jne 0xf369
popq %rbx
retq
leaq 0x154d0(%rip), %rdi     # 0x24840
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
jmp 0x8b23
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: built_in_function
void _built_in_function()
{
    view holdBIFArgsView;
    void(*theBuiltInFunction)(void);
    ccInt biFunctionID;
    
    
        // read in the function ID
    
    callNumericFunction(int_type);
    if (errCode != passed)  return;
    
    if ((intRegister < 0) || (intRegister >= bi_commands_num))  {
        setError(nonexistent_built_in_function_err, pcCodePtr);
        return;         }
    
    biFunctionID = intRegister;
    theBuiltInFunction = BuiltInFunctionJumpTable[biFunctionID];
    
    
        // get the argument variable
    
    callBytecodeFunction();
    if (errCode != passed)  return;
    
    holdBIFArgsView = BIF_argsView;
    BIF_argsView = searchView;
    
    
        // run the function and set the return variable
    
    returnView.windowPtr = NULL;
    theBuiltInFunction();
    
    GL_Object.type = BIF_Types[biFunctionID];
    GL_Path.stemMember = NULL;
    
    
        // restore the old args variable
    
    BIF_argsView = holdBIFArgsView;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
pushq $0x2
popq %rdi
callq 0xfb69
cmpl $0x0, 0x14cf3(%rip)     # 0x24778
je 0xfa8f
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movslq 0x14d36(%rip), %rbx     # 0x247cc
testq %rbx, %rbx
js 0xfb53
leaq 0x145ea(%rip), %rax     # 0x24090
cmpl (%rax), %ebx
jge 0xfb53
leaq 0x144eb(%rip), %rax     # 0x23fa0
movq (%rax,%rbx,8), %r14
movq 0x14d58(%rip), %rax     # 0x24818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x14d4a(%rip)     # 0x24818
leaq 0x13a8b(%rip), %rax     # 0x23560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x14c99(%rip)     # 0x24778
jne 0xfa87
movq 0x14e00(%rip), %rax     # 0x248e8
movq %rax, 0x10(%rsp)
movups 0x14de4(%rip), %xmm0    # 0x248d8
movaps %xmm0, (%rsp)
movups 0x14db9(%rip), %xmm0    # 0x248b8
movups %xmm0, 0x14dd2(%rip)    # 0x248d8
movq 0x14dbb(%rip), %rax     # 0x248c8
movq %rax, 0x14dd4(%rip)     # 0x248e8
andq $0x0, 0x14dec(%rip)     # 0x24908
callq *%r14
leaq 0x1437a(%rip), %rax     # 0x23ea0
movl (%rax,%rbx,4), %eax
movl %eax, 0x14d09(%rip)     # 0x24838
andq $0x0, 0x14d31(%rip)     # 0x24868
movaps (%rsp), %xmm0
movups %xmm0, 0x14d96(%rip)    # 0x248d8
movq 0x10(%rsp), %rax
movq %rax, 0x14d9a(%rip)     # 0x248e8
jmp 0xfa87
movq 0x14cbe(%rip), %rsi     # 0x24818
pushq $0x2b
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0xc7c2
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: copyCompareReadArg
void copyCompareReadArg(void(*runBytecodeFunction)(void), ccInt *dataType, ccBool *argIsScalar)
{
    runBytecodeFunction();
    if (errCode != passed)  return;
    
    *dataType = GL_Object.type;
    *argIsScalar = ((*dataType != var_type) && (*dataType != no_type));
    
    if (*dataType == var_type)  {
        if (searchView.windowPtr == NULL)  *dataType = no_type;
        else if ((searchView.windowPtr->variable_ptr->type >= bool_type) && (searchView.windowPtr->variable_ptr->type <= string_type))  {
            *dataType = searchView.windowPtr->variable_ptr->type;
            if ((!searchView.multipleIndices) && (searchView.width == 1))  {        // 2nd condition in case baseView.width /= 1
                *argIsScalar = ccTrue;
                loadRegister(searchView.windowPtr->variable_ptr, searchView.offset);
    }   }   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq *%rdi
cmpl $0x0, 0x1391d(%rip)     # 0x24778
jne 0x10e76
movl 0x139d5(%rip), %eax     # 0x24838
movl %eax, (%r14)
incl %eax
testl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
setne (%rbx)
cmpl $-0x1, (%r14)
je 0x10e7e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13a33(%rip), %rax     # 0x248b8
testq %rax, %rax
je 0x10edd
movq 0x10(%rax), %rax
movl 0xc0(%rax), %eax
cmpl $0x4, %eax
ja 0x10e76
movl %eax, (%r14)
cmpb $0x0, 0x13a25(%rip)     # 0x248c8
jne 0x10e76
cmpl $0x1, 0x13a18(%rip)     # 0x248c4
jne 0x10e76
movb $0x1, (%rbx)
movq 0x13a00(%rip), %rax     # 0x248b8
movq 0x10(%rax), %rdi
movl 0x139fe(%rip), %esi     # 0x248c0
movslq 0xc0(%rdi), %rax
leaq 0x12dd0(%rip), %rcx     # 0x23ca0
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movl $0x7, (%r14)
jmp 0x10e76
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: updateType
void updateType(linkedlist *destLL, ccInt *sourceType, ccInt *eventualSourceType, ccInt *arrayDepth,
                ccInt newSourceType, ccInt newEventualSourceType, ccInt newArrayDepth, ccBool isMember)
{
    code_ref *loopCodeRef;
    ccInt counter, copyBottom, rtrn;
    
    *sourceType = newSourceType;
    *eventualSourceType = newEventualSourceType;
    *arrayDepth = newArrayDepth;
    
    
        // If it's composite we have to also update the codes.  (Any changes to the code list are code additions.)
    
    if (newEventualSourceType == composite_type)  {
        
        copyBottom = destLL->elementNum+1;
        rtrn = addElements(destLL, GL_Object.codeList->elementNum-copyBottom+1, ccFalse);
        if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr-1);  return;  }
        copyElements(GL_Object.codeList, copyBottom, destLL, copyBottom, GL_Object.codeList->elementNum-copyBottom+1);
        
        if ((isMember) || (newArrayDepth > 0))  {     // reference the new code refs if we're not going to 'customize' the code later
        for (counter = copyBottom; counter <= destLL->elementNum; counter++)  {
            loopCodeRef = (code_ref *) element(destLL, counter);
            loopCodeRef->anchor = NULL;     // since anchors will be 'customized' later, don't assign anchors just yet
            refCodeRef(loopCodeRef);
    }   }}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0x38(%rsp), %r15b
movl 0x30(%rsp), %r14d
movl %r8d, (%rsi)
movl %r9d, (%rdx)
movl %r14d, (%rcx)
cmpl $0x5, %r9d
jne 0x11096
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x13840(%rip), %rax     # 0x24860
movl (%rax), %esi
subl %ebp, %esi
xorl %edx, %edx
callq 0x8b0f
testl %eax, %eax
je 0x1104c
movq 0x137e2(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc7c2
movq 0x1380d(%rip), %rdi     # 0x24860
movl (%rdi), %r8d
subl %ebp, %r8d
incl %ebp
movl %ebp, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x87c7
testb %r15b, %r15b
sete %al
testl %r14d, %r14d
setle %cl
testb %al, %cl
jne 0x11096
cmpl (%rbx), %ebp
jg 0x11096
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9088
andq $0x0, 0x18(%rax)
movq %rax, %rdi
callq 0xe54f
incl %ebp
jmp 0x11077
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: relinkGLStemMember
ccInt relinkGLStemMember(view *targetView, ccBool doRelink, ccBool newTarget, ccBool isUnjammable)
{
    window *newMemberWindow = NULL;
    ccInt rtrn;
    
    
        // first make sure the aliasing is legal
    
    if (GL_Path.stemMember == NULL)  return undefined_member_err;
    else if (GL_Path.indices != GL_Path.stemMember->indices)  return incomplete_member_err;
    else if (searchView.width != searchView.windowPtr->variable_ptr->instances)  return incomplete_variable_err;
    else if ((doRelink) && (!newTarget))  {
        if ((targetView->width != searchView.width*GL_Path.indices))  return mismatched_indices_err;
        else if (targetView->windowPtr == NULL)  return illegal_target_err;
        else if (*(targetView->windowPtr->variable_ptr->references) == 0)  return target_deleted_err;       }
    
    
        // re-alias the member
    
    if (doRelink)  {   // if we're not voiding it, then relink it
        rtrn = addWindow(targetView->windowPtr->variable_ptr, targetView->offset, targetView->width, &newMemberWindow, !isUnjammable);
        if (rtrn != passed)  return rtrn;
        refWindow(newMemberWindow);        }
    
    derefWindow(&(GL_Path.stemMember->memberWindow));
    
    if (doRelink)  GL_Path.stemMember->memberWindow = newMemberWindow;
    
    return passed;
}

// Assembly:
pushq %rax
andq $0x0, (%rsp)
movq 0x137ba(%rip), %rax     # 0x24868
testq %rax, %rax
je 0x110fd
movl 0x137be(%rip), %r8d     # 0x24878
cmpl 0xc(%rax), %r8d
jne 0x11101
movl 0x137fd(%rip), %r9d     # 0x248c4
movq 0x137ea(%rip), %r10     # 0x248b8
movq 0x10(%r10), %r10
cmpl 0xf0(%r10), %r9d
jne 0x11105
testb %sil, %sil
sete %r10b
testb %dl, %dl
setne %dl
orb %r10b, %dl
je 0x1110a
testb %sil, %sil
je 0x1116f
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0xc(%rdi), %edx
jmp 0x1112b
pushq $0x19
jmp 0x11107
pushq $0x1c
jmp 0x11107
pushq $0x1d
popq %rax
popq %rcx
retq
movl 0xc(%rdi), %edx
imull %r8d, %r9d
cmpl %r9d, %edx
jne 0x1116b
movq (%rdi), %rax
testq %rax, %rax
je 0x1117b
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpl $0x0, (%rsi)
je 0x1117f
movl 0x8(%rdi), %esi
xorl %r8d, %r8d
testb %cl, %cl
sete %r8b
movq %rsp, %rcx
movq %rax, %rdi
callq 0xc718
testl %eax, %eax
jne 0x11108
movq (%rsp), %rdi
callq 0xc7e1
movq 0x13712(%rip), %rdi     # 0x24868
callq 0xc801
movq (%rsp), %rax
movq 0x13702(%rip), %rcx     # 0x24868
movq %rax, (%rcx)
jmp 0x11177
pushq $0x4
jmp 0x11107
movq %rax, %rdi
callq 0xc801
xorl %eax, %eax
jmp 0x11108
pushq $0x26
jmp 0x11107
pushq $0x27
jmp 0x11107
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: copyCompareMultiView
void copyCompareMultiView(void(*ccFunction)(view *, view *), view *view1, view *view2)
{
    window dummyWindow1, dummyWindow2;
    variable dummyVar;
    ccBool multiView1 = ((view1->multipleIndices) && (!(view2->multipleIndices)));
    ccBool multiView2 = ((view2->multipleIndices) && (!(view1->multipleIndices)));
    ccBool hasString = ((view1->windowPtr->variable_ptr->type == string_type) || (view2->windowPtr->variable_ptr->type == string_type));
    ccInt rtrn = passed;
    
    if (multiView1)  {
        rtrn = newLinkedList(&(dummyVar.mem.members), 1, sizeof(member), 0., ccFalse);
        encompassMultiView(view1, &dummyWindow1, &dummyWindow2, &dummyVar, hasString);      }
    else if (multiView2)  {
        rtrn = newLinkedList(&(dummyVar.mem.members), 1, sizeof(member), 0., ccFalse);
        encompassMultiView(view2, &dummyWindow1, &dummyWindow2, &dummyVar, hasString);      }
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    
    ccFunction(view1, view2);
    
    if ((multiView1) || (multiView2))  deleteLinkedList(&(dummyVar.mem.members));
    
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r8
movb 0x10(%rsi), %r13b
testb %r13b, %r13b
setne %al
movb 0x10(%rdx), %r14b
testb %r14b, %r14b
sete %cl
movq (%rsi), %rdx
movq 0x10(%rdx), %rdx
movb $0x1, %bpl
cmpl $0x4, 0xc0(%rdx)
je 0x111ee
movq (%rbx), %rdx
movq 0x10(%rdx), %rdx
cmpl $0x4, 0xc0(%rdx)
sete %bpl
testb %r14b, %r14b
sete %dl
testb %r13b, %r13b
sete %sil
cmpb %dl, %sil
je 0x11261
andb %cl, %al
movq %rbx, %r12
cmovneq %r15, %r12
leaq 0x70(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x48
popq %rdx
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movq %r8, 0x8(%rsp)
callq 0x83d5
movl %eax, 0x4(%rsp)
movzbl %bpl, %r8d
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r12, %rdi
callq 0x11299
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %r8
testl %edi, %edi
je 0x11261
movq 0x135c2(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
callq 0xc7c2
jmp 0x11287
testb %r14b, %r14b
sete %bpl
testb %r13b, %r13b
sete %r14b
movq %r15, %rdi
movq %rbx, %rsi
callq *%r8
cmpb %bpl, %r14b
je 0x11287
leaq 0x70(%rsp), %rdi
callq 0x846b
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: encompassMultiView
void encompassMultiView(view *theView, window *dummyWindow1, window *dummyWindow2, variable *dummyVar, ccBool hasString)
{
    member *dummyMember = LL_member(dummyVar, 1);
    dummyMember->memberWindow = dummyWindow2;
    dummyMember->indices = theView->width / baseView.width;
    dummyMember->ifHidden = ccFalse;
    dummyMember->business = 0;
    
    *dummyWindow2 = *(theView->windowPtr);
    dummyWindow2->offset = theView->offset;
    dummyWindow2->width = theView->width;
    
    dummyWindow1->offset = theView->offset;
    if ((hasString) && (theView->windowPtr->variable_ptr->type == char_type))  {
        dummyVar->type = string_type;
        theView->offset = 0;       }
    else  {
        dummyVar->type = array_type;
        theView->offset = theView->windowPtr->offset;       }
    
    dummyWindow1->jamStatus = cannot_jam;
    dummyWindow1->variable_ptr = dummyVar;
    
    theView->windowPtr = dummyWindow1;
    theView->width = baseView.width;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rcx), %rdi
pushq $0x1
popq %rsi
callq 0x9088
movq %rax, %rcx
movq %r12, (%rax)
movl 0xc(%rbx), %eax
cltd
idivl 0x135e0(%rip)           # 0x248ac
movl %eax, 0xc(%rcx)
movb $0x0, 0x40(%rcx)
andl $0x0, 0x44(%rcx)
movq (%rbx), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm0, (%r12)
movups %xmm1, 0x10(%r12)
movq 0x20(%rax), %rax
movq %rax, 0x20(%r12)
movq 0x8(%rbx), %rax
movq %rax, 0x18(%r12)
movl %eax, 0x18(%r15)
movq (%rbx), %rax
testb %bpl, %bpl
je 0x11326
movq 0x10(%rax), %rcx
cmpl $0x1, 0xc0(%rcx)
jne 0x11326
movl $0x4, 0xc0(%r14)
xorl %eax, %eax
jmp 0x11334
movl $0x6, 0xc0(%r14)
movl 0x18(%rax), %eax
movl %eax, 0x8(%rbx)
movb $0x0, 0x20(%r15)
movq %r14, 0x10(%r15)
movq %r15, (%rbx)
movl 0x13563(%rip), %eax     # 0x248ac
movl %eax, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: newStringLL
void newStringLL(view *destView)
{
    member *newStringMember = LL_member(destView->windowPtr->variable_ptr, destView->offset + 1);
    variable *newStringVar = newStringMember->memberWindow->variable_ptr;
    
    resizeMember(newStringMember, searchView.width, stringRegister.elementNum);
    if (errCode != passed)  return;
    
    copyElements(&stringRegister, 1, &(newStringVar->mem.data), newStringMember->memberWindow->offset+1, stringRegister.elementNum);
    
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movl 0x8(%rdi), %esi
incl %esi
movq %rax, %rdi
callq 0x9088
movq %rax, %r14
movq (%rax), %rax
movq 0x10(%rax), %rbx
movl 0x13543(%rip), %esi     # 0x248c4
movl 0x13451(%rip), %edx     # 0x247d8
movq %r14, %rdi
callq 0x11183
cmpl $0x0, 0x133e2(%rip)     # 0x24778
je 0x113a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x10, %rbx
movq (%r14), %rax
movl 0x18(%rax), %ecx
incl %ecx
movl 0x13425(%rip), %r8d     # 0x247d8
leaq 0x1341e(%rip), %rdi     # 0x247d8
pushq $0x1
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x87c7
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: navigate
void navigate(void (*stepFunction)(ccBool), ccBool defineMode, ccBool takeStep, ccBool allowStepToVoid)
{
    
        // find the member to step into (stored in GL_Path.stemMember)
    
    stepFunction(defineMode && canAddMembers);
    GL_Path.stemView = searchView;
    
    if (errCode != passed)  return;
    
    
        // perform the actual step
    
    if (takeStep)  {
        
        if ((searchView.width > 1) && (GL_Path.indices != GL_Path.stemMember->indices))
            {  setError(incomplete_member_err, pcCodePtr-1);  return;  }
        
        if (searchView.windowPtr->variable_ptr->type == composite_type)  {
            if (GL_Path.indices == 0)  {  setError(no_member_err, pcCodePtr-1);  return;  }
            else if (GL_Path.indices > 1)  {  setError(step_multiple_members_err, pcCodePtr-1);  return;  }     }
        
        stepView(&searchView, GL_Path.stemMember, GL_Path.offset, GL_Path.indices);
    }
    
    
        // set our object info before returning
    
    GL_Object.type = var_type;
    if ((allowStepToVoid) && (errCode == void_member_err))  {
        errCode = passed;
        GL_Object.type = no_type;       }
    
    if (searchView.windowPtr != NULL)  GL_Object.codeList = &(searchView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
testb %sil, %sil
setne %cl
cmpb $0x0, 0x12e87(%rip)     # 0x24830
movq %rdi, %rax
setne %dl
andb %cl, %dl
movzbl %dl, %edi
callq *%rax
movq 0x12f0b(%rip), %rax     # 0x248c8
movq %rax, 0x12ecc(%rip)     # 0x24890
movups 0x12eed(%rip), %xmm0    # 0x248b8
movups %xmm0, 0x12eae(%rip)    # 0x24880
cmpl $0x0, 0x12d9f(%rip)     # 0x24778
jne 0x11a9f
testb %bpl, %bpl
je 0x11a36
cmpl $0x2, 0x12ed9(%rip)     # 0x248c4
movl 0x12e87(%rip), %ecx     # 0x24878
jl 0x11a03
movq 0x12e6e(%rip), %rax     # 0x24868
cmpl 0xc(%rax), %ecx
jne 0x11aa6
movq 0x12eae(%rip), %rax     # 0x248b8
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x11a3a
testl %ecx, %ecx
je 0x11ab5
cmpl $0x2, %ecx
jl 0x11a3a
movq 0x12ded(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1b
jmp 0x11ac2
pushq $-0x1
jmp 0x11a72
movq 0x12e27(%rip), %rsi     # 0x24868
movl 0x12e2d(%rip), %edx     # 0x24874
leaq 0x12e6a(%rip), %rdi     # 0x248b8
callq 0xcb03
movl 0x12d1f(%rip), %eax     # 0x24778
orl $-0x1, 0x12dd8(%rip)    # 0x24838
testb %bl, %bl
je 0x11a79
cmpl $0x1a, %eax
jne 0x11a79
andl $0x0, 0x12d08(%rip)     # 0x24778
pushq $0x7
popq %rax
movl %eax, 0x12dbf(%rip)     # 0x24838
movq 0x12e38(%rip), %rax     # 0x248b8
testq %rax, %rax
je 0x11a95
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x12dcb(%rip)     # 0x24860
movl $0x1, 0x12eb5(%rip)     # 0x24954
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x12d6b(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1c
jmp 0x11ac2
movq 0x12d5c(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x18
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc7c2
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: sidStep
void sidStep(ccBool allowAddMember)
{
    ccInt *theIDPtr = pcCodePtr, rtrn;
    
    
        // first get the initial steps along the path
    
    pcCodePtr++;
    callSearchPathFunction();
    if (errCode != passed)  return;
    
    
        // look for the member in this variable
    
    rtrn = findMemberID(searchView.windowPtr->variable_ptr, *theIDPtr,
                    &GL_Path.stemMember, &GL_Path.stemMemberNumber, allowAddMember, isHiddenMember);
    if (rtrn != passed)  setError(rtrn, theIDPtr);
    
    GL_Path.offset = 0;
    GL_Path.indices = 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq 0x12cc3(%rip), %rbx     # 0x24818
leaq 0x4(%rbx), %rax
movq %rax, 0x12cb8(%rip)     # 0x24818
callq 0x11be6
cmpl $0x0, 0x12c0c(%rip)     # 0x24778
jne 0x11bb9
movq 0x12d43(%rip), %rax     # 0x248b8
movq 0x10(%rax), %rdi
movl (%rbx), %esi
movsbl 0x12cae(%rip), %r9d     # 0x24831
movsbl %bpl, %r8d
leaq 0x12cda(%rip), %rdx     # 0x24868
leaq 0x12cdb(%rip), %rcx     # 0x24870
callq 0xe21b
testl %eax, %eax
je 0x11ba8
movl %eax, %edi
movq %rbx, %rsi
callq 0xc7c2
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x12cbb(%rip)     # 0x24874
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: callSearchPathFunction
void callSearchPathFunction()
{
    ccInt *commandPtr = pcCodePtr;
    
    callBytecodeFunction();
    
    if (errCode == passed)  {
        if (GL_Object.type != var_type)  setError(not_a_variable_err, commandPtr);
        else if (searchView.windowPtr == NULL)  setError(void_member_err, commandPtr);
        else if (searchView.windowPtr->variable_ptr->type < string_type)  setError(not_composite_err, commandPtr);      }
}

// Assembly:
pushq %rbx
movq 0x12c2a(%rip), %rbx     # 0x24818
movslq (%rbx), %rax
leaq 0x4(%rbx), %rcx
movq %rcx, 0x12c1c(%rip)     # 0x24818
leaq 0x1195d(%rip), %rcx     # 0x23560
callq *(%rcx,%rax,8)
cmpl $0x0, 0x12b6b(%rip)     # 0x24778
je 0x11c11
popq %rbx
retq
cmpl $-0x1, 0x12c20(%rip)    # 0x24838
je 0x11c26
pushq $0x22
popq %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xc7c2
movq 0x12c8b(%rip), %rax     # 0x248b8
testq %rax, %rax
je 0x11c43
movq 0x10(%rax), %rax
cmpl $0x3, 0xc0(%rax)
jg 0x11c0f
pushq $0x24
jmp 0x11c1c
pushq $0x1a
jmp 0x11c1c
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: stixStep
void stixStep(ccBool allowAddMember)
{
    ccInt soughtIndex, rtrn;
    
    
        // get the initial steps along the path
    
    callSearchPathFunction();
    if (errCode != passed)  return;
    
    
        // get the index to step to
    
    soughtIndex = callIndexFunction();
    if (errCode != passed)  return;
    
    
        // calculate the member number that holds that index
    
    rtrn = findMemberIndex(searchView.windowPtr->variable_ptr, searchView.offset, soughtIndex, &(GL_Path.stemMember),
                                            &(GL_Path.stemMemberNumber), &(GL_Path.offset), allowAddMember);
    if (rtrn != passed)  setError(rtrn, pcCodePtr-1);
    
    GL_Path.indices = 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
callq 0x11be6
cmpl $0x0, 0x12b0b(%rip)     # 0x24778
jne 0x11cd0
callq 0x11cfc
cmpl $0x0, 0x12afd(%rip)     # 0x24778
jne 0x11cd0
movq 0x12c34(%rip), %rcx     # 0x248b8
movq 0x10(%rcx), %rdi
movl 0x12c32(%rip), %esi     # 0x248c0
movsbl %bl, %ecx
movl %ecx, (%rsp)
leaq 0x12bcd(%rip), %rcx     # 0x24868
leaq 0x12bce(%rip), %r8      # 0x24870
leaq 0x12bcb(%rip), %r9      # 0x24874
movl %eax, %edx
callq 0xe374
testl %eax, %eax
je 0x11cc6
movq 0x12b5d(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
movl %eax, %edi
callq 0xc7c2
movl $0x1, 0x12ba8(%rip)     # 0x24878
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: callIndexFunction
ccInt callIndexFunction()
{
    view holdTopView = topView;
    step_params holdGLPath = GL_Path;
    view holdSearchView = searchView;
    
    topView = searchView;
    
    
        // get the index to step to
    
    callNumericFunction(int_type);
    
    topView = holdTopView;
    GL_Path = holdGLPath;
    searchView = holdSearchView;
    
    return intRegister;
}

// Assembly:
subq $0x78, %rsp
movq 0x12c41(%rip), %rax     # 0x24948
movq %rax, 0x30(%rsp)
movups 0x12c25(%rip), %xmm0    # 0x24938
movaps %xmm0, 0x20(%rsp)
movups 0x12b69(%rip), %xmm0    # 0x24888
movaps %xmm0, 0x60(%rsp)
movups 0x12b4d(%rip), %xmm0    # 0x24878
movaps %xmm0, 0x50(%rsp)
movups 0x12b31(%rip), %xmm0    # 0x24868
movaps %xmm0, 0x40(%rsp)
movq 0x12b85(%rip), %rax     # 0x248c8
movq %rax, 0x10(%rsp)
movups 0x12b69(%rip), %xmm0    # 0x248b8
movaps %xmm0, (%rsp)
movq 0x12b6e(%rip), %rax     # 0x248c8
movq %rax, 0x12be7(%rip)     # 0x24948
movups 0x12b50(%rip), %xmm0    # 0x248b8
movups %xmm0, 0x12bc9(%rip)    # 0x24938
pushq $0x2
popq %rdi
callq 0xfb69
movq 0x30(%rsp), %rax
movq %rax, 0x12bc5(%rip)     # 0x24948
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x12ba9(%rip)    # 0x24938
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm0, 0x12ac3(%rip)    # 0x24868
movups %xmm1, 0x12acc(%rip)    # 0x24878
movups %xmm2, 0x12ad5(%rip)    # 0x24888
movaps (%rsp), %xmm0
movups %xmm0, 0x12afa(%rip)    # 0x248b8
movq 0x10(%rsp), %rax
movq %rax, 0x12afe(%rip)     # 0x248c8
movl 0x129fc(%rip), %eax     # 0x247cc
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: staiStep
void staiStep(ccBool allowAddMember)
{
    
        // get the prior path
    
    GL_Path.indices = 1;         // for subsequent STAIs
    callSearchPathFunction();
    if (errCode != passed)  return;
    
    
        // do more checks
    
    if (searchView.windowPtr->variable_ptr->mem.members.elementNum == 0)  {  setError(no_member_err, pcCodePtr-1);  return;  }
    if (searchView.windowPtr->variable_ptr->mem.members.elementNum != 1)  {  setError(step_multiple_members_err, pcCodePtr-1);  return;  }
    
    searchView.multipleIndices = ccTrue;
    
    
        // set all the path params
    
    GL_Path.stemMember = LL_member(searchView.windowPtr->variable_ptr, 1);
    GL_Path.stemMemberNumber = 1;
    GL_Path.offset = 0;
    GL_Path.indices = GL_Path.stemMember->indices;
}

// Assembly:
pushq %rax
movl $0x1, 0x128d8(%rip)     # 0x24878
callq 0x11be6
cmpl $0x0, 0x127cc(%rip)     # 0x24778
je 0x11fb0
popq %rax
retq
movq 0x12901(%rip), %rax     # 0x248b8
movq 0x10(%rax), %rdi
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x11fd6
testl %eax, %eax
jne 0x12006
movq 0x1284a(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x18
jmp 0x12013
addq $0x10, %rdi
movb $0x1, 0x128e7(%rip)     # 0x248c8
pushq $0x1
popq %rsi
callq 0x9088
movq %rax, 0x12878(%rip)     # 0x24868
movq $0x1, 0x12875(%rip) # 0x24870
movl 0xc(%rax), %eax
movl %eax, 0x12874(%rip)     # 0x24878
jmp 0x11fae
movq 0x1280b(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1b
popq %rdi
popq %rax
jmp 0xc7c2
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: remove()
void _remove()
{
    ccInt loopMember;
    
    
        // Get the path to the condemned.
        // Unlike masterInsert(), we don't read the indices separately -- we just step into whatever we want deleted.
    
    canAddMembers = ccFalse;
    callDefineFunction();
    if (errCode != passed)  return;
    
    if ((GL_Object.type != var_type) || (searchView.windowPtr == NULL))
        {  setError(not_a_variable_err, pcCodePtr-1);  return;  }
    if ((searchView.windowPtr != NULL) && (searchView.width != searchView.windowPtr->variable_ptr->instances))
        {  setError(incomplete_variable_err, pcCodePtr-1);  return;  }
    
    if (GL_Path.stemMember == NULL)  {  setError(undefined_member_err, pcCodePtr-1);  return;  }
    
    
        // case 1:  remove a member
    
    if (searchView.windowPtr->variable_ptr->type == composite_type)   {    // we don't take the last step, so SC points to the stem window.
    for (loopMember = 1; loopMember <= GL_Path.indices; loopMember++)  {
//        if (GL_Path.indices != GL_Path.stemMember->indices)  {  setError(incomplete_member_err, pcCodePtr-1);  return;  }
        removeMember(searchView.windowPtr->variable_ptr, GL_Path.stemMemberNumber);    }}
    
    
        // case 2:  delete indices
    
    else if (searchView.windowPtr->variable_ptr->type == array_type)  {
        resizeIndices(GL_Path.stemMember, GL_Path.stemView.width, GL_Path.offset, -GL_Path.indices);  }
    
    GL_Path.stemMember = NULL;          // clean our knives & go
    searchView.windowPtr = NULL;
}

// Assembly:
pushq %rbx
movb $0x0, 0x1204d(%rip)     # 0x24830
movq 0x1202e(%rip), %rax     # 0x24818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x12020(%rip)     # 0x24818
leaq 0x10f31(%rip), %rax     # 0x23730
callq *(%rax,%rcx,8)
cmpl $0x0, 0x11f6f(%rip)     # 0x24778
je 0x1280d
popq %rbx
retq
cmpl $-0x1, 0x12024(%rip)    # 0x24838
setne %cl
movq 0x1209a(%rip), %rax     # 0x248b8
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1283a
movq 0x11fe6(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x22
jmp 0x128a9
movl 0x12084(%rip), %ecx     # 0x248c4
movq 0x10(%rax), %rax
cmpl 0xf0(%rax), %ecx
jne 0x1288d
movq 0x12015(%rip), %rdi     # 0x24868
testq %rdi, %rdi
je 0x1289c
movl 0xc0(%rax), %eax
cmpl $0x6, %eax
je 0x128b0
cmpl $0x5, %eax
jne 0x128c9
pushq $0x1
popq %rbx
cmpl 0x12007(%rip), %ebx     # 0x24878
jg 0x128c9
movq 0x1203e(%rip), %rax     # 0x248b8
movq 0x10(%rax), %rdi
movl 0x11fec(%rip), %esi     # 0x24870
callq 0xec0e
incl %ebx
jmp 0x1286b
movq 0x11f84(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1d
jmp 0x128a9
movq 0x11f75(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x19
popq %rdi
popq %rbx
jmp 0xc7c2
movl 0x11fd6(%rip), %esi     # 0x2488c
movl 0x11fb8(%rip), %edx     # 0x24874
xorl %ecx, %ecx
subl 0x11fb4(%rip), %ecx     # 0x24878
callq 0x126a9
andq $0x0, 0x11f97(%rip)     # 0x24868
andq $0x0, 0x11fdf(%rip)     # 0x248b8
jmp 0x1280b
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: if_eq_at
void _if_eq_at()
{
    view firstView;
    
    
        // get the first argument
    
    eqaOneArg();
    if (errCode != passed)  return;
    firstView = searchView;
    
    eqaOneArg();
    if (errCode != passed)  return;
    
    if (firstView.windowPtr == NULL)  boolRegister = (searchView.windowPtr == NULL);
    else if (searchView.windowPtr == NULL)  boolRegister = ccFalse;
    else boolRegister = ((firstView.windowPtr->variable_ptr == searchView.windowPtr->variable_ptr)
                && (firstView.width == searchView.width) && (firstView.offset == searchView.offset));
    
    GL_Object.type = bool_type;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x12d6f
cmpl $0x0, 0x11a8f(%rip)     # 0x24778
jne 0x12d69
movq 0x11bc6(%rip), %rbx     # 0x248b8
movsd 0x11bc6(%rip), %xmm0    # 0x248c0
movapd %xmm0, (%rsp)
callq 0x12d6f
cmpl $0x0, 0x11a6d(%rip)     # 0x24778
jne 0x12d69
movdqa (%rsp), %xmm1
testq %rbx, %rbx
sete %al
movq 0x11b99(%rip), %rcx     # 0x248b8
testq %rcx, %rcx
sete %dl
orb %al, %dl
movq %rbx, %rax
orq %rcx, %rax
sete %al
testb %dl, %dl
jne 0x12d5c
movq 0x10(%rbx), %rax
cmpq 0x10(%rcx), %rax
sete %cl
movq 0x11b79(%rip), %xmm0    # 0x248c0
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %eax
andb %al, %cl
andb $0x2, %al
shrb %al
andb %cl, %al
movb %al, 0x11a66(%rip)      # 0x247c8
andl $0x0, 0x11acf(%rip)     # 0x24838
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: eqaOneArg
void eqaOneArg()
{
    ccInt *ArgBeginningPtr, *ErrPtr, hold_err_code;
    
    ArgBeginningPtr = pcCodePtr;
    callBytecodeFunction();
    
    if (errCode == passed)  {
        if (GL_Object.type == no_type)  searchView.windowPtr = NULL;
        else if (GL_Object.type != var_type)  setError(not_a_variable_err, pcCodePtr-1);    }
    
    else if (errCode == void_member_err)  {
        
        hold_err_code = errCode;
        errCode = passed;
        ErrPtr = pcCodePtr;
        pcCodePtr = ArgBeginningPtr;
        callSkipFunction();
        
        if (ErrPtr == pcCodePtr)  searchView.windowPtr = NULL;
        else  errCode = hold_err_code;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x11a9d(%rip), %rbx     # 0x24818
movslq (%rbx), %rax
leaq 0x4(%rbx), %r14
movq %r14, 0x11a8f(%rip)     # 0x24818
leaq 0x107d0(%rip), %rcx     # 0x23560
callq *(%rcx,%rax,8)
movl 0x119df(%rip), %eax     # 0x24778
cmpl $0x1a, %eax
je 0x12dca
testl %eax, %eax
jne 0x12e09
movl 0x11a90(%rip), %eax     # 0x24838
cmpl $-0x1, %eax
je 0x12e09
cmpl $0x7, %eax
je 0x12e01
movq 0x11a5f(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x22
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc7c2
andl $0x0, 0x119a7(%rip)     # 0x24778
movq 0x11a40(%rip), %r15     # 0x24818
movslq (%rbx), %rax
movq %r14, 0x11a36(%rip)     # 0x24818
leaq 0x10b17(%rip), %rcx     # 0x23900
callq *(%rcx,%rax,8)
cmpq 0x11a25(%rip), %r15     # 0x24818
je 0x12e01
movl $0x1a, 0x11979(%rip)    # 0x24778
jmp 0x12e09
andq $0x0, 0x11aaf(%rip)     # 0x248b8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: mathOperator
void mathOperator(void(*theOp)(ccFloat), ccInt theType)
{
    ccFloat firstArgument;
    
    callNumericFunction(double_type);           // arg 1
    if (errCode != passed)  return;
    firstArgument = doubleRegister;
    
    callNumericFunction(double_type);           // arg 2
    GL_Object.type = theType;
    
    theOp(firstArgument);   // compute the function (return value isn't specified because result is stored in global variables)
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x3
popq %rdi
callq 0xfb69
cmpl $0x0, 0x1190e(%rip)     # 0x24778
je 0x12e74
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x11954(%rip), %xmm0    # 0x247d0
movsd %xmm0, (%rsp)
pushq $0x3
popq %rdi
callq 0xfb69
movl %ebx, 0x119a9(%rip)     # 0x24838
movsd (%rsp), %xmm0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: logicalOperator
void logicalOperator(void(*logicOp)(ccBool))
{
    ccBool firstArgument;
    
    callLogicalFunction();             // get first arg
    if (errCode != passed)  return;
    firstArgument = boolRegister;
    
    callLogicalFunction();             // get second arg
    logicOp(firstArgument);    // and evaluate the conditional
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xf204
cmpl $0x0, 0x1170a(%rip)     # 0x24778
je 0x13078
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsbl 0x11749(%rip), %ebx     # 0x247c8
callq 0xf204
movl %ebx, %edi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: getCurrentCodeList
void getCurrentCodeList(linkedlist *theList)
{
    ccInt numNewElements = 0, rtrn;
    linkedlist *listToCopy = NULL;
    
    if (GL_Object.type == composite_type)  {
        listToCopy = GL_Object.codeList;        }
    else if ((GL_Object.type == var_type) || (GL_Object.type == no_type))  {
        if ((GL_Object.type == var_type) && (searchView.windowPtr != NULL))  {
            if (searchView.windowPtr->variable_ptr->eventualType == composite_type)  {
                listToCopy = GL_Object.codeList;
        }   }
        else if ((searchView.windowPtr == NULL) && (GL_Path.stemMember != NULL))  {
            if (GL_Path.stemMember->eventualType == composite_type)  {
                listToCopy = &GL_Path.stemMember->codeList;
        }   }
        else if (GL_Object.type == var_type)  {  setError(void_member_err, pcCodePtr-1);  return;  }
    }
    else  {  setError(not_a_function_err, pcCodePtr-1);  return;  }
    
    if (listToCopy != NULL)  numNewElements = listToCopy->elementNum;
    
    rtrn = newLinkedList(theList, numNewElements, sizeof(code_ref), 0., ccFalse);
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    if (listToCopy != NULL)  copyElements(listToCopy, 1, theList, 1, listToCopy->elementNum);
    
    refCodeList(theList);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x11561(%rip), %eax     # 0x24838
cmpl $0x5, %eax
jne 0x132ed
movq 0x1157d(%rip), %r14     # 0x24860
testq %r14, %r14
jne 0x1335a
jmp 0x13376
cmpl $0x7, %eax
je 0x132f7
cmpl $-0x1, %eax
jne 0x13361
cmpl $-0x1, %eax
sete %dl
movq 0x115b4(%rip), %rcx     # 0x248b8
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x13335
movq 0x10(%rcx), %rax
cmpl $0x5, 0xc4(%rax)
setne %al
movq 0x11537(%rip), %r14     # 0x24860
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x1335a
jmp 0x13376
testq %rcx, %rcx
sete %cl
movq 0x11526(%rip), %r14     # 0x24868
testq %r14, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x13371
cmpl $0x5, 0x14(%r14)
jne 0x13376
addq $0x20, %r14
movl (%r14), %esi
xorl %ebp, %ebp
jmp 0x1337e
movq 0x114b0(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x23
popq %rdi
jmp 0x1339f
cmpl $-0x1, %eax
je 0x133cc
xorl %r14d, %r14d
movb $0x1, %bpl
xorl %esi, %esi
pushq $0x20
popq %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x83d5
testl %eax, %eax
je 0x133a8
movq 0x1147f(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xc7c2
testb %bpl, %bpl
jne 0x133c0
movl (%r14), %r8d
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %ecx, %esi
movq %rbx, %rdx
callq 0x87c7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13515
movq 0x11445(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x1a
jmp 0x1336e
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: append_code
void _append_code()
{
    linkedlist firstCodeList, secondCodeList;
    ccInt rtrn;
    
    
        // get the first code argument..
    
    callCodeFunction();
    if (errCode != passed)  return;
    
    getCurrentCodeList(&firstCodeList);
    if (errCode != passed)  return;
    
    
        // get the 2nd argument
    
    callCodeFunction();
    if (errCode != passed)  {  derefCodeList(&firstCodeList);  return;  }
    
    getCurrentCodeList(&secondCodeList);
    if (errCode != passed)  return;
    
    
        // prepare the codeRegister for holding the concatenated code list
    
    derefCodeList(&codeRegister);
    rtrn = resizeLinkedList(&codeRegister, firstCodeList.elementNum+secondCodeList.elementNum, ccFalse);
    if (rtrn != passed)  {  resizeLinkedList(&codeRegister, 0, ccFalse);  setError(rtrn, pcCodePtr-1);  }
    else  {
        copyElements(&firstCodeList, 1, &codeRegister, 1, firstCodeList.elementNum);
        copyElements(&secondCodeList, 1, &codeRegister, firstCodeList.elementNum+1, secondCodeList.elementNum);   }
    
    
        // clean up and go..
    
    GL_Object.type = composite_type;
    GL_Object.codeList = &codeRegister;
    codeNumber = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
callq 0xf33b
cmpl $0x0, 0x1135d(%rip)     # 0x24778
jne 0x1350a
leaq 0x8(%rsp), %rdi
callq 0x132ca
cmpl $0x0, 0x11346(%rip)     # 0x24778
jne 0x1350a
callq 0xf33b
cmpl $0x0, 0x11334(%rip)     # 0x24778
je 0x13455
leaq 0x8(%rsp), %rdi
callq 0x133db
jmp 0x1350a
leaq 0x28(%rsp), %rdi
callq 0x132ca
cmpl $0x0, 0x11312(%rip)     # 0x24778
jne 0x1350a
leaq 0x11385(%rip), %rbx     # 0x247f8
movq %rbx, %rdi
callq 0x133db
movl 0x28(%rsp), %esi
addl 0x8(%rsp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8b23
testl %eax, %eax
je 0x134b7
movl %eax, %ebp
leaq 0x1135e(%rip), %rdi     # 0x247f8
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b23
movq 0x1136e(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
movl %ebp, %edi
callq 0xc7c2
jmp 0x134ef
leaq 0x8(%rsp), %r14
movl (%r14), %r8d
leaq 0x11332(%rip), %r15     # 0x247f8
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x87c7
movl (%r14), %ecx
incl %ecx
leaq 0x28(%rsp), %rdi
movl (%rdi), %r8d
movl %ebp, %esi
movq %r15, %rdx
callq 0x87c7
movl $0x5, 0x1133f(%rip)     # 0x24838
movq %rbx, 0x11360(%rip)     # 0x24860
movl $0x1, 0x1144a(%rip)     # 0x24954
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: get_args
void _get_args()
{
    GL_Path.stemMember = NULL;
    searchView = argsView;
    
    GL_Object.type = var_type;
    if (searchView.windowPtr != NULL)  GL_Object.codeList = &(argsView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
andq $0x0, 0x11321(%rip)     # 0x24868
movups 0x113a2(%rip), %xmm0    # 0x248f0
movups %xmm0, 0x11363(%rip)    # 0x248b8
movq 0x113a4(%rip), %rax     # 0x24900
movq %rax, 0x11365(%rip)     # 0x248c8
orl $-0x1, 0x112ce(%rip)    # 0x24838
cmpq $0x0, 0x11346(%rip)     # 0x248b8
je 0x1358b
movq 0x11375(%rip), %rax     # 0x248f0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x112d5(%rip)     # 0x24860
movl $0x1, 0x113bf(%rip)     # 0x24954
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: this_var
void _this_var()
{
    GL_Path.stemMember = NULL;
    searchView = baseView;
    
    GL_Object.type = var_type;
    GL_Object.codeList = &(baseView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
andq $0x0, 0x112ca(%rip)     # 0x24868
movups 0x112fb(%rip), %xmm0    # 0x248a0
movups %xmm0, 0x1130c(%rip)    # 0x248b8
movq 0x112fd(%rip), %rax     # 0x248b0
movq %rax, 0x1130e(%rip)     # 0x248c8
orl $-0x1, 0x11277(%rip)    # 0x24838
movq 0x112d8(%rip), %rax     # 0x248a0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x11288(%rip)     # 0x24860
movl $0x1, 0x11372(%rip)     # 0x24954
retq