// File: /workspace/github_c_makefile_star2_O3/heltilda[P]cicada/bytecd.c
// Function: user_function
void _user_function()
{
    view holdArgsView = argsView, functionView;
    linkedlist backupCodeList, *theCodeList;
    ccInt counter, holdCodeNumber, rtrn;
    ccBool cleanUpCodeLL = ccFalse;
    
    
        // First determine which code marker N to skip to.  N = 0 would run the constructor.
        // In theory, N can be anything, but the compiler only generates N = 1 function calls.
    
        // get the function variable (sV.windowPtr == NULL if called in constructor mode)
    
    callCodeFunction();
    if (errCode != passed)  return;
    
    functionView = searchView;
    holdCodeNumber = codeNumber;
    
    backupCodeList.memory = NULL;       // BeginExec() will likely change GL_Object.codeList
    theCodeList = GL_Object.codeList;
    if (theCodeList == NULL)  return;
    
    
        // technical point:  make a backup of the codeRegister if that's where our code is stored, since it could be overwritten
    
    if ((theCodeList->elementNum > 1) || (theCodeList == &codeRegister))   {
        rtrn = newLinkedList(&backupCodeList, GL_Object.codeList->elementNum, sizeof(code_ref), 0., ccFalse);
        if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
        theCodeList = &backupCodeList;
        cleanUpCodeLL = ccTrue;
        
        for (counter = 1; counter <= theCodeList->elementNum; counter++)    {
            *(code_ref *) element(&backupCodeList, counter) = *(code_ref *) element(GL_Object.codeList, counter);
            refCodeRef((code_ref *) element(&backupCodeList, counter));
    }   }
    
    
        // get the function arguments
    
    callBytecodeFunction();
    if (errCode != passed)    {
        if (cleanUpCodeLL)    {
            for (counter = 1; counter <= theCodeList->elementNum; counter++)   {        // deref & delete backup code list
                derefCodeRef((code_ref *) element(&backupCodeList, counter));   }
            deleteLinkedList(&backupCodeList);   }
        return;      }
    
    holdArgsView = argsView;
    argsView = searchView;
    refWindow(argsView.windowPtr);
    
    
        // Run the function.
    
    returnView.windowPtr = NULL;
    if ((GL_Object.type == var_type) && (functionView.windowPtr != NULL))  {
    if (functionView.windowPtr->variable_ptr->type == composite_type)  {        // don't run array variables (they weren't customized)
    for (counter = 1; counter <= theCodeList->elementNum; counter++)  {
        beginExecution((code_ref *) element(theCodeList, counter), ccTrue, functionView.offset,
                                    functionView.width, holdCodeNumber);
        if (errCode != passed)  break;           // return_flag shows up in errCode
    }}}
    
    
        // deref & delete backup code list
    
    if (cleanUpCodeLL)      {
        for (counter = 1; counter <= theCodeList->elementNum; counter++)    {
            derefCodeRef((code_ref *) element(&backupCodeList, counter));     }
        deleteLinkedList(&backupCodeList);    }
    
    if (errCode == return_flag)  errCode = passed;    // a return flag is a legitimate excuse for leaving the function
    
    
        // set searchView to point to the return variable, and draw a path to it if necessary (f().q :: ...)
    
    if (errCode == passed)  {
        searchView = returnView;
        GL_Object.type = var_type;
        if (searchView.windowPtr != NULL)  {
            GL_Object.codeList = &(searchView.windowPtr->variable_ptr->codeList);
    }   }
    
    
        // restore the old args variable and clean up
    
    GL_Path.stemMember = NULL;
    
    derefWindow(&(argsView.windowPtr));
    argsView = holdArgsView;
    returnView.windowPtr = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
callq 0xff3d
cmpl $0x0, 0x157e2(%rip)     # 0x25778
je 0xffa7
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1590a(%rip), %r14     # 0x258b8
movl 0x1590b(%rip), %r13d    # 0x258c0
movl 0x15908(%rip), %r12d    # 0x258c4
movl 0x15991(%rip), %r15d    # 0x25954
movq $0x0, 0x18(%rsp)
movq 0x1588d(%rip), %rbx     # 0x25860
testq %rbx, %rbx
je 0xff98
movl (%rbx), %esi
cmpl $0x2, %esi
setl %al
leaq 0x15779(%rip), %rcx     # 0x25760
addq $0x98, %rcx
cmpq %rcx, %rbx
setne %bpl
andb %al, %bpl
je 0x1005e
movq 0x15817(%rip), %rax     # 0x25818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x15809(%rip)     # 0x25818
leaq 0x1454a(%rip), %rax     # 0x24560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x15758(%rip)     # 0x25778
je 0x10093
testb %bpl, %bpl
jne 0xff98
cmpl $0x0, (%rbx)
jle 0x1004f
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x91d8
movq %rax, %rdi
callq 0xf00c
cmpl (%rbx), %ebp
jl 0x10037
leaq 0x10(%rsp), %rdi
callq 0x847e
jmp 0xff98
leaq 0x10(%rsp), %rbx
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
je 0x10209
movq 0x15794(%rip), %rsi     # 0x25818
movl $0x1, %edi
callq 0xcfa3
jmp 0xff98
movl %r12d, 0x8(%rsp)
movq 0x15861(%rip), %rax     # 0x25900
movq %rax, 0x40(%rsp)
movups 0x15845(%rip), %xmm0    # 0x258f0
movaps %xmm0, 0x30(%rsp)
movups 0x15801(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x15832(%rip)    # 0x258f0
movq 0x15803(%rip), %rax     # 0x258c8
movq %rax, 0x15834(%rip)     # 0x25900
movq 0x1581d(%rip), %rdi     # 0x258f0
callq 0xcfc2
movq $0x0, 0x15825(%rip) # 0x25908
cmpl $-0x1, 0x1574e(%rip)    # 0x25838
sete %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x10142
movq 0x10(%r14), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x10142
cmpl $0x0, (%rbx)
jle 0x10142
xorl %r12d, %r12d
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x91d8
movq %rax, %rdi
movl $0x1, %esi
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movl %r15d, %r8d
callq 0x1029f
cmpl $0x0, 0x1563d(%rip)     # 0x25778
jne 0x10142
cmpl (%rbx), %r12d
jl 0x1010f
testb %bpl, %bpl
jne 0x10175
cmpl $0x0, (%rbx)
jle 0x1016b
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x91d8
movq %rax, %rdi
callq 0xf00c
cmpl (%rbx), %ebp
jl 0x10153
leaq 0x10(%rsp), %rdi
callq 0x847e
movl 0x155fd(%rip), %eax     # 0x25778
testl %eax, %eax
je 0x1018e
cmpl $0x32, %eax
jne 0x101d0
movl $0x0, 0x155ea(%rip)     # 0x25778
movups 0x15773(%rip), %xmm0    # 0x25908
movups %xmm0, 0x1571c(%rip)    # 0x258b8
movq 0x15775(%rip), %rax     # 0x25918
movq %rax, 0x1571e(%rip)     # 0x258c8
movl $0xffffffff, 0x15684(%rip) # imm = 0xFFFFFFFF
movq 0x156fd(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x101d0
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x15690(%rip)     # 0x25860
xorl %ebx, %ebx
movq %rbx, 0x1568f(%rip)     # 0x25868
leaq 0x15710(%rip), %rdi     # 0x258f0
callq 0xcfe2
movq 0x40(%rsp), %rax
movq %rax, 0x1570f(%rip)     # 0x25900
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x156f3(%rip)    # 0x258f0
movq %rbx, 0x15704(%rip)     # 0x25908
jmp 0xff98
cmpl $0x0, 0x10(%rsp)
jle 0xfffa
movl %r12d, 0x8(%rsp)
movl %r13d, 0xc(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbx
incl %r12d
movq 0x15630(%rip), %rdi     # 0x25860
movl %r12d, %esi
callq 0x91d8
movq %rax, %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x91d8
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x91d8
movq %rax, %rdi
callq 0xf028
cmpl 0x10(%rsp), %r12d
jl 0x10226
movl 0xc(%rsp), %r13d
movl 0x8(%rsp), %r12d
jmp 0xfffa