// File: /workspace/github_c_makefile_star2_O2/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 0xf33b
cmpl $0x0, 0x153e4(%rip)     # 0x24778
je 0xf3a5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1550c(%rip), %r12     # 0x248b8
movl 0x1550e(%rip), %eax     # 0x248c0
movl %eax, 0x4(%rsp)
andq $0x0, 0x18(%rsp)
movl 0x15501(%rip), %r14d    # 0x248c4
movl 0x1558a(%rip), %r15d    # 0x24954
movq 0x1548f(%rip), %rbx     # 0x24860
testq %rbx, %rbx
je 0xf396
movl (%rbx), %esi
cmpl $0x2, %esi
setl %al
leaq 0x1537b(%rip), %rcx     # 0x24760
addq $0x98, %rcx
cmpq %rcx, %rbx
setne %bpl
andb %al, %bpl
jne 0xf484
leaq 0x10(%rsp), %rbx
pushq $0x20
popq %rdx
xorps %xmm0, %xmm0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x83d5
testl %eax, %eax
je 0xf429
movq 0x153fc(%rip), %rsi     # 0x24818
pushq $0x1
popq %rdi
callq 0xc7c2
jmp 0xf396
movq %r12, 0x8(%rsp)
pushq $0x1
popq %r12
cmpl 0x10(%rsp), %r12d
jg 0xf47f
movq 0x15420(%rip), %rdi     # 0x24860
movl %r12d, %esi
callq 0x9088
movq %rax, %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x9088
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe54f
incl %r12d
jmp 0xf432
movq 0x8(%rsp), %r12
movq 0x1538d(%rip), %rax     # 0x24818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x1537f(%rip)     # 0x24818
leaq 0x140c0(%rip), %rax     # 0x23560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x152ce(%rip)     # 0x24778
je 0xf4db
testb %bpl, %bpl
jne 0xf396
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r14
cmpl (%rbx), %ebp
jg 0xf5a7
movq %r14, %rdi
movl %ebp, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe533
incl %ebp
jmp 0xf4bd
movq 0x1541e(%rip), %rax     # 0x24900
movq %rax, 0x40(%rsp)
movups 0x15402(%rip), %xmm0    # 0x248f0
movaps %xmm0, 0x30(%rsp)
movups 0x153be(%rip), %xmm0    # 0x248b8
movups %xmm0, 0x153ef(%rip)    # 0x248f0
movq 0x153c0(%rip), %rax     # 0x248c8
movq %rax, 0x153f1(%rip)     # 0x24900
movq 0x153da(%rip), %rdi     # 0x248f0
callq 0xc7e1
andq $0x0, 0x153e5(%rip)     # 0x24908
cmpl $-0x1, 0x1530e(%rip)    # 0x24838
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf580
movq 0x10(%r12), %rax
cmpl $0x5, 0xc0(%rax)
jne 0xf580
pushq $0x1
popq %r12
movl %r12d, %r13d
cmpl (%rbx), %r13d
jg 0xf580
movq %rbx, %rdi
movl %r13d, %esi
callq 0x9088
movq %rax, %rdi
movl %r12d, %esi
movl 0x4(%rsp), %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0xf66d
incl %r13d
cmpl $0x0, 0x151fa(%rip)     # 0x24778
je 0xf54f
testb %bpl, %bpl
jne 0xf5c0
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r14
cmpl (%rbx), %ebp
jg 0xf5b6
movq %r14, %rdi
movl %ebp, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe533
incl %ebp
jmp 0xf58d
leaq 0x10(%rsp), %rdi
callq 0x846b
jmp 0xf396
leaq 0x10(%rsp), %rdi
callq 0x846b
movl 0x151b2(%rip), %eax     # 0x24778
testl %eax, %eax
je 0xf5d6
cmpl $0x32, %eax
jne 0xf615
andl $0x0, 0x151a2(%rip)     # 0x24778
movups 0x1532b(%rip), %xmm0    # 0x24908
movups %xmm0, 0x152d4(%rip)    # 0x248b8
movq 0x1532d(%rip), %rax     # 0x24918
movq %rax, 0x152d6(%rip)     # 0x248c8
orl $-0x1, 0x1523f(%rip)    # 0x24838
movq 0x152b8(%rip), %rax     # 0x248b8
testq %rax, %rax
je 0xf615
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x1524b(%rip)     # 0x24860
andq $0x0, 0x1524b(%rip)     # 0x24868
leaq 0x152cc(%rip), %rdi     # 0x248f0
callq 0xc801
movq 0x40(%rsp), %rax
movq %rax, 0x152cb(%rip)     # 0x24900
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x152af(%rip)    # 0x248f0
andq $0x0, 0x152bf(%rip)     # 0x24908
jmp 0xf396