// File: /workspace/github_c_makefile_star2_O1/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
movq 0x15727(%rip), %rax     # 0x25900
movq %rax, 0x40(%rsp)
movups 0x1570b(%rip), %xmm0    # 0x258f0
movaps %xmm0, 0x30(%rsp)
callq 0x10185
cmpl $0x0, 0x15582(%rip)     # 0x25778
je 0x10207
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x156aa(%rip), %r14     # 0x258b8
movl 0x156ab(%rip), %r13d    # 0x258c0
movl 0x156a8(%rip), %r12d    # 0x258c4
movl 0x15731(%rip), %r15d    # 0x25954
movq $0x0, 0x18(%rsp)
movq 0x1562d(%rip), %rbx     # 0x25860
testq %rbx, %rbx
je 0x101f8
movl (%rbx), %esi
cmpl $0x2, %esi
setl %al
leaq 0x15519(%rip), %rcx     # 0x25760
addq $0x98, %rcx
cmpq %rcx, %rbx
setne %bpl
andb %al, %bpl
je 0x102be
movq 0x155b7(%rip), %rax     # 0x25818
movslq (%rax), %rcx
addq $0x4, %rax
movq %rax, 0x155a9(%rip)     # 0x25818
leaq 0x142ea(%rip), %rax     # 0x24560
callq *(%rax,%rcx,8)
cmpl $0x0, 0x154f8(%rip)     # 0x25778
je 0x102f3
testb %bpl, %bpl
jne 0x101f8
cmpl $0x0, (%rbx)
jle 0x102af
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x911c
movq %rax, %rdi
callq 0xf24c
cmpl (%rbx), %ebp
jl 0x10297
leaq 0x10(%rsp), %rdi
callq 0x847e
jmp 0x101f8
leaq 0x10(%rsp), %rbx
xorps %xmm0, %xmm0
movq %rbx, %rdi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
je 0x1046c
movq 0x15534(%rip), %rsi     # 0x25818
movl $0x1, %edi
callq 0xd1a9
jmp 0x101f8
movl %r12d, 0x8(%rsp)
movq 0x15601(%rip), %rax     # 0x25900
movq %rax, 0x40(%rsp)
movups 0x155e5(%rip), %xmm0    # 0x258f0
movaps %xmm0, 0x30(%rsp)
movups 0x155a1(%rip), %xmm0    # 0x258b8
movups %xmm0, 0x155d2(%rip)    # 0x258f0
movq 0x155a3(%rip), %rax     # 0x258c8
movq %rax, 0x155d4(%rip)     # 0x25900
movq 0x155bd(%rip), %rdi     # 0x258f0
callq 0xd1c8
movq $0x0, 0x155c5(%rip) # 0x25908
cmpl $-0x1, 0x154ee(%rip)    # 0x25838
sete %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x103a2
movq 0x10(%r14), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x103a2
cmpl $0x0, (%rbx)
jle 0x103a2
xorl %r12d, %r12d
incl %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x911c
movq %rax, %rdi
movl $0x1, %esi
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movl %r15d, %r8d
callq 0x10502
cmpl $0x0, 0x153dd(%rip)     # 0x25778
jne 0x103a2
cmpl (%rbx), %r12d
jl 0x1036f
testb %bpl, %bpl
jne 0x103d5
cmpl $0x0, (%rbx)
jle 0x103cb
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x911c
movq %rax, %rdi
callq 0xf24c
cmpl (%rbx), %ebp
jl 0x103b3
leaq 0x10(%rsp), %rdi
callq 0x847e
cmpl $0x32, 0x1539c(%rip)    # 0x25778
jne 0x103e8
movl $0x0, 0x15390(%rip)     # 0x25778
cmpl $0x0, 0x15389(%rip)     # 0x25778
jne 0x10433
movups 0x15510(%rip), %xmm0    # 0x25908
movups %xmm0, 0x154b9(%rip)    # 0x258b8
movq 0x15512(%rip), %rax     # 0x25918
movq %rax, 0x154bb(%rip)     # 0x258c8
movl $0xffffffff, 0x15421(%rip) # imm = 0xFFFFFFFF
movq 0x1549a(%rip), %rax     # 0x258b8
testq %rax, %rax
je 0x10433
movl $0xd0, %ecx
addq 0x10(%rax), %rcx
movq %rcx, 0x1542d(%rip)     # 0x25860
xorl %ebx, %ebx
movq %rbx, 0x1542c(%rip)     # 0x25868
leaq 0x154ad(%rip), %rdi     # 0x258f0
callq 0xd1e8
movq 0x40(%rsp), %rax
movq %rax, 0x154ac(%rip)     # 0x25900
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x15490(%rip)    # 0x258f0
movq %rbx, 0x154a1(%rip)     # 0x25908
jmp 0x101f8
cmpl $0x0, 0x10(%rsp)
jle 0x1025a
movl %r12d, 0x8(%rsp)
movl %r13d, 0xc(%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbx
incl %r12d
movq 0x153cd(%rip), %rdi     # 0x25860
movl %r12d, %esi
callq 0x911c
movq %rax, %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x911c
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x911c
movq %rax, %rdi
callq 0xf268
cmpl 0x10(%rsp), %r12d
jl 0x10489
movl 0xc(%rsp), %r13d
movl 0x8(%rsp), %r12d
jmp 0x1025a