LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: unflagVariables
void unflagVariables(variable *theVariable, unsigned char theFlag)
{
    member *loopMember;
    ccInt counter;
    
    if (!isBusy(theVariable, theFlag))  return;
    clearBusy(theVariable, theFlag);
    
    if (theVariable->type >= composite_type)  {
        for (counter = 1; counter <= theVariable->mem.members.elementNum; counter++)  {
            loopMember = LL_member(theVariable, counter);
            if (loopMember->memberWindow != NULL)  unflagVariables(loopMember->memberWindow->variable_ptr, theFlag);  }}
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0xf4(%rax), %eax
movzbl -0x9(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x12ffc
jmp 0x1307c
movq -0x8(%rbp), %rax
movl 0xf4(%rax), %ecx
movzbl -0x9(%rbp), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xf4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x5, 0xc0(%rax)
jl 0x1307a
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x13078
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %esi
callq 0x9700
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1306b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movzbl -0x9(%rbp), %esi
callq 0x12fd0
jmp 0x1306d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1302d
jmp 0x1307a
jmp 0x1307c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: unlinkWindow
void unlinkWindow(variable *stemVariable, window **unlinkedWindow, ccInt stemMemberNumber)
{
    pinned_LL *unlinkedFibrilList = &((*unlinkedWindow)->variable_ptr->pathList);
    window *holdWindowPtr;
    searchPath *loopPath, *clippedStem;
    ccInt counter;
    
    for (counter = 1; counter <= unlinkedFibrilList->data.elementNum; counter++)  {
    if (*LL_int(&(unlinkedFibrilList->references), counter) != 0)  {
        loopPath = (searchPath *) element(&(unlinkedFibrilList->data), counter);
        if (loopPath->stem != NULL)  {
        if (loopPath->stem->variablePtr == stemVariable)  {
            clippedStem = loopPath->stem;
            loopPath->stem = NULL;
            derefPath(&clippedStem);
    }}  }}
    
    holdWindowPtr = *unlinkedWindow;
    *unlinkedWindow = NULL;
    derefWindow(&holdWindowPtr);        // We just deleted a link, so in any event dereference unlinkedWindow.    
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
addq $0x78, %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x135fc
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x3c(%rbp), %esi
callq 0x9700
cmpl $0x0, (%rax)
je 0x135ef
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x9700
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x135ed
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x135eb
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
leaq -0x38(%rbp), %rdi
callq 0x13630
jmp 0x135ed
jmp 0x135ef
jmp 0x135f1
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1357d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq -0x28(%rbp), %rdi
callq 0xf7d0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: derefPath
void derefPath(searchPath **thePath)
{
    if (*thePath == NULL)  return;
    
    derefPLLPtr(&((*thePath)->variablePtr->pathList), (*thePath)->PLL_index, (*thePath)->references);
    if (*((*thePath)->references) != 0)  {  *thePath = NULL;  return;  }
    
            // if we're being deleted, we aren't the anchor for any other paths
    
    derefPath(&((*thePath)->stem));
    derefPLLElement(&MasterCodeList, (*thePath)->sourceCode);
    derefWindow(&((*thePath)->jamb));
    
    *thePath = NULL;
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1364b
jmp 0x136d1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
addq $0x78, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
callq 0x9aa0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x13690
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x136d1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x13630
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x2c(%rax), %esi
leaq 0x18fe7(%rip), %rdi     # 0x2c698
callq 0x9a60
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0xf7d0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: removeMember
void removeMember(variable *theVariable, ccInt doomedMemberNumber)
{
    ccInt counter;
    member *doomedMember;
    
    doomedMember = LL_member(theVariable, doomedMemberNumber);
    
    
        // delete the member & associated codes & references
    
    if (doomedMember->memberWindow != NULL)  derefWindow(&(doomedMember->memberWindow));
    
    for (counter = 1; counter <= doomedMember->codeList.elementNum; counter++)  {
        derefCodeRef((code_ref *) element(&(doomedMember->codeList), counter));   }
    deleteLinkedList(&(doomedMember->codeList));
    
    deleteElement(&(theVariable->mem.members), doomedMemberNumber);
    
    return;     // we ignored return values from FDeleteElement -- an error is possible, but seems implausible to me.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0x9700
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13716
movq -0x18(%rbp), %rdi
callq 0xf7d0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jg 0x1374c
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movl -0x10(%rbp), %esi
callq 0x9700
movq %rax, %rdi
callq 0x12c40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1371d
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x8540
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0x8eb0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: refPath
void refPath(searchPath *thePath)
{
    if (thePath == NULL)  return;
    
    RefPLLPtr(thePath->references);
    
    if (*(thePath->references) == 1)  {
        refPath(thePath->stem);
        refPLLElement(&MasterCodeList, thePath->sourceCode);
        refWindow(thePath->jamb);     }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13785
jmp 0x137d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
jne 0x137ce
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x13770
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %esi
leaq 0x18edc(%rip), %rdi     # 0x2c698
callq 0x9a30
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xf780
jmp 0x137d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: drawPath
ccInt drawPath(searchPath **newPath, window *destWindow, searchPath *newPathStem, ccInt indices, ccInt sourceCode)
{
    ccInt newPathIndex, rtrn;
    
    rtrn = addPLLElement(&(destWindow->variable_ptr->pathList), (void **) newPath, &newPathIndex);
    if (rtrn != passed)  return rtrn;
    
    (*newPath)->PLL_index = newPathIndex;
    (*newPath)->references = LL_int(&(destWindow->variable_ptr->pathList.references), newPathIndex);
    (*newPath)->stemIndices = indices;
    (*newPath)->stem = newPathStem;
    (*newPath)->variablePtr = destWindow->variable_ptr;
    (*newPath)->sourceCode = sourceCode;
    (*newPath)->jamb = destWindow;
    
    *((*newPath)->references) = 0;
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x98a0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x13828
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x138bd
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x78, %rdi
addq $0x20, %rdi
movl -0x2c(%rbp), %esi
callq 0x9700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/intrpt.c
// Function: derefCode
void derefCode(ccInt *refsPtr, ccInt refsID)
{
    derefPLLPtr(&MasterCodeList, refsID, refsPtr);
    if (refsPtr == NULL)  {
        if (storedCode(refsID)->fileName != NULL)  free((void *) storedCode(refsID)->fileName);
        if (storedCode(refsID)->sourceCode != NULL)  free((void *) storedCode(refsID)->sourceCode);
        if (storedCode(refsID)->opCharNum != NULL)  free((void *) storedCode(refsID)->opCharNum);
        free((void *) storedCode(refsID)->bytecode);        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0x18b8b(%rip), %rdi     # 0x2c698
callq 0x9aa0
cmpq $0x0, -0x8(%rbp)
jne 0x13bbd
movl -0xc(%rbp), %esi
leaq 0x18b71(%rip), %rdi     # 0x2c698
callq 0x9700
cmpq $0x0, (%rax)
je 0x13b49
movl -0xc(%rbp), %esi
leaq 0x18b5c(%rip), %rdi     # 0x2c698
callq 0x9700
movq (%rax), %rdi
callq 0x81c0
movl -0xc(%rbp), %esi
leaq 0x18b45(%rip), %rdi     # 0x2c698
callq 0x9700
cmpq $0x0, 0x8(%rax)
je 0x13b77
movl -0xc(%rbp), %esi
leaq 0x18b2f(%rip), %rdi     # 0x2c698
callq 0x9700
movq 0x8(%rax), %rdi
callq 0x81c0
movl -0xc(%rbp), %esi
leaq 0x18b17(%rip), %rdi     # 0x2c698
callq 0x9700
cmpq $0x0, 0x18(%rax)
je 0x13ba5
movl -0xc(%rbp), %esi
leaq 0x18b01(%rip), %rdi     # 0x2c698
callq 0x9700
movq 0x18(%rax), %rdi
callq 0x81c0
movl -0xc(%rbp), %esi
leaq 0x18ae9(%rip), %rdi     # 0x2c698
callq 0x9700
movq 0x10(%rax), %rdi
callq 0x81c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x13c09
movl $0x1, -0x4(%rbp)
jmp 0x13c6b
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x9700
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %esi
leaq 0x18a69(%rip), %rdi     # 0x2c698
addq $0x20, %rdi
callq 0x9700
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rdi
callq 0x12c80
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpb $0x0, -0x1(%rbp)
je 0x13f69
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x13f69
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
subl (%rdx), %ecx
cmpl %ecx, %eax
jge 0x13f67
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
subl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x13fbd
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x13fbb
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x13fb9
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
subl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x13fb0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x13fbb
jmp 0x13fbd
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movzbl -0x9(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x13ff5
jmp 0x140a1
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
movzbl -0x9(%rbp), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
cmpl $0x5, 0xc0(%rax)
jl 0x1409f
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x1409d
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl -0x1c(%rbp), %esi
callq 0x9700
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14090
movq -0x28(%rbp), %rax
movq (%rax), %rax
movsbl 0x20(%rax), %eax
cmpl $0x1, %eax
jne 0x1408e
movq -0x28(%rbp), %rax
movl 0x44(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1408e
movq -0x28(%rbp), %rax
movl 0x44(%rax), %ecx
andl $-0x21, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movzbl -0x9(%rbp), %esi
callq 0x13fc0
jmp 0x14090
jmp 0x14092
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14024
jmp 0x1409f
jmp 0x140a1
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x18719(%rip), %rax     # 0x2c808
movq 0x18712(%rip), %rcx     # 0x2c808
movslq (%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq 0x186fd(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x186f2(%rip)     # 0x2c808
callq 0x14140
cmpb $0x0, 0x18696(%rip)     # 0x2c7b8
je 0x1412f
movq -0x8(%rbp), %rax
movq %rax, 0x186d9(%rip)     # 0x2c808
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x17405(%rip), %rdi     # 0x2b550
callq 0x1b840
cmpl $0x0, 0x18611(%rip)     # 0x2c768
je 0x1415e
jmp 0x1421e
cmpl $-0x1, 0x186c3(%rip)    # 0x2c828
jne 0x141fc
cmpq $0x0, 0x18735(%rip)     # 0x2c8a8
jne 0x1418f
movq 0x1868c(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x1421e
cmpl $0x1, 0x1871e(%rip)     # 0x2c8b4
je 0x141af
movq 0x18669(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1f, %edi
callq 0xf740
jmp 0x1421e
movq 0x186f2(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x0, 0xc0(%rax)
je 0x141da
movq 0x1863e(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x11, %edi
callq 0xf740
jmp 0x1421e
movq 0x186c7(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rdi
movl 0x186c5(%rip), %esi     # 0x2c8b0
callq 0x1b880
movl $0x0, 0x1862e(%rip)     # 0x2c828
jmp 0x1421e
cmpl $0x0, 0x18625(%rip)     # 0x2c828
je 0x1421c
movq 0x185fc(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x11, %edi
callq 0xf740
jmp 0x1421e
jmp 0x1421e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x185d9(%rip), %rax     # 0x2c808
movq 0x185d2(%rip), %rcx     # 0x2c808
movslq (%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq 0x185bd(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x185b2(%rip)     # 0x2c808
callq 0x14140
cmpb $0x0, 0x18556(%rip)     # 0x2c7b8
jne 0x1426f
movq -0x8(%rbp), %rax
movq %rax, 0x18599(%rip)     # 0x2c808
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
callq 0x14300
cmpl $0x0, 0x184b8(%rip)     # 0x2c768
je 0x142b4
jmp 0x142fc
movq 0x185ed(%rip), %rax     # 0x2c8a8
movq %rax, 0x18636(%rip)     # 0x2c8f8
movq 0x185e7(%rip), %rax     # 0x2c8b0
movq %rax, 0x18630(%rip)     # 0x2c900
movq 0x185e1(%rip), %rax     # 0x2c8b8
movq %rax, 0x1862a(%rip)     # 0x2c908
cmpl $-0x1, 0x18543(%rip)    # 0x2c828
je 0x142f2
movq $0x0, 0x18606(%rip) # 0x2c8f8
movl $0x32, 0x1846c(%rip)    # 0x2c768
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x184f9(%rip), %rax     # 0x2c808
movq %rax, -0x8(%rbp)
leaq 0x177a6(%rip), %rdi     # 0x2bac0
callq 0x1b840
movq -0x8(%rbp), %rax
cmpl $0x2e, (%rax)
je 0x1434c
movq -0x8(%rbp), %rax
cmpl $0x8, (%rax)
je 0x1434c
leaq 0x18418(%rip), %rdi     # 0x2c750
addq $0xd8, %rdi
addq $0x8, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x2, %edi
callq 0x14da0
cmpl $0x0, 0x17acf(%rip)     # 0x2c768
je 0x14ca0
jmp 0x14d98
cmpl $0x0, 0x17b15(%rip)     # 0x2c7bc
jl 0x14cba
movl 0x17b0d(%rip), %eax     # 0x2c7bc
leaq 0x173ca(%rip), %rcx     # 0x2c080
cmpl (%rcx), %eax
jl 0x14cd0
movq 0x17b47(%rip), %rsi     # 0x2c808
movl $0x2b, %edi
callq 0xf740
jmp 0x14d98
movl 0x17ae6(%rip), %eax     # 0x2c7bc
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x172ac(%rip), %rax     # 0x2bf90
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
callq 0x146f0
cmpl $0x0, 0x17a70(%rip)     # 0x2c768
je 0x14cff
jmp 0x14d98
movq 0x17bc2(%rip), %rax     # 0x2c8c8
movq %rax, -0x18(%rbp)
movq 0x17bbf(%rip), %rax     # 0x2c8d0
movq %rax, -0x10(%rbp)
movq 0x17bbc(%rip), %rax     # 0x2c8d8
movq %rax, -0x8(%rbp)
movq 0x17b81(%rip), %rax     # 0x2c8a8
movq %rax, 0x17b9a(%rip)     # 0x2c8c8
movq 0x17b7b(%rip), %rax     # 0x2c8b0
movq %rax, 0x17b94(%rip)     # 0x2c8d0
movq 0x17b75(%rip), %rax     # 0x2c8b8
movq %rax, 0x17b8e(%rip)     # 0x2c8d8
movq $0x0, 0x17ba3(%rip) # 0x2c8f8
callq *-0x20(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x1712d(%rip), %rax     # 0x2be90
movl (%rax,%rcx,4), %eax
movl %eax, 0x17abc(%rip)     # 0x2c828
movq $0x0, 0x17ae1(%rip) # 0x2c858
movq -0x18(%rbp), %rax
movq %rax, 0x17b46(%rip)     # 0x2c8c8
movq -0x10(%rbp), %rax
movq %rax, 0x17b43(%rip)     # 0x2c8d0
movq -0x8(%rbp), %rax
movq %rax, 0x17b40(%rip)     # 0x2c8d8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq *-0x8(%rbp)
cmpl $0x0, 0x15ffa(%rip)     # 0x2c768
je 0x16775
jmp 0x1683f
movl 0x160ad(%rip), %ecx     # 0x2c828
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, (%rcx)
movb %al, -0x19(%rbp)
je 0x1679c
movq -0x10(%rbp), %rax
cmpl $0x7, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %cl
andb $0x1, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x1683f
cmpq $0x0, 0x160eb(%rip)     # 0x2c8a8
jne 0x167cb
movq -0x10(%rbp), %rax
movl $0x7, (%rax)
jmp 0x1683d
movq 0x160d6(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x0, 0xc0(%rax)
jl 0x1683b
movq 0x160c2(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x4, 0xc0(%rax)
jg 0x1683b
movq 0x160ae(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
movl 0xc0(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpb $0x0, 0x160a7(%rip)     # 0x2c8b8
jne 0x16839
cmpl $0x1, 0x1609a(%rip)     # 0x2c8b4
jne 0x16839
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq 0x1607e(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rdi
movl 0x1607c(%rip), %esi     # 0x2c8b0
callq 0x192a0
jmp 0x1683b
jmp 0x1683d
jmp 0x1683f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl 0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x5, -0x28(%rbp)
jne 0x16b2a
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq 0x15dce(%rip), %rax     # 0x2c850
movl (%rax), %esi
subl -0x38(%rbp), %esi
addl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x16ab1
movq 0x15d67(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1, %edi
callq 0xf740
jmp 0x16b2a
movq 0x15d98(%rip), %rdi     # 0x2c850
movl -0x38(%rbp), %esi
movq -0x8(%rbp), %rdx
movl -0x38(%rbp), %ecx
movq 0x15d87(%rip), %rax     # 0x2c850
movl (%rax), %r8d
subl -0x38(%rbp), %r8d
addl $0x1, %r8d
callq 0x8a90
cmpb $0x0, 0x18(%rbp)
jne 0x16ae5
cmpl $0x0, 0x10(%rbp)
jle 0x16b28
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x16b26
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x9700
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rdi
callq 0x12c80
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x16aeb
jmp 0x16b28
jmp 0x16b2a
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x9700
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cltd
idivl 0x1596f(%rip)           # 0x2c89c
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdi
movl $0x28, %edx
callq 0x8120
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
cmpb $0x0, -0x21(%rbp)
je 0x16fbd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0xc0(%rax)
jne 0x16fbd
movq -0x20(%rbp), %rax
movl $0x4, 0xc0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x16fdc
movq -0x20(%rbp), %rax
movl $0x6, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl 0x1589b(%rip), %ecx     # 0x2c89c
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0x9700
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl 0x1585d(%rip), %esi     # 0x2c8b4
movl 0x1576b(%rip), %edx     # 0x2c7c8
callq 0x16ca0
cmpl $0x0, 0x156ff(%rip)     # 0x2c768
je 0x1706d
jmp 0x1709e
movq -0x18(%rbp), %rdx
addq $0x10, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl 0x1573f(%rip), %r8d     # 0x2c7c8
leaq 0x156c0(%rip), %rdi     # 0x2c750
addq $0x78, %rdi
movl $0x1, %esi
callq 0x8a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: smStep
void smStep(ccBool allowAddMember)
{
    searchMember((ccInt) *pcCodePtr, &GL_Path.stemMember, &GL_Path.stemMemberNumber, allowAddMember, isHiddenMember);
    pcCodePtr++;
    
    GL_Path.offset = 0;
    GL_Path.indices = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq 0x14e93(%rip), %rax     # 0x2c808
movl (%rax), %edi
movb -0x1(%rbp), %al
leaq 0x14dcf(%rip), %rsi     # 0x2c750
addq $0x108, %rsi            # imm = 0x108
movq %rsi, %rdx
addq $0x8, %rdx
movsbl %al, %ecx
movsbl 0x14e87(%rip), %r8d     # 0x2c821
callq 0x12450
movq 0x14e62(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x14e57(%rip)     # 0x2c808
movl $0x0, 0x14ea9(%rip)     # 0x2c864
movl $0x1, 0x14ea3(%rip)     # 0x2c868
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq 0x14dc3(%rip), %rax     # 0x2c808
movq %rax, -0x10(%rbp)
movq 0x14db8(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x14dad(%rip)     # 0x2c808
callq 0x17b20
cmpl $0x0, 0x14d01(%rip)     # 0x2c768
je 0x17a6b
jmp 0x17ace
movq 0x14e36(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movb -0x1(%rbp), %al
leaq 0x14cca(%rip), %rdx     # 0x2c750
addq $0x108, %rdx            # imm = 0x108
movq %rdx, %rcx
addq $0x8, %rcx
movsbl %al, %r8d
movsbl 0x14d81(%rip), %r9d     # 0x2c821
callq 0x12690
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x17aba
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xf740
movl $0x0, 0x14da0(%rip)     # 0x2c864
movl $0x1, 0x14d9a(%rip)     # 0x2c868
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x14cd9(%rip), %rax     # 0x2c808
movq %rax, -0x8(%rbp)
callq 0x146f0
cmpl $0x0, 0x14c29(%rip)     # 0x2c768
jne 0x17b9c
cmpl $-0x1, 0x14ce0(%rip)    # 0x2c828
je 0x17b5a
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0xf740
jmp 0x17b9a
cmpq $0x0, 0x14d46(%rip)     # 0x2c8a8
jne 0x17b74
movq -0x8(%rbp), %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x17b98
movq 0x14d2d(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x4, 0xc0(%rax)
jge 0x17b96
movq -0x8(%rbp), %rsi
movl $0x24, %edi
callq 0xf740
jmp 0x17b98
jmp 0x17b9a
jmp 0x17b9c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
callq 0x17b20
cmpl $0x0, 0x14b7e(%rip)     # 0x2c768
je 0x17bee
jmp 0x17c63
callq 0x17cb0
movl %eax, -0x8(%rbp)
cmpl $0x0, 0x14b6b(%rip)     # 0x2c768
je 0x17c01
jmp 0x17c63
movq 0x14ca0(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rdi
movl 0x14c9e(%rip), %esi     # 0x2c8b0
movl -0x8(%rbp), %edx
leaq 0x14b34(%rip), %rcx     # 0x2c750
addq $0x108, %rcx            # imm = 0x108
movq %rcx, %r8
addq $0x8, %r8
movq %rcx, %r9
addq $0xc, %r9
movsbl -0x1(%rbp), %eax
movl %eax, (%rsp)
callq 0x128f0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x17c59
movl -0xc(%rbp), %edi
movq 0x14bb8(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
movl $0x1, 0x14c05(%rip)     # 0x2c868
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x14c69(%rip), %rax     # 0x2c928
movq %rax, -0x18(%rbp)
movq 0x14c66(%rip), %rax     # 0x2c930
movq %rax, -0x10(%rbp)
movq 0x14c63(%rip), %rax     # 0x2c938
movq %rax, -0x8(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0x14a6c(%rip), %rsi     # 0x2c750
addq $0x108, %rsi            # imm = 0x108
movl $0x30, %edx
callq 0x8120
movq 0x14bac(%rip), %rax     # 0x2c8a8
movq %rax, -0x60(%rbp)
movq 0x14ba9(%rip), %rax     # 0x2c8b0
movq %rax, -0x58(%rbp)
movq 0x14ba6(%rip), %rax     # 0x2c8b8
movq %rax, -0x50(%rbp)
movq 0x14b8b(%rip), %rax     # 0x2c8a8
movq %rax, 0x14c04(%rip)     # 0x2c928
movq 0x14b85(%rip), %rax     # 0x2c8b0
movq %rax, 0x14bfe(%rip)     # 0x2c930
movq 0x14b7f(%rip), %rax     # 0x2c8b8
movq %rax, 0x14bf8(%rip)     # 0x2c938
movl $0x2, %edi
callq 0x14da0
movq -0x18(%rbp), %rax
movq %rax, 0x14bd3(%rip)     # 0x2c928
movq -0x10(%rbp), %rax
movq %rax, 0x14bd0(%rip)     # 0x2c930
movq -0x8(%rbp), %rax
movq %rax, 0x14bcd(%rip)     # 0x2c938
leaq 0x149de(%rip), %rdi     # 0x2c750
addq $0x108, %rdi            # imm = 0x108
leaq -0x48(%rbp), %rsi
movl $0x30, %edx
callq 0x8120
movq -0x60(%rbp), %rax
movq %rax, 0x14b16(%rip)     # 0x2c8a8
movq -0x58(%rbp), %rax
movq %rax, 0x14b13(%rip)     # 0x2c8b0
movq -0x50(%rbp), %rax
movq %rax, 0x14b10(%rip)     # 0x2c8b8
movl 0x14a0e(%rip), %eax     # 0x2c7bc
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x1, 0x14850(%rip)     # 0x2c868
callq 0x17b20
cmpl $0x0, 0x14744(%rip)     # 0x2c768
je 0x1802b
jmp 0x180c6
movq 0x14876(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x18053
movq 0x147c5(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x18, %edi
callq 0xf740
jmp 0x180c6
movq 0x1484e(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0x1807b
movq 0x1479d(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1b, %edi
callq 0xf740
jmp 0x180c6
movb $0x1, 0x14836(%rip)     # 0x2c8b8
movq 0x1481f(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x9700
movq %rax, 0x147b6(%rip)     # 0x2c858
movl $0x1, 0x147b4(%rip)     # 0x2c860
movl $0x0, 0x147ae(%rip)     # 0x2c864
movq 0x1479b(%rip), %rax     # 0x2c858
movl 0xc(%rax), %eax
movl %eax, 0x147a2(%rip)     # 0x2c868
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x193c0
cmpl $0x0, 0x13474(%rip)     # 0x2c768
je 0x192fb
jmp 0x193ab
movq 0x135a6(%rip), %rax     # 0x2c8a8
movq %rax, -0x18(%rbp)
movq 0x135a3(%rip), %rax     # 0x2c8b0
movq %rax, -0x10(%rbp)
movq 0x135a0(%rip), %rax     # 0x2c8b8
movq %rax, -0x8(%rbp)
callq 0x193c0
cmpl $0x0, 0x13440(%rip)     # 0x2c768
je 0x1932c
jmp 0x193ab
cmpq $0x0, -0x18(%rbp)
jne 0x19348
cmpq $0x0, 0x1356d(%rip)     # 0x2c8a8
sete %al
andb $0x1, %al
movb %al, 0x13472(%rip)      # 0x2c7b8
jmp 0x193a1
cmpq $0x0, 0x13558(%rip)     # 0x2c8a8
jne 0x1935b
movb $0x0, 0x1345f(%rip)     # 0x2c7b8
jmp 0x1939f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x1353e(%rip), %rdx     # 0x2c8a8
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rbp)
jne 0x19394
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl 0x13534(%rip), %ecx     # 0x2c8b4
movb %al, -0x19(%rbp)
jne 0x19394
movl -0x10(%rbp), %eax
cmpl 0x13522(%rip), %eax     # 0x2c8b0
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, 0x13419(%rip)      # 0x2c7b8
jmp 0x193a1
movl $0x0, 0x1347d(%rip)     # 0x2c828
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x13439(%rip), %rax     # 0x2c808
movq %rax, -0x8(%rbp)
callq 0x146f0
cmpl $0x0, 0x13389(%rip)     # 0x2c768
jne 0x19419
cmpl $0x7, 0x13440(%rip)     # 0x2c828
jne 0x193f7
movq $0x0, 0x134b3(%rip) # 0x2c8a8
jmp 0x19417
cmpl $-0x1, 0x1342a(%rip)    # 0x2c828
je 0x19415
movq 0x13401(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x22, %edi
callq 0xf740
jmp 0x19417
jmp 0x19477
cmpl $0x1a, 0x13348(%rip)    # 0x2c768
jne 0x19475
movl 0x13340(%rip), %eax     # 0x2c768
movl %eax, -0x14(%rbp)
movl $0x0, 0x13333(%rip)     # 0x2c768
movq 0x133cc(%rip), %rax     # 0x2c808
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x133bd(%rip)     # 0x2c808
callq 0x194a0
movq -0x10(%rbp), %rax
cmpq 0x133ad(%rip), %rax     # 0x2c808
jne 0x1946a
movq $0x0, 0x13440(%rip) # 0x2c8a8
jmp 0x19473
movl -0x14(%rbp), %eax
movl %eax, 0x132f5(%rip)     # 0x2c768
jmp 0x19475
jmp 0x19477
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x3, %edi
callq 0x14da0
cmpl $0x0, 0x13268(%rip)     # 0x2c768
je 0x19504
jmp 0x1952f
movsd 0x132b4(%rip), %xmm0    # 0x2c7c0
movsd %xmm0, -0x18(%rbp)
movl $0x3, %edi
callq 0x14da0
movl -0xc(%rbp), %eax
movl %eax, 0x13304(%rip)     # 0x2c828
movq -0x8(%rbp), %rax
movsd -0x18(%rbp), %xmm0
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x14140
cmpl $0x0, 0x12ec0(%rip)     # 0x2c768
je 0x198ac
jmp 0x198c4
movb 0x12f06(%rip), %al      # 0x2c7b8
movb %al, -0x9(%rbp)
callq 0x14140
movq -0x8(%rbp), %rax
movsbl -0x9(%rbp), %edi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)