LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, 0x13aa8(%rip)     # 0x25778
jne 0x11ceb
movl 0x13b60(%rip), %eax     # 0x25838
movl %eax, (%r14)
incl %eax
testl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
setne (%rbx)
cmpl $-0x1, (%r14)
je 0x11cf3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13bbe(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x11d52
movq 0x10(%rax), %rax
movl 0xc0(%rax), %eax
cmpl $0x4, %eax
ja 0x11ceb
movl %eax, (%r14)
cmpb $0x0, 0x13bb0(%rip)     # 0x258c8
jne 0x11ceb
cmpl $0x1, 0x13ba3(%rip)     # 0x258c4
jne 0x11ceb
movb $0x1, (%rbx)
movq 0x13b8b(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x13b89(%rip), %esi     # 0x258c0
movslq 0xc0(%rdi), %rax
leaq 0x12f5b(%rip), %rcx     # 0x24ca0
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movl $0x7, (%r14)
jmp 0x11ceb
// File: /workspace/github_c_makefile_star2_O3/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), %ebp
movl %r8d, (%rsi)
movl %r9d, (%rdx)
movl %ebp, (%rcx)
cmpl $0x5, %r9d
jne 0x11f27
movq %rdi, %rbx
movl (%rdi), %r14d
movq 0x139b7(%rip), %rax     # 0x25860
movl (%rax), %esi
subl %r14d, %esi
xorl %edx, %edx
callq 0x8bb3
testl %eax, %eax
je 0x11ed8
movq 0x13958(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcfa3
leal 0x1(%r14), %ecx
movq 0x1397d(%rip), %rdi     # 0x25860
movl (%rdi), %r8d
subl %r14d, %r8d
movl %ecx, %esi
movq %rbx, %rdx
callq 0x8856
testb %r15b, %r15b
sete %al
testl %ebp, %ebp
setle %cl
testb %al, %cl
jne 0x11f27
cmpl (%rbx), %r14d
jge 0x11f27
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x91d8
movq $0x0, 0x18(%rax)
movq %rax, %rdi
callq 0xf028
jmp 0x11f02
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, (%rsp)
movq 0x13926(%rip), %r8      # 0x25868
testq %r8, %r8
je 0x11f99
movl 0x1392a(%rip), %r9d     # 0x25878
movl $0x1c, %eax
cmpl 0xc(%r8), %r9d
jne 0x11f9e
movl 0x13964(%rip), %r10d    # 0x258c4
movq 0x13951(%rip), %rax     # 0x258b8
movq 0x10(%rax), %r11
movl $0x1d, %eax
cmpl 0xf0(%r11), %r10d
jne 0x11f9e
testb %sil, %sil
sete %al
testb %dl, %dl
setne %dl
orb %al, %dl
je 0x11fa0
testb %sil, %sil
je 0x12006
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0xc(%rdi), %edx
jmp 0x11fc6
movl $0x19, %eax
popq %rcx
retq
movl 0xc(%rdi), %edx
imull %r9d, %r10d
movl $0x4, %eax
cmpl %r10d, %edx
jne 0x11f9e
movq (%rdi), %rax
testq %rax, %rax
je 0x12012
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
cmpl $0x0, (%rsi)
je 0x12019
movl 0x8(%rdi), %esi
xorl %r8d, %r8d
testb %cl, %cl
sete %r8b
movq %rsp, %rcx
movq %rax, %rdi
callq 0xceef
testl %eax, %eax
jne 0x11f9e
movq (%rsp), %rdi
callq 0xcfc2
movq 0x13877(%rip), %rdi     # 0x25868
callq 0xcfe2
movq (%rsp), %rax
movq 0x13867(%rip), %rcx     # 0x25868
movq %rax, (%rcx)
jmp 0x1200e
movq %r8, %rdi
callq 0xcfe2
xorl %eax, %eax
jmp 0x11f9e
movl $0x26, %eax
jmp 0x11f9e
movl $0x27, %eax
jmp 0x11f9e
// File: /workspace/github_c_makefile_star2_O3/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 0x1208e
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 0x12105
andb %cl, %al
movq %rbx, %r12
cmovneq %r15, %r12
leaq 0x70(%rsp), %rdi
xorps %xmm0, %xmm0
movl $0x1, %esi
movl $0x48, %edx
xorl %ecx, %ecx
movq %r8, 0x8(%rsp)
callq 0x83e1
movl %eax, 0x4(%rsp)
movzbl %bpl, %r8d
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r12, %rdi
callq 0x1213d
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %r8
testl %edi, %edi
je 0x12105
movq 0x1371e(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
callq 0xcfa3
jmp 0x1212b
testb %r14b, %r14b
sete %bpl
testb %r13b, %r13b
sete %r14b
movq %r15, %rdi
movq %rbx, %rsi
callq *%r8
cmpb %bpl, %r14b
je 0x1212b
leaq 0x70(%rsp), %rdi
callq 0x847e
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
callq 0x91d8
movq %rax, %rcx
movq %r12, (%rax)
movl 0xc(%rbx), %eax
cltd
idivl 0x1373a(%rip)           # 0x258ac
movl %eax, 0xc(%rcx)
movb $0x0, 0x40(%rcx)
movl $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 0x121cf
movq 0x10(%rax), %rcx
cmpl $0x1, 0xc0(%rcx)
jne 0x121cf
movl $0x4, 0xc0(%r14)
xorl %eax, %eax
jmp 0x121dd
movl $0x6, 0xc0(%r14)
movl 0x18(%rax), %eax
movl %eax, 0x8(%rbx)
movb $0x0, 0x20(%r15)
movq %r14, 0x10(%r15)
movq %r15, (%rbx)
movl 0x136ba(%rip), %eax     # 0x258ac
movl %eax, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x91d8
movq %rax, %r14
movq (%rax), %rax
movq 0x10(%rax), %rbx
movl 0x1369a(%rip), %esi     # 0x258c4
movl 0x135a8(%rip), %eax     # 0x257d8
movl 0xc(%r14), %edx
movl %eax, %ecx
subl %edx, %ecx
jg 0x1223e
movl %eax, %edx
jge 0x12246
movq %r14, %rdi
callq 0x13f35
cmpl $0x0, 0x1352b(%rip)     # 0x25778
je 0x12257
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x10, %rbx
movq (%r14), %rax
movl 0x18(%rax), %ecx
incl %ecx
movl 0x1356e(%rip), %r8d     # 0x257d8
leaq 0x13567(%rip), %rdi     # 0x257d8
movl $0x1, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8856
// File: /workspace/github_c_makefile_star2_O3/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, 0x12f87(%rip)     # 0x25830
movq %rdi, %rax
setne %dl
andb %cl, %dl
movzbl %dl, %edi
callq *%rax
movq 0x1300b(%rip), %rax     # 0x258c8
movq %rax, 0x12fcc(%rip)     # 0x25890
movups 0x12fed(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12fae(%rip)    # 0x25880
cmpl $0x0, 0x12e9f(%rip)     # 0x25778
jne 0x129ad
testb %bpl, %bpl
je 0x12939
cmpl $0x2, 0x12fd9(%rip)     # 0x258c4
movl 0x12f87(%rip), %ecx     # 0x25878
jl 0x12903
movq 0x12f6e(%rip), %rax     # 0x25868
cmpl 0xc(%rax), %ecx
jne 0x129b4
movq 0x12fae(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x12940
testl %ecx, %ecx
je 0x129c6
cmpl $0x2, %ecx
jl 0x12940
movq 0x12eed(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1b, %edi
jmp 0x129d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x12981
movq 0x12f21(%rip), %rsi     # 0x25868
movl 0x12f27(%rip), %edx     # 0x25874
leaq 0x12f64(%rip), %rdi     # 0x258b8
callq 0xd32b
movl 0x12e19(%rip), %eax     # 0x25778
movl $0xffffffff, 0x12ecf(%rip) # imm = 0xFFFFFFFF
testb %bl, %bl
je 0x12987
cmpl $0x1a, %eax
jne 0x12987
movl $0x0, 0x12dfc(%rip)     # 0x25778
movl $0x7, %eax
movl %eax, 0x12eb1(%rip)     # 0x25838
movq 0x12f2a(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x129a3
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x12ebd(%rip)     # 0x25860
movl $0x1, 0x12fa7(%rip)     # 0x25954
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x12e5d(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1c, %edi
jmp 0x129d6
movq 0x12e4b(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x18, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xcfa3
// File: /workspace/github_c_makefile_star2_O3/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 0x12d1b(%rip), %rbx     # 0x25818
leaq 0x4(%rbx), %rax
movq %rax, 0x12d10(%rip)     # 0x25818
callq 0x12bea
cmpl $0x0, 0x12c64(%rip)     # 0x25778
jne 0x12b61
movq 0x12d9b(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl (%rbx), %esi
movsbl 0x12d06(%rip), %r9d     # 0x25831
movsbl %bpl, %r8d
leaq 0x12d32(%rip), %rdx     # 0x25868
leaq 0x12d33(%rip), %rcx     # 0x25870
callq 0xec8a
testl %eax, %eax
je 0x12b50
movl %eax, %edi
movq %rbx, %rsi
callq 0xcfa3
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x12d13(%rip)     # 0x25874
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12c26(%rip), %rbx     # 0x25818
movslq (%rbx), %rax
leaq 0x4(%rbx), %rcx
movq %rcx, 0x12c18(%rip)     # 0x25818
leaq 0x11959(%rip), %rcx     # 0x24560
callq *(%rcx,%rax,8)
cmpl $0x0, 0x12b67(%rip)     # 0x25778
je 0x12c15
popq %rbx
retq
movl $0x22, %edi
cmpl $-0x1, 0x12c17(%rip)    # 0x25838
je 0x12c2c
movq %rbx, %rsi
popq %rbx
jmp 0xcfa3
movq 0x12c85(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x12c4c
movq 0x10(%rax), %rax
movl $0x24, %edi
cmpl $0x3, 0xc0(%rax)
jg 0x12c13
jmp 0x12c23
movl $0x1a, %edi
jmp 0x12c23
// File: /workspace/github_c_makefile_star2_O3/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 $0x80, %rsp
movl %edi, %ebx
callq 0x12bea
cmpl $0x0, 0x12afa(%rip)     # 0x25778
jne 0x12db2
movq 0x12cbd(%rip), %rax     # 0x25948
movq %rax, 0x40(%rsp)
movups 0x12ca1(%rip), %xmm0    # 0x25938
movaps %xmm0, 0x30(%rsp)
movups 0x12be5(%rip), %xmm0    # 0x25888
movaps %xmm0, 0x70(%rsp)
movups 0x12bc9(%rip), %xmm0    # 0x25878
movaps %xmm0, 0x60(%rsp)
movups 0x12bad(%rip), %xmm0    # 0x25868
movaps %xmm0, 0x50(%rsp)
movq 0x12c01(%rip), %rax     # 0x258c8
movq %rax, 0x20(%rsp)
movups 0x12be5(%rip), %xmm0    # 0x258b8
movaps %xmm0, 0x10(%rsp)
movq 0x12be9(%rip), %rax     # 0x258c8
movq %rax, 0x12c62(%rip)     # 0x25948
movups 0x12bcb(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12c44(%rip)    # 0x25938
movl $0x2, %edi
callq 0x10814
movq 0x40(%rsp), %rax
movq %rax, 0x12c3e(%rip)     # 0x25948
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x12c22(%rip)    # 0x25938
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movups %xmm0, 0x12b3c(%rip)    # 0x25868
movups %xmm1, 0x12b45(%rip)    # 0x25878
movups %xmm2, 0x12b4e(%rip)    # 0x25888
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x12b72(%rip)    # 0x258b8
movq 0x20(%rsp), %rax
movq %rax, 0x12b76(%rip)     # 0x258c8
cmpl $0x0, 0x12a1f(%rip)     # 0x25778
jne 0x12db2
movl 0x12a6b(%rip), %edx     # 0x257cc
movq 0x12b50(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x12b4e(%rip), %esi     # 0x258c0
movsbl %bl, %eax
movl %eax, (%rsp)
leaq 0x12ae9(%rip), %rcx     # 0x25868
leaq 0x12aea(%rip), %r8      # 0x25870
leaq 0x12ae7(%rip), %r9      # 0x25874
callq 0xee01
testl %eax, %eax
je 0x12da8
movq 0x12a7b(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
callq 0xcfa3
movl $0x1, 0x12ac6(%rip)     # 0x25878
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12b00(%rip), %rax     # 0x25948
movq %rax, 0x30(%rsp)
movups 0x12ae4(%rip), %xmm0    # 0x25938
movaps %xmm0, 0x20(%rsp)
movups 0x12a28(%rip), %xmm0    # 0x25888
movaps %xmm0, 0x60(%rsp)
movups 0x12a0c(%rip), %xmm0    # 0x25878
movaps %xmm0, 0x50(%rsp)
movups 0x129f0(%rip), %xmm0    # 0x25868
movaps %xmm0, 0x40(%rsp)
movq 0x12a44(%rip), %rax     # 0x258c8
movq %rax, 0x10(%rsp)
movups 0x12a28(%rip), %xmm0    # 0x258b8
movaps %xmm0, (%rsp)
movq 0x12a2d(%rip), %rax     # 0x258c8
movq %rax, 0x12aa6(%rip)     # 0x25948
movups 0x12a0f(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12a88(%rip)    # 0x25938
movl $0x2, %edi
callq 0x10814
movq 0x30(%rsp), %rax
movq %rax, 0x12a82(%rip)     # 0x25948
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x12a66(%rip)    # 0x25938
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm0, 0x12980(%rip)    # 0x25868
movups %xmm1, 0x12989(%rip)    # 0x25878
movups %xmm2, 0x12992(%rip)    # 0x25888
movaps (%rsp), %xmm0
movups %xmm0, 0x129b7(%rip)    # 0x258b8
movq 0x10(%rsp), %rax
movq %rax, 0x129bb(%rip)     # 0x258c8
movl 0x128b9(%rip), %eax     # 0x257cc
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x12580(%rip)     # 0x25878
callq 0x12bea
cmpl $0x0, 0x12474(%rip)     # 0x25778
je 0x13308
popq %rax
retq
movq 0x125a9(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x13331
testl %eax, %eax
jne 0x13363
movq 0x124f2(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x18, %edi
jmp 0x13373
addq $0x10, %rdi
movb $0x1, 0x1258c(%rip)     # 0x258c8
movl $0x1, %esi
callq 0x91d8
movq %rax, 0x1251b(%rip)     # 0x25868
movq $0x1, 0x12518(%rip) # 0x25870
movl 0xc(%rax), %eax
movl %eax, 0x12517(%rip)     # 0x25878
jmp 0x13306
movq 0x124ae(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1b, %edi
popq %rax
jmp 0xcfa3
// File: /workspace/github_c_makefile_star2_O3/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, 0x117ce(%rip)     # 0x25830
movq 0x117af(%rip), %rax     # 0x25818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x117a1(%rip)     # 0x25818
leaq 0x106b2(%rip), %rax     # 0x24730
callq *(%rax,%rcx,8)
cmpl $0x0, 0x116f0(%rip)     # 0x25778
je 0x1408c
popq %rbx
retq
cmpl $-0x1, 0x117a5(%rip)    # 0x25838
setne %cl
movq 0x1181b(%rip), %rax     # 0x258b8
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x140bc
movq 0x11767(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x22, %edi
jmp 0x14139
movl 0x11802(%rip), %ecx     # 0x258c4
movq 0x10(%rax), %rax
cmpl 0xf0(%rax), %ecx
jne 0x14117
movq 0x11793(%rip), %rdi     # 0x25868
testq %rdi, %rdi
je 0x14129
movl 0xc0(%rax), %eax
cmpl $0x6, %eax
je 0x1413f
cmpl $0x5, %eax
jne 0x14158
cmpl $0x0, 0x11787(%rip)     # 0x25878
jle 0x14158
xorl %ebx, %ebx
movq 0x117bc(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x1176a(%rip), %esi     # 0x25870
callq 0xf789
incl %ebx
cmpl 0x11765(%rip), %ebx     # 0x25878
jl 0x140f5
jmp 0x14158
movq 0x116fa(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1d, %edi
jmp 0x14139
movq 0x116e8(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x19, %edi
popq %rbx
jmp 0xcfa3
movl 0x11747(%rip), %esi     # 0x2588c
movl 0x11729(%rip), %edx     # 0x25874
xorl %ecx, %ecx
subl 0x11725(%rip), %ecx     # 0x25878
callq 0x13f35
xorl %eax, %eax
movq %rax, 0x11707(%rip)     # 0x25868
movq %rax, 0x11750(%rip)     # 0x258b8
jmp 0x1408a
// File: /workspace/github_c_makefile_star2_O3/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 0x1476d
cmpl $0x0, 0x11098(%rip)     # 0x25778
jne 0x14767
movq 0x111cb(%rip), %rbx     # 0x258b8
movsd 0x111cb(%rip), %xmm0    # 0x258c0
movapd %xmm0, (%rsp)
callq 0x1476d
cmpl $0x0, 0x11072(%rip)     # 0x25778
jne 0x14767
movdqa (%rsp), %xmm1
testq %rbx, %rbx
sete %al
movq 0x1119e(%rip), %rcx     # 0x258b8
testq %rcx, %rcx
sete %dl
orb %al, %dl
movq %rbx, %rax
orq %rcx, %rax
sete %al
testb %dl, %dl
jne 0x14757
movq 0x10(%rbx), %rax
cmpq 0x10(%rcx), %rax
sete %cl
movq 0x1117e(%rip), %xmm0    # 0x258c0
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, 0x1106b(%rip)      # 0x257c8
movl $0x0, 0x110d1(%rip)     # 0x25838
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1109f(%rip), %rbx     # 0x25818
movslq (%rbx), %rax
leaq 0x4(%rbx), %r14
movq %r14, 0x11091(%rip)     # 0x25818
leaq 0xfdd2(%rip), %rcx      # 0x24560
callq *(%rcx,%rax,8)
movl 0x10fe1(%rip), %eax     # 0x25778
cmpl $0x1a, %eax
je 0x147ca
testl %eax, %eax
jne 0x1480f
movl 0x11092(%rip), %eax     # 0x25838
cmpl $-0x1, %eax
je 0x1480f
cmpl $0x7, %eax
je 0x14804
movq 0x11061(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x22, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xcfa3
movl $0x0, 0x10fa4(%rip)     # 0x25778
movq 0x1103d(%rip), %r15     # 0x25818
movslq (%rbx), %rax
movq %r14, 0x11033(%rip)     # 0x25818
leaq 0x10114(%rip), %rcx     # 0x24900
callq *(%rcx,%rax,8)
cmpq 0x11022(%rip), %r15     # 0x25818
je 0x14804
movl $0x1a, 0x10f76(%rip)    # 0x25778
jmp 0x1480f
movq $0x0, 0x110a9(%rip) # 0x258b8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x3, %edi
callq 0x10814
cmpl $0x0, 0x10ec9(%rip)     # 0x25778
je 0x148b9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x10f0f(%rip), %xmm0    # 0x257d0
movsd %xmm0, (%rsp)
movl $0x3, %edi
callq 0x10814
movl %ebx, 0x10f62(%rip)     # 0x25838
movsd (%rsp), %xmm0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: if_and
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 %rbx
callq 0xfde4
cmpl $0x0, 0x10b1d(%rip)     # 0x25778
jne 0x14c7e
cmpb $0x0, 0x10b64(%rip)     # 0x257c8
setne %bl
callq 0xfde4
cmpb $0x0, 0x10b55(%rip)     # 0x257c8
setne %al
andb %bl, %al
movb %al, 0x10b4a(%rip)      # 0x257c8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x108df(%rip), %eax     # 0x25838
cmpl $0x5, %eax
jne 0x14fa8
movq 0x108fb(%rip), %r14     # 0x25860
testq %r14, %r14
je 0x1501f
movl (%r14), %esi
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x15037
movl (%r14), %r8d
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x8856
jmp 0x15050
cmpl $0x7, %eax
je 0x14fb2
cmpl $-0x1, %eax
jne 0x15008
cmpl $-0x1, %eax
sete %dl
movq 0x108f9(%rip), %rcx     # 0x258b8
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x14fde
movq 0x10(%rcx), %rax
cmpl $0x5, 0xc4(%rax)
je 0x14f5e
jmp 0x1501f
testq %rcx, %rcx
sete %cl
movq 0x1087d(%rip), %r14     # 0x25868
testq %r14, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1501a
cmpl $0x5, 0x14(%r14)
jne 0x1501f
addq $0x20, %r14
jmp 0x14f6e
movq 0x10809(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x23, %edi
jmp 0x15044
cmpl $-0x1, %eax
je 0x1505f
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %esi, %esi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
je 0x15050
movq 0x107da(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcfa3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x151b3
movq 0x107b2(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1a, %edi
jmp 0x15044
// File: /workspace/github_c_makefile_star2_O3/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 0xff3d
cmpl $0x0, 0x106c5(%rip)     # 0x25778
jne 0x151a8
leaq 0x8(%rsp), %rdi
callq 0x14f4c
cmpl $0x0, 0x106ae(%rip)     # 0x25778
jne 0x151a8
callq 0xff3d
cmpl $0x0, 0x1069c(%rip)     # 0x25778
je 0x150ed
leaq 0x8(%rsp), %rdi
callq 0x15071
jmp 0x151a8
leaq 0x28(%rsp), %rdi
callq 0x14f4c
cmpl $0x0, 0x1067a(%rip)     # 0x25778
jne 0x151a8
leaq 0x106ed(%rip), %rbx     # 0x257f8
movq %rbx, %rdi
callq 0x15071
movl 0x28(%rsp), %esi
addl 0x8(%rsp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8bc7
testl %eax, %eax
je 0x1514f
movl %eax, %ebp
leaq 0x106c6(%rip), %rdi     # 0x257f8
xorl %esi, %esi
xorl %edx, %edx
callq 0x8bc7
movq 0x106d6(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %ebp, %edi
callq 0xcfa3
jmp 0x1518d
leaq 0x8(%rsp), %r14
movl (%r14), %r8d
leaq 0x1069a(%rip), %r15     # 0x257f8
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x8856
movl (%r14), %ecx
incl %ecx
leaq 0x28(%rsp), %rdi
movl (%rdi), %r8d
movl $0x1, %esi
movq %r15, %rdx
callq 0x8856
movl $0x5, 0x106a1(%rip)     # 0x25838
movq %rbx, 0x106c2(%rip)     # 0x25860
movl $0x1, 0x107ac(%rip)     # 0x25954
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, 0x1067e(%rip) # 0x25868
movups 0x106ff(%rip), %xmm0    # 0x258f0
movups %xmm0, 0x106c0(%rip)    # 0x258b8
movq 0x10701(%rip), %rax     # 0x25900
movq %rax, 0x106c2(%rip)     # 0x258c8
movl $0xffffffff, 0x10628(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x106a0(%rip)     # 0x258b8
je 0x15231
movq 0x106cf(%rip), %rax     # 0x258f0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x1062f(%rip)     # 0x25860
movl $0x1, 0x10719(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, 0x10621(%rip) # 0x25868
movups 0x10652(%rip), %xmm0    # 0x258a0
movups %xmm0, 0x10663(%rip)    # 0x258b8
movq 0x10654(%rip), %rax     # 0x258b0
movq %rax, 0x10665(%rip)     # 0x258c8
movl $0xffffffff, 0x105cb(%rip) # imm = 0xFFFFFFFF
movq 0x1062c(%rip), %rax     # 0x258a0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x105dc(%rip)     # 0x25860
movl $0x1, 0x106c6(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: that_var
void _that_var()
{
    GL_Path.stemMember = NULL;
    searchView = thatView;
    
    GL_Object.type = var_type;
    if (searchView.windowPtr != NULL)  GL_Object.codeList = &(thatView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
movq $0x0, 0x105ce(%rip) # 0x25868
movups 0x1067f(%rip), %xmm0    # 0x25920
movups %xmm0, 0x10610(%rip)    # 0x258b8
movq 0x10681(%rip), %rax     # 0x25930
movq %rax, 0x10612(%rip)     # 0x258c8
movl $0xffffffff, 0x10578(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x105f0(%rip)     # 0x258b8
je 0x152e1
movq 0x1064f(%rip), %rax     # 0x25920
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x1057f(%rip)     # 0x25860
movl $0x1, 0x10669(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: parent_var
void _parent_var()
{
    searchPath *searchPosition = pcSearchPath;
    
    pcCodePtr--;
    searchView = baseView;                      // a.\.a won't work
//    searchView.width = baseView.width;          // in case the first stem is NULL
    do  {
        searchView.windowPtr = searchPosition->jamb;
        if (searchPosition->stemIndices == 0)  {
        if (searchPosition->stem != NULL)  {
            searchView.offset = searchView.windowPtr->offset;
            searchView.width = searchPosition->stem->jamb->width;     }}
        else  {
            searchView.offset = (searchView.offset - searchView.windowPtr->offset) / searchPosition->stemIndices;
            if (searchView.width > 1)  searchView.width /= searchPosition->stemIndices;        }
        
        searchPosition = searchPosition->stem;
        if (searchPosition == NULL)  {  setError(no_parent_err, pcCodePtr-1);  return;  }
        pcCodePtr++;
    }  while (*pcCodePtr == parent_variable);
    
    searchView.windowPtr = searchPosition->jamb;
    searchView.multipleIndices = ccFalse;
    GL_Object.type = var_type;
    GL_Object.codeList = &(searchView.windowPtr->variable_ptr->codeList);
}

// Assembly:
movq 0x105dd(%rip), %r8      # 0x258d0
movq 0x1051e(%rip), %rsi     # 0x25818
leaq -0x4(%rsi), %rax
movq %rax, 0x10513(%rip)     # 0x25818
movups 0x10594(%rip), %xmm0    # 0x258a0
movups %xmm0, 0x105a5(%rip)    # 0x258b8
movq 0x10596(%rip), %rax     # 0x258b0
movq %rax, 0x105a7(%rip)     # 0x258c8
movl 0x10599(%rip), %ecx     # 0x258c0
movl 0x10597(%rip), %edi     # 0x258c4
movq 0x18(%r8), %r9
movl 0x28(%r8), %r10d
testl %r10d, %r10d
je 0x1535b
subl 0x18(%r9), %ecx
movl %ecx, %eax
cltd
idivl %r10d
movl %eax, %ecx
movl %eax, 0x10574(%rip)     # 0x258c0
cmpl $0x2, %edi
jl 0x1537b
movl %edi, %eax
cltd
idivl %r10d
movl %eax, %edi
jmp 0x15375
movq 0x20(%r8), %rax
testq %rax, %rax
je 0x1537b
movl 0x18(%r9), %ecx
movl %ecx, 0x10552(%rip)     # 0x258c0
movq 0x18(%rax), %rax
movl 0x1c(%rax), %edi
movl %edi, 0x10549(%rip)     # 0x258c4
movq 0x20(%r8), %r8
testq %r8, %r8
je 0x153c1
movq %rsi, 0x1048d(%rip)     # 0x25818
cmpl $0x2b, (%rsi)
leaq 0x4(%rsi), %rsi
je 0x1532d
movq 0x18(%r8), %rax
movq %rax, 0x10519(%rip)     # 0x258b8
movb $0x0, 0x10522(%rip)     # 0x258c8
movl $0xffffffff, 0x10488(%rip) # imm = 0xFFFFFFFF
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x104a0(%rip)     # 0x25860
retq
movq %r9, 0x104f0(%rip)      # 0x258b8
addq $-0x8, %rsi
movl $0x21, %edi
jmp 0xcfa3
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: array_cmd
void _array_cmd()
{
    ccInt theIndex, rtrn;
    
    callNumericFunction(int_type);
    if (errCode != passed)  return;
    theIndex = intRegister;
    
    if (theIndex < 0)  {  setError(invalid_index_err, pcCodePtr-1);  return;  }
    
    callCodeFunction();
    if (errCode != passed)  return;
    
    rtrn = insertElements(&(GL_Object.arrayDimList), 1, 1, ccFalse);
    if (rtrn != passed)  setError(rtrn, pcCodePtr-1);
    else  *LL_int(&(GL_Object.arrayDimList), 1) = theIndex;
}

// Assembly:
pushq %rbx
movl $0x2, %edi
callq 0x10814
cmpl $0x0, 0x10347(%rip)     # 0x25778
je 0x15435
popq %rbx
retq
movl 0x10391(%rip), %ebx     # 0x257cc
testl %ebx, %ebx
js 0x15478
callq 0xff3d
cmpl $0x0, 0x1032d(%rip)     # 0x25778
jne 0x15433
leaq 0x103ec(%rip), %rdi     # 0x25840
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x84af
testl %eax, %eax
je 0x1548e
movq 0x103a8(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
jmp 0x15488
movq 0x10399(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1e, %edi
popq %rbx
jmp 0xcfa3
leaq 0x103ab(%rip), %rdi     # 0x25840
movl $0x1, %esi
callq 0x91d8
movl %ebx, (%rax)
jmp 0x15433
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: constant_string
void _constant_string()
{
    GL_Object.type = string_type;
    resizeLinkedList(&stringRegister, *pcCodePtr, ccFalse);
    pcCodePtr++;
    
    setElements(&stringRegister, 1, stringRegister.elementNum, (void *) pcCodePtr);
    pcCodePtr += (ccInt) ceil(((ccFloat) stringRegister.elementNum)/sizeof(ccInt));
}

// Assembly:
pushq %rbx
movl $0x4, 0x102bb(%rip)     # 0x25838
movq 0x10294(%rip), %rax     # 0x25818
movl (%rax), %esi
leaq 0x1024b(%rip), %rbx     # 0x257d8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8bc7
movq 0x1027a(%rip), %rcx     # 0x25818
addq $0x4, %rcx
movq %rcx, 0x1026f(%rip)     # 0x25818
movl 0x10229(%rip), %edx     # 0x257d8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8fba
cvtsi2sdl 0x10214(%rip), %xmm0 # 0x257d8
mulsd 0x5a4c(%rip), %xmm0     # 0x1b018
callq 0x8070
cvttsd2si %xmm0, %eax
cltq
shlq $0x2, %rax
addq %rax, 0x10236(%rip)     # 0x25818
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: code_block
void _code_block()
{
    code_ref *oneCodeRef;
    ccInt rtrn;
    
    derefCodeList(&codeRegister);
    rtrn = resizeLinkedList(&codeRegister, 1, ccFalse);
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    
    oneCodeRef = (code_ref *) element(&codeRegister, 1);
    oneCodeRef->PLL_index = PCCodeRef.PLL_index;
    oneCodeRef->references = PCCodeRef.references;
    oneCodeRef->code_ptr = pcCodePtr;
    oneCodeRef->anchor = NULL;          // will be 'customized' later
    
    refCodeList(&codeRegister);
    
    runSkipMode(0);     // get over the code without executing any of it
    pcCodePtr++;
    
    GL_Object.type = composite_type;
    GL_Object.codeList = &codeRegister;
    codeNumber = 1;
}

// Assembly:
pushq %rbx
leaq 0x1020c(%rip), %rbx     # 0x257f8
movq %rbx, %rdi
callq 0x15071
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8bc7
testl %eax, %eax
je 0x1561a
movq 0x1020a(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
popq %rbx
jmp 0xcfa3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x91d8
movl 0x1033b(%rip), %ecx     # 0x25968
movl %ecx, (%rax)
movq 0x1033a(%rip), %rcx     # 0x25970
movq %rcx, 0x8(%rax)
movq 0x101d7(%rip), %rcx     # 0x25818
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rbx, %rdi
callq 0x151b3
xorl %edi, %edi
callq 0x15681
addq $0x4, 0x101b4(%rip)     # 0x25818
movl $0x5, 0x101ca(%rip)     # 0x25838
movq %rbx, 0x101eb(%rip)     # 0x25860
movl $0x1, 0x102d5(%rip)     # 0x25954
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: runSkipMode
void runSkipMode(ccInt codesToSkip)
{
    while (*pcCodePtr != end_of_script)  {
        if ((*pcCodePtr == code_marker) && (codesToSkip != 0))    {
            codesToSkip--;
            if (codesToSkip == 0)  return;    }
        callSkipFunction();
        if (errCode != passed)  return;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xf272(%rip), %r14      # 0x24900
movq 0x10183(%rip), %rcx     # 0x25818
movslq (%rcx), %rax
testq %rax, %rax
je 0x156ce
cmpl $0x4, %eax
sete %dl
testl %ebx, %ebx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x156b6
decl %ebx
je 0x156ce
addq $0x4, %rcx
movq %rcx, 0x10157(%rip)     # 0x25818
callq *(%r14,%rax,8)
cmpl $0x0, 0x100ac(%rip)     # 0x25778
je 0x1568e
addq $0x8, %rsp
popq %rbx
popq %r14
retq