LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x13797(%rip), %r8      # 0x25868
testq %r8, %r8
je 0x1216e
movl 0x13797(%rip), %r9d     # 0x25878
movl $0x1c, %eax
cmpl 0xc(%r8), %r9d
jne 0x12173
movl 0x137cd(%rip), %r10d    # 0x258c4
movq 0x137ba(%rip), %rax     # 0x258b8
movq 0x10(%rax), %r11
movl $0x1d, %eax
cmpl 0xf0(%r11), %r10d
jne 0x12173
testb %sil, %sil
sete %al
testb %dl, %dl
setne %dl
orb %al, %dl
je 0x12175
testb %sil, %sil
je 0x121a0
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0x8(%rdi), %esi
movl 0xc(%rdi), %edx
xorl %r8d, %r8d
testb %cl, %cl
sete %r8b
movq %rsp, %rcx
movq %rax, %rdi
callq 0xd0f1
testl %eax, %eax
jne 0x12173
movq (%rsp), %rdi
callq 0xd1c8
movq 0x1370f(%rip), %rdi     # 0x25868
callq 0xd1e8
movq (%rsp), %rax
movq 0x136ff(%rip), %rcx     # 0x25868
movq %rax, (%rcx)
jmp 0x121a8
movl $0x19, %eax
popq %rcx
retq
imull %r9d, %r10d
movl $0x4, %eax
cmpl %r10d, 0xc(%rdi)
jne 0x12173
movq (%rdi), %rax
testq %rax, %rax
je 0x121ac
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jne 0x1211f
movl $0x27, %eax
jmp 0x12173
movq %r8, %rdi
callq 0xd1e8
xorl %eax, %eax
jmp 0x12173
movl $0x26, %eax
jmp 0x12173
// File: /workspace/github_c_makefile_star2_O1/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, 0x8(%rsp)
movb 0x10(%rsi), %al
testb %al, %al
je 0x121f8
cmpb $0x0, 0x10(%rbx)
sete %r12b
jmp 0x121fb
xorl %r12d, %r12d
testb %al, %al
sete %r13b
cmpb $0x0, 0x10(%rbx)
setne %al
movq (%r15), %rcx
movq 0x10(%rcx), %rcx
movb $0x1, %r14b
cmpl $0x4, 0xc0(%rcx)
je 0x1222d
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
cmpl $0x4, 0xc0(%rcx)
sete %r14b
andb %al, %r13b
testb %r12b, %r12b
je 0x12268
leaq 0x70(%rsp), %rdi
xorps %xmm0, %xmm0
movl $0x1, %esi
movl $0x48, %edx
xorl %ecx, %ecx
callq 0x83e1
movl %eax, %ebp
movzbl %r14b, %r8d
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %r15, %rdi
jmp 0x122a0
xorl %ebp, %ebp
testb %r13b, %r13b
je 0x122a5
leaq 0x70(%rsp), %rdi
xorps %xmm0, %xmm0
movl $0x1, %esi
movl $0x48, %edx
xorl %ecx, %ecx
callq 0x83e1
movl %eax, %ebp
movzbl %r14b, %r8d
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x60(%rsp), %rcx
movq %rbx, %rdi
callq 0x122ec
testl %ebp, %ebp
je 0x122bd
movq 0x13568(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %ebp, %edi
callq 0xd1a9
jmp 0x122da
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%rsp)
orb %r13b, %r12b
testb $0x1, %r12b
je 0x122da
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_O1/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 0x911c
movq %rax, %rcx
movq %r12, (%rax)
movl 0xc(%rbx), %eax
cltd
idivl 0x1358b(%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)
movl 0x8(%rbx), %eax
movl %eax, 0x18(%r12)
movl 0xc(%rbx), %ecx
movl %ecx, 0x1c(%r12)
movl %eax, 0x18(%r15)
testb %bpl, %bpl
je 0x12385
movq (%rbx), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0xc0(%rax)
jne 0x12385
movl $0x4, 0xc0(%r14)
xorl %eax, %eax
jmp 0x12396
movl $0x6, 0xc0(%r14)
movq (%rbx), %rax
movl 0x18(%rax), %eax
movl %eax, 0x8(%rbx)
movb $0x0, 0x20(%r15)
movq %r14, 0x10(%r15)
movq %r15, (%rbx)
movl 0x13501(%rip), %eax     # 0x258ac
movl %eax, 0xc(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x911c
movq %rax, %r14
movq (%rax), %rax
movq 0x10(%rax), %rbx
movl 0x134e1(%rip), %esi     # 0x258c4
movl 0x133ef(%rip), %edx     # 0x257d8
movq %r14, %rdi
callq 0x121b3
cmpl $0x0, 0x13380(%rip)     # 0x25778
je 0x12402
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x10, %rbx
movq (%r14), %rax
movl 0x18(%rax), %ecx
incl %ecx
movl 0x133c3(%rip), %r8d     # 0x257d8
leaq 0x133bc(%rip), %rdi     # 0x257d8
movl $0x1, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8821
// File: /workspace/github_c_makefile_star2_O1/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, 0x12e2a(%rip)     # 0x25830
movq %rdi, %rax
setne %dl
andb %cl, %dl
movzbl %dl, %edi
callq *%rax
movq 0x12eae(%rip), %rax     # 0x258c8
movq %rax, 0x12e6f(%rip)     # 0x25890
movups 0x12e90(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12e51(%rip)    # 0x25880
cmpl $0x0, 0x12d42(%rip)     # 0x25778
jne 0x12b0c
testb %bpl, %bpl
je 0x12abb
cmpl $0x2, 0x12e7c(%rip)     # 0x258c4
jl 0x12a60
movl 0x12e28(%rip), %eax     # 0x25878
movq 0x12e11(%rip), %rcx     # 0x25868
cmpl 0xc(%rcx), %eax
jne 0x12b13
movq 0x12e51(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x12a9c
movl 0x12dfe(%rip), %eax     # 0x25878
testl %eax, %eax
je 0x12b25
cmpl $0x2, %eax
jl 0x12a9c
movq 0x12d8a(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1b, %edi
jmp 0x12b35
movq 0x12dc5(%rip), %rsi     # 0x25868
movl 0x12dcb(%rip), %edx     # 0x25874
movl 0x12dc9(%rip), %ecx     # 0x25878
leaq 0x12e02(%rip), %rdi     # 0x258b8
callq 0xd531
movl $0xffffffff, 0x12d73(%rip) # imm = 0xFFFFFFFF
testb %bl, %bl
je 0x12ae6
cmpl $0x1a, 0x12ca8(%rip)    # 0x25778
jne 0x12ae6
movl $0x0, 0x12c9c(%rip)     # 0x25778
movl $0x7, 0x12d52(%rip)     # 0x25838
movq 0x12dcb(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x12b02
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x12d5e(%rip)     # 0x25860
movl $0x1, 0x12e48(%rip)     # 0x25954
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x12cfe(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1c, %edi
jmp 0x12b35
movq 0x12cec(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x18, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd1a9
// File: /workspace/github_c_makefile_star2_O1/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 0x12bbc(%rip), %rbx     # 0x25818
leaq 0x4(%rbx), %rax
movq %rax, 0x12bb1(%rip)     # 0x25818
callq 0x12d49
cmpl $0x0, 0x12b05(%rip)     # 0x25778
jne 0x12cc0
movq 0x12c3c(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl (%rbx), %esi
movsbl 0x12ba7(%rip), %r9d     # 0x25831
movsbl %bpl, %r8d
leaq 0x12bd3(%rip), %rdx     # 0x25868
leaq 0x12bd4(%rip), %rcx     # 0x25870
callq 0xeece
testl %eax, %eax
je 0x12caf
movl %eax, %edi
movq %rbx, %rsi
callq 0xd1a9
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x12bb4(%rip)     # 0x25874
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12ac7(%rip), %rbx     # 0x25818
movslq (%rbx), %rax
leaq 0x4(%rbx), %rcx
movq %rcx, 0x12ab9(%rip)     # 0x25818
leaq 0x117fa(%rip), %rcx     # 0x24560
callq *(%rcx,%rax,8)
cmpl $0x0, 0x12a08(%rip)     # 0x25778
je 0x12d74
popq %rbx
retq
movl $0x22, %edi
cmpl $-0x1, 0x12ab8(%rip)    # 0x25838
je 0x12d8b
movq %rbx, %rsi
popq %rbx
jmp 0xd1a9
movq 0x12b26(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x12dab
movq 0x10(%rax), %rax
movl $0x24, %edi
cmpl $0x3, 0xc0(%rax)
jg 0x12d72
jmp 0x12d82
movl $0x1a, %edi
jmp 0x12d82
// File: /workspace/github_c_makefile_star2_O1/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 0x12d49
cmpl $0x0, 0x1299b(%rip)     # 0x25778
jne 0x12f11
movq 0x12b5e(%rip), %rax     # 0x25948
movq %rax, 0x40(%rsp)
movups 0x12b42(%rip), %xmm0    # 0x25938
movaps %xmm0, 0x30(%rsp)
movups 0x12a86(%rip), %xmm0    # 0x25888
movaps %xmm0, 0x70(%rsp)
movups 0x12a6a(%rip), %xmm0    # 0x25878
movaps %xmm0, 0x60(%rsp)
movups 0x12a4e(%rip), %xmm0    # 0x25868
movaps %xmm0, 0x50(%rsp)
movq 0x12aa2(%rip), %rax     # 0x258c8
movq %rax, 0x20(%rsp)
movups 0x12a86(%rip), %xmm0    # 0x258b8
movaps %xmm0, 0x10(%rsp)
movq 0x12a8a(%rip), %rax     # 0x258c8
movq %rax, 0x12b03(%rip)     # 0x25948
movups 0x12a6c(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12ae5(%rip)    # 0x25938
movl $0x2, %edi
callq 0x10a77
movq 0x40(%rsp), %rax
movq %rax, 0x12adf(%rip)     # 0x25948
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x12ac3(%rip)    # 0x25938
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movups %xmm0, 0x129dd(%rip)    # 0x25868
movups %xmm1, 0x129e6(%rip)    # 0x25878
movups %xmm2, 0x129ef(%rip)    # 0x25888
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x12a13(%rip)    # 0x258b8
movq 0x20(%rsp), %rax
movq %rax, 0x12a17(%rip)     # 0x258c8
cmpl $0x0, 0x128c0(%rip)     # 0x25778
jne 0x12f11
movl 0x1290c(%rip), %edx     # 0x257cc
movq 0x129f1(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x129ef(%rip), %esi     # 0x258c0
movsbl %bl, %eax
movl %eax, (%rsp)
leaq 0x1298a(%rip), %rcx     # 0x25868
leaq 0x1298b(%rip), %r8      # 0x25870
leaq 0x12988(%rip), %r9      # 0x25874
callq 0xf043
testl %eax, %eax
je 0x12f07
movq 0x1291c(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
callq 0xd1a9
movl $0x1, 0x12967(%rip)     # 0x25878
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x129a1(%rip), %rax     # 0x25948
movq %rax, 0x30(%rsp)
movups 0x12985(%rip), %xmm0    # 0x25938
movaps %xmm0, 0x20(%rsp)
movups 0x128c9(%rip), %xmm0    # 0x25888
movaps %xmm0, 0x60(%rsp)
movups 0x128ad(%rip), %xmm0    # 0x25878
movaps %xmm0, 0x50(%rsp)
movups 0x12891(%rip), %xmm0    # 0x25868
movaps %xmm0, 0x40(%rsp)
movq 0x128e5(%rip), %rax     # 0x258c8
movq %rax, 0x10(%rsp)
movups 0x128c9(%rip), %xmm0    # 0x258b8
movaps %xmm0, (%rsp)
movq 0x128ce(%rip), %rax     # 0x258c8
movq %rax, 0x12947(%rip)     # 0x25948
movups 0x128b0(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x12929(%rip)    # 0x25938
movl $0x2, %edi
callq 0x10a77
movq 0x30(%rsp), %rax
movq %rax, 0x12923(%rip)     # 0x25948
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x12907(%rip)    # 0x25938
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm0, 0x12821(%rip)    # 0x25868
movups %xmm1, 0x1282a(%rip)    # 0x25878
movups %xmm2, 0x12833(%rip)    # 0x25888
movaps (%rsp), %xmm0
movups %xmm0, 0x12858(%rip)    # 0x258b8
movq 0x10(%rsp), %rax
movq %rax, 0x1285c(%rip)     # 0x258c8
movl 0x1275a(%rip), %eax     # 0x257cc
addq $0x78, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x12421(%rip)     # 0x25878
callq 0x12d49
cmpl $0x0, 0x12315(%rip)     # 0x25778
je 0x13467
popq %rax
retq
movq 0x1244a(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x13490
testl %eax, %eax
jne 0x134c2
movq 0x12393(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x18, %edi
jmp 0x134d2
addq $0x10, %rdi
movb $0x1, 0x1242d(%rip)     # 0x258c8
movl $0x1, %esi
callq 0x911c
movq %rax, 0x123bc(%rip)     # 0x25868
movq $0x1, 0x123b9(%rip) # 0x25870
movl 0xc(%rax), %eax
movl %eax, 0x123b8(%rip)     # 0x25878
jmp 0x13465
movq 0x1234f(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1b, %edi
popq %rax
jmp 0xd1a9
// File: /workspace/github_c_makefile_star2_O1/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, 0x1170f(%rip)     # 0x25830
movq 0x116f0(%rip), %rax     # 0x25818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x116e2(%rip)     # 0x25818
leaq 0x105f3(%rip), %rax     # 0x24730
callq *(%rax,%rcx,8)
cmpl $0x0, 0x11631(%rip)     # 0x25778
je 0x1414b
popq %rbx
retq
cmpl $-0x1, 0x116e6(%rip)    # 0x25838
setne %cl
movq 0x1175c(%rip), %rax     # 0x258b8
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1417b
movq 0x116a8(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x22, %edi
jmp 0x141f8
movl 0x11743(%rip), %ecx     # 0x258c4
movq 0x10(%rax), %rax
cmpl 0xf0(%rax), %ecx
jne 0x141d6
movq 0x116d4(%rip), %rdi     # 0x25868
testq %rdi, %rdi
je 0x141e8
movl 0xc0(%rax), %eax
cmpl $0x6, %eax
je 0x141fe
cmpl $0x5, %eax
jne 0x14217
cmpl $0x0, 0x116c8(%rip)     # 0x25878
jle 0x14217
xorl %ebx, %ebx
movq 0x116fd(%rip), %rax     # 0x258b8
movq 0x10(%rax), %rdi
movl 0x116ab(%rip), %esi     # 0x25870
callq 0xf9cd
incl %ebx
cmpl 0x116a6(%rip), %ebx     # 0x25878
jl 0x141b4
jmp 0x14217
movq 0x1163b(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1d, %edi
jmp 0x141f8
movq 0x11629(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x19, %edi
popq %rbx
jmp 0xd1a9
movl 0x11688(%rip), %esi     # 0x2588c
movl 0x1166a(%rip), %edx     # 0x25874
xorl %ecx, %ecx
subl 0x11666(%rip), %ecx     # 0x25878
callq 0x13ff4
xorl %eax, %eax
movq %rax, 0x11648(%rip)     # 0x25868
movq %rax, 0x11691(%rip)     # 0x258b8
jmp 0x14149
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
callq 0x1476d
cmpl $0x0, 0x11086(%rip)     # 0x25778
jne 0x14768
movq 0x111bd(%rip), %r14     # 0x258b8
movl 0x111bf(%rip), %ebx     # 0x258c0
movl 0x111bd(%rip), %ebp     # 0x258c4
callq 0x1476d
cmpl $0x0, 0x11065(%rip)     # 0x25778
jne 0x14768
testq %r14, %r14
sete %cl
movq 0x11196(%rip), %rax     # 0x258b8
testq %rax, %rax
sete %dl
orb %cl, %dl
movq %r14, %rcx
orq %rax, %rcx
sete %cl
testb %dl, %dl
jne 0x14758
movq 0x10(%r14), %rcx
cmpq 0x10(%rax), %rcx
sete %al
cmpl 0x1117c(%rip), %ebp     # 0x258c4
sete %dl
cmpl 0x1116f(%rip), %ebx     # 0x258c0
sete %cl
andb %dl, %cl
andb %al, %cl
movb %cl, 0x1106a(%rip)      # 0x257c8
movl $0x0, 0x110d0(%rip)     # 0x25838
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14816
movl 0x11092(%rip), %eax     # 0x25838
cmpl $-0x1, %eax
je 0x14816
cmpl $0x7, %eax
je 0x1480b
movq 0x11061(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x22, %edi
popq %rbx
popq %r14
popq %r15
jmp 0xd1a9
movl $0x0, 0x10fa4(%rip)     # 0x25778
movq 0x1103d(%rip), %r15     # 0x25818
movq %rbx, 0x11036(%rip)     # 0x25818
movslq (%rbx), %rax
movq %r14, 0x1102c(%rip)     # 0x25818
leaq 0x1010d(%rip), %rcx     # 0x24900
callq *(%rcx,%rax,8)
cmpq 0x1101b(%rip), %r15     # 0x25818
je 0x1480b
movl $0x1a, 0x10f6f(%rip)    # 0x25778
jmp 0x14816
movq $0x0, 0x110a2(%rip) # 0x258b8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10a77
cmpl $0x0, 0x10ec2(%rip)     # 0x25778
je 0x148c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x10f08(%rip), %xmm0    # 0x257d0
movsd %xmm0, (%rsp)
movl $0x3, %edi
callq 0x10a77
movl %ebx, 0x10f5b(%rip)     # 0x25838
movsd (%rsp), %xmm0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/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 0x1002c
cmpl $0x0, 0x10b1a(%rip)     # 0x25778
jne 0x14c81
cmpb $0x0, 0x10b61(%rip)     # 0x257c8
setne %bl
callq 0x1002c
cmpb $0x0, 0x10b52(%rip)     # 0x257c8
setne %al
andb %bl, %al
movb %al, 0x10b47(%rip)      # 0x257c8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x108d1(%rip), %eax     # 0x25838
cmpl $0x5, %eax
jne 0x14f7d
movq 0x108ed(%rip), %r14     # 0x25860
testq %r14, %r14
je 0x14fba
movl (%r14), %esi
jmp 0x14fbc
cmpl $0x7, %eax
je 0x14f8b
cmpl $-0x1, %eax
jne 0x15041
cmpl $-0x1, %eax
sete %dl
movq 0x10920(%rip), %rcx     # 0x258b8
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1500d
movq 0x10(%rcx), %rax
cmpl $0x5, 0xc4(%rax)
je 0x14f6c
jmp 0x15062
xorl %esi, %esi
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
je 0x14fe1
movq 0x1083f(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
jmp 0x15051
testq %r14, %r14
je 0x14ffe
movl (%r14), %r8d
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x8821
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x151be
testq %rcx, %rcx
sete %dl
movq 0x1084e(%rip), %rcx     # 0x25868
testq %rcx, %rcx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1505d
movq %rcx, %rax
addq $0x20, %rax
xorl %r14d, %r14d
cmpl $0x5, 0x14(%rcx)
cmoveq %rax, %r14
jmp 0x14f73
movq 0x107d0(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x23, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd1a9
cmpl $-0x1, %eax
je 0x1506a
xorl %r14d, %r14d
jmp 0x14f73
movq 0x107a7(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1a, %edi
jmp 0x15051
// File: /workspace/github_c_makefile_star2_O1/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 0x10185
cmpl $0x0, 0x106ba(%rip)     # 0x25778
jne 0x151b3
leaq 0x8(%rsp), %rdi
callq 0x14f5a
cmpl $0x0, 0x106a3(%rip)     # 0x25778
jne 0x151b3
callq 0x10185
cmpl $0x0, 0x10691(%rip)     # 0x25778
je 0x150f8
leaq 0x8(%rsp), %rdi
callq 0x1507c
jmp 0x151b3
leaq 0x28(%rsp), %rdi
callq 0x14f5a
cmpl $0x0, 0x1066f(%rip)     # 0x25778
jne 0x151b3
leaq 0x106e2(%rip), %rbx     # 0x257f8
movq %rbx, %rdi
callq 0x1507c
movl 0x28(%rsp), %esi
addl 0x8(%rsp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8b7e
testl %eax, %eax
je 0x1515a
movl %eax, %ebp
leaq 0x106bb(%rip), %rdi     # 0x257f8
xorl %esi, %esi
xorl %edx, %edx
callq 0x8b7e
movq 0x106cb(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %ebp, %edi
callq 0xd1a9
jmp 0x15198
leaq 0x8(%rsp), %r14
movl (%r14), %r8d
leaq 0x1068f(%rip), %r15     # 0x257f8
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x8821
movl (%r14), %ecx
incl %ecx
leaq 0x28(%rsp), %rdi
movl (%rdi), %r8d
movl $0x1, %esi
movq %r15, %rdx
callq 0x8821
movl $0x5, 0x10696(%rip)     # 0x25838
movq %rbx, 0x106b7(%rip)     # 0x25860
movl $0x1, 0x107a1(%rip)     # 0x25954
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x10673(%rip) # 0x25868
movups 0x106f4(%rip), %xmm0    # 0x258f0
movups %xmm0, 0x106b5(%rip)    # 0x258b8
movq 0x106f6(%rip), %rax     # 0x25900
movq %rax, 0x106b7(%rip)     # 0x258c8
movl $0xffffffff, 0x1061d(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x10695(%rip)     # 0x258b8
je 0x1523c
movq 0x106c4(%rip), %rax     # 0x258f0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x10624(%rip)     # 0x25860
movl $0x1, 0x1070e(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x10616(%rip) # 0x25868
movups 0x10647(%rip), %xmm0    # 0x258a0
movups %xmm0, 0x10658(%rip)    # 0x258b8
movq 0x10649(%rip), %rax     # 0x258b0
movq %rax, 0x1065a(%rip)     # 0x258c8
movl $0xffffffff, 0x105c0(%rip) # imm = 0xFFFFFFFF
movq 0x10621(%rip), %rax     # 0x258a0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x105d1(%rip)     # 0x25860
movl $0x1, 0x106bb(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x105c3(%rip) # 0x25868
movups 0x10674(%rip), %xmm0    # 0x25920
movups %xmm0, 0x10605(%rip)    # 0x258b8
movq 0x10676(%rip), %rax     # 0x25930
movq %rax, 0x10607(%rip)     # 0x258c8
movl $0xffffffff, 0x1056d(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x105e5(%rip)     # 0x258b8
je 0x152ec
movq 0x10644(%rip), %rax     # 0x25920
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x10574(%rip)     # 0x25860
movl $0x1, 0x1065e(%rip)     # 0x25954
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x105d2(%rip), %rdi     # 0x258d0
movq 0x10513(%rip), %r8      # 0x25818
leaq -0x4(%r8), %rax
movq %rax, 0x10508(%rip)     # 0x25818
movups 0x10589(%rip), %xmm0    # 0x258a0
movups %xmm0, 0x1059a(%rip)    # 0x258b8
movq 0x1058b(%rip), %rax     # 0x258b0
movq %rax, 0x1059c(%rip)     # 0x258c8
movl 0x1058e(%rip), %ecx     # 0x258c0
movl 0x1058c(%rip), %esi     # 0x258c4
movq 0x18(%rdi), %r9
movl 0x28(%rdi), %r10d
testl %r10d, %r10d
je 0x15366
subl 0x18(%r9), %ecx
movl %ecx, %eax
cltd
idivl %r10d
movl %eax, %ecx
movl %eax, 0x10569(%rip)     # 0x258c0
cmpl $0x2, %esi
jl 0x15386
movl %esi, %eax
cltd
idivl %r10d
movl %eax, %esi
jmp 0x15380
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x15386
movl 0x18(%r9), %ecx
movl %ecx, 0x10547(%rip)     # 0x258c0
movq 0x18(%rax), %rax
movl 0x1c(%rax), %esi
movl %esi, 0x1053e(%rip)     # 0x258c4
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x153d4
movq %r8, 0x10482(%rip)      # 0x25818
cmpl $0x2b, (%r8)
leaq 0x4(%r8), %r8
je 0x15338
movq %r9, 0x10511(%rip)      # 0x258b8
movq 0x18(%rdi), %rax
movq %rax, 0x10506(%rip)     # 0x258b8
movb $0x0, 0x1050f(%rip)     # 0x258c8
movl $0xffffffff, 0x10475(%rip) # imm = 0xFFFFFFFF
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x1048d(%rip)     # 0x25860
retq
movq %r9, 0x104dd(%rip)      # 0x258b8
movq 0x10436(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x21, %edi
jmp 0xd1a9
// File: /workspace/github_c_makefile_star2_O1/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 0x10a77
cmpl $0x0, 0x1032d(%rip)     # 0x25778
je 0x1544f
popq %rbx
retq
movl 0x10377(%rip), %ebx     # 0x257cc
testl %ebx, %ebx
js 0x15492
callq 0x10185
cmpl $0x0, 0x10313(%rip)     # 0x25778
jne 0x1544d
leaq 0x103d2(%rip), %rdi     # 0x25840
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x84af
testl %eax, %eax
je 0x154a8
movq 0x1038e(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
jmp 0x154a2
movq 0x1037f(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1e, %edi
popq %rbx
jmp 0xd1a9
leaq 0x10391(%rip), %rdi     # 0x25840
movl $0x1, %esi
callq 0x911c
movl %ebx, (%rax)
jmp 0x1544d
// File: /workspace/github_c_makefile_star2_O1/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, 0x102a1(%rip)     # 0x25838
movq 0x1027a(%rip), %rax     # 0x25818
movl (%rax), %esi
leaq 0x10231(%rip), %rbx     # 0x257d8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8b7e
movq 0x10260(%rip), %rcx     # 0x25818
addq $0x4, %rcx
movq %rcx, 0x10255(%rip)     # 0x25818
movl 0x1020f(%rip), %edx     # 0x257d8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8f0d
cvtsi2sdl 0x101fa(%rip), %xmm0 # 0x257d8
mulsd 0x5a32(%rip), %xmm0     # 0x1b018
callq 0x8070
cvttsd2si %xmm0, %eax
cltq
shlq $0x2, %rax
addq %rax, 0x1021c(%rip)     # 0x25818
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x101f2(%rip), %rbx     # 0x257f8
movq %rbx, %rdi
callq 0x1507c
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8b7e
testl %eax, %eax
je 0x15634
movq 0x101f0(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl %eax, %edi
popq %rbx
jmp 0xd1a9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x911c
movl 0x10321(%rip), %ecx     # 0x25968
movl %ecx, (%rax)
movq 0x10320(%rip), %rcx     # 0x25970
movq %rcx, 0x8(%rax)
movq 0x101bd(%rip), %rcx     # 0x25818
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rbx, %rdi
callq 0x151be
xorl %edi, %edi
callq 0x1569b
addq $0x4, 0x1019a(%rip)     # 0x25818
movl $0x5, 0x101b0(%rip)     # 0x25838
movq %rbx, 0x101d1(%rip)     # 0x25860
movl $0x1, 0x102bb(%rip)     # 0x25954
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf258(%rip), %r14      # 0x24900
movq 0x10169(%rip), %rcx     # 0x25818
movslq (%rcx), %rax
testq %rax, %rax
je 0x156e8
cmpl $0x4, %eax
sete %dl
testl %ebx, %ebx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x156d0
decl %ebx
je 0x156e8
addq $0x4, %rcx
movq %rcx, 0x1013d(%rip)     # 0x25818
callq *(%r14,%rax,8)
cmpl $0x0, 0x10092(%rip)     # 0x25778
je 0x156a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/heltilda[P]cicada/bytecd.c
// Function: numAdapter
void numAdapter(ccInt numType)
{
    variable *theVariable;
    void(*loadNum)(variable *, ccInt);
    
    pcCodePtr--;
    callBytecodeFunction();        // read in an argument
    if (errCode != passed)  return;
    
    if ((GL_Object.type != var_type) || (searchView.windowPtr == NULL))
        {  setError(not_a_variable_err, pcCodePtr-1);  return;  }
    
    if (searchView.width != 1)  {  setError(multiple_indices_not_allowed_err, pcCodePtr-1);  return;  }
    theVariable = searchView.windowPtr->variable_ptr;
    if ((theVariable->type < char_type) || (theVariable->type > double_type))
        {  setError(not_a_number_err, pcCodePtr-1);  return;  }    // must be numeric
    
    if (numType == int_type)  loadNum = &loadIntRegister;
    else if (numType == double_type)  loadNum = &loadDoubleRegister;
    else if (theVariable->type == double_type)  loadNum = &loadDoubleRegister;
    else  loadNum = &loadIntRegister;
    
    loadNum(searchView.windowPtr->variable_ptr, searchView.offset);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x100ff(%rip), %rax     # 0x25818
leaq -0x4(%rax), %rcx
movq %rcx, 0x100f4(%rip)     # 0x25818
movslq -0x4(%rax), %rcx
movq %rax, 0x100e9(%rip)     # 0x25818
leaq 0xee2a(%rip), %rax      # 0x24560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x10038(%rip)     # 0x25778
je 0x15744
popq %rbx
retq
cmpl $-0x1, 0x100ed(%rip)    # 0x25838
setne %cl
movq 0x10163(%rip), %rax     # 0x258b8
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x15774
movq 0x100af(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x22, %edi
jmp 0x157b1
cmpl $0x1, 0x10149(%rip)     # 0x258c4
jne 0x157a1
movq 0x10(%rax), %rdi
movl 0xc0(%rdi), %eax
leal -0x4(%rax), %ecx
cmpl $-0x4, %ecx
ja 0x157b7
movq 0x10082(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x29, %edi
jmp 0x157b1
movq 0x10070(%rip), %rsi     # 0x25818
addq $-0x4, %rsi
movl $0x1f, %edi
popq %rbx
jmp 0xd1a9
cmpl $0x2, %ebx
je 0x157ca
cmpl $0x3, %ebx
jne 0x157d3
leaq 0x5a(%rip), %rax        # 0x15822
jmp 0x157e8
leaq 0x2a(%rip), %rax        # 0x157fb
jmp 0x157e8
cmpl $0x3, %eax
leaq 0x45(%rip), %rcx        # 0x15822
leaq 0x17(%rip), %rax        # 0x157fb
cmoveq %rcx, %rax
movl 0x100d2(%rip), %esi     # 0x258c0
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/heltilda[P]cicada/bytecd.c
// Function: checkBytecodeSentences
void checkBytecodeSentences()
{
    ccInt rtrn;
    
    while (*pcCodePtr != end_of_script)   {
        
        
            // keep track of our sentence beginnings for checkBytecode()
            
        rtrn = addElements(&sentenceList, 1, ccFalse);
        if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
        *(ccInt **) findElement(&sentenceList, sentenceList.elementNum) = pcCodePtr;
        
        
            // run each outermost command
        
        checkBytecodeArg(start_arg);
        if (errCode != passed)  break;         }
        
        
        // add the null terminator as a valid jump point
    
    rtrn = addElements(&sentenceList, 1, ccFalse);
    if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
    *(ccInt **) findElement(&sentenceList, sentenceList.elementNum) = pcCodePtr;
    
    if (errCode == passed)  pcCodePtr++;   // get past the null terminator
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xfcd3(%rip), %rbx      # 0x259c8
movq 0xfb1c(%rip), %rax      # 0x25818
cmpl $0x0, (%rax)
je 0x15d3c
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8b6a
movq 0xfb01(%rip), %r14      # 0x25818
testl %eax, %eax
jne 0x15d64
movl 0xfca7(%rip), %esi      # 0x259c8
movq %rbx, %rdi
callq 0x90da
movq %r14, (%rax)
xorl %edi, %edi
callq 0x15da6
cmpl $0x0, 0xfa3e(%rip)      # 0x25778
je 0x15cf5
leaq 0xfc85(%rip), %rdi      # 0x259c8
movl $0x1, %esi
xorl %edx, %edx
callq 0x8b6a
movq 0xfac2(%rip), %rbx      # 0x25818
testl %eax, %eax
je 0x15d78
movl $0x1, %edi
movq %rbx, %rsi
jmp 0x15d6c
movl $0x1, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd1a9
movl 0xfc4a(%rip), %esi      # 0x259c8
leaq 0xfc43(%rip), %rdi      # 0x259c8
callq 0x90da
movq %rbx, (%rax)
cmpl $0x0, 0xf9e4(%rip)      # 0x25778
jne 0x15d9e
addq $0x4, 0xfa7a(%rip)      # 0x25818
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/heltilda[P]cicada/bytecd.c
// Function: checkBytecodeArg
void checkBytecodeArg(ccInt tableID)     // runs a bytecode function via the check jump tables
{
    ccInt theCommand = *pcCodePtr;
    
    if ((theCommand < 0) || (theCommand >= commands_num))  {  setError(illegal_command_err, pcCodePtr);  return;  }
    
    pcCodePtr++;
    if (pcCodePtr >= endCodePtr)  {  pcCodePtr = endCodePtr;  setError(code_overflow_err, pcCodePtr);  return;  }
    
    checkJumpTables[tableID][theCommand](theCommand);
}

// Assembly:
movl %edi, %eax
movq 0xfa69(%rip), %rsi      # 0x25818
movl (%rsi), %edi
cmpq $0x3a, %rdi
jb 0x15dc1
movl $0x12, %edi
jmp 0xd1a9
addq $0x4, %rsi
movq %rsi, 0xfa4c(%rip)      # 0x25818
movq 0xfa55(%rip), %rcx      # 0x25828
cmpq %rcx, %rsi
jae 0x15dee
cltq
imulq $0x1d0, %rax, %rax      # imm = 0x1D0
leaq 0xdac8(%rip), %rcx      # 0x238b0
addq %rax, %rcx
jmpq *(%rcx,%rdi,8)
movq %rcx, 0xfa23(%rip)      # 0x25818
movl $0x13, %edi
movq %rcx, %rsi
jmp 0xd1a9