// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x18571(%rip), %rax     # 0x2c8e0
movq %rax, -0x18(%rbp)
movq 0x1856e(%rip), %rax     # 0x2c8e8
movq %rax, -0x10(%rbp)
movq 0x1856b(%rip), %rax     # 0x2c8f0
movq %rax, -0x8(%rbp)
movb $0x0, -0x65(%rbp)
callq 0x14300
cmpl $0x0, 0x183cf(%rip)     # 0x2c768
je 0x143a0
jmp 0x146e9
movq 0x18501(%rip), %rax     # 0x2c8a8
movq %rax, -0x30(%rbp)
movq 0x184fe(%rip), %rax     # 0x2c8b0
movq %rax, -0x28(%rbp)
movq 0x184fb(%rip), %rax     # 0x2c8b8
movq %rax, -0x20(%rbp)
movl 0x1857d(%rip), %eax     # 0x2c944
movl %eax, -0x60(%rbp)
movq $0x0, -0x48(%rbp)
movq 0x18477(%rip), %rax     # 0x2c850
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x143e9
jmp 0x146e9
movq -0x58(%rbp), %rax
cmpl $0x1, (%rax)
jg 0x14409
leaq 0x18357(%rip), %rax     # 0x2c750
addq $0x98, %rax
cmpq %rax, -0x58(%rbp)
jne 0x144c4
movq 0x18440(%rip), %rax     # 0x2c850
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
movl $0x20, %edx
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8460
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x14444
movq 0x183d3(%rip), %rsi     # 0x2c808
movl $0x1, %edi
callq 0xf740
jmp 0x146e9
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x1, -0x65(%rbp)
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x144c2
movq 0x183e7(%rip), %rdi     # 0x2c850
movl -0x5c(%rbp), %esi
callq 0x9700
movq %rax, -0x70(%rbp)
movl -0x5c(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x9700
movq -0x70(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x5c(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x9700
movq %rax, %rdi
callq 0x12c80
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x14457
jmp 0x144c4
callq 0x146f0
cmpl $0x0, 0x18298(%rip)     # 0x2c768
je 0x14517
cmpb $0x0, -0x65(%rbp)
je 0x14512
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x14509
movl -0x5c(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x9700
movq %rax, %rdi
callq 0x12c40
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x144df
leaq -0x50(%rbp), %rdi
callq 0x8540
jmp 0x146e9
movq 0x183c2(%rip), %rax     # 0x2c8e0
movq %rax, -0x18(%rbp)
movq 0x183bf(%rip), %rax     # 0x2c8e8
movq %rax, -0x10(%rbp)
movq 0x183bc(%rip), %rax     # 0x2c8f0
movq %rax, -0x8(%rbp)
movq 0x18369(%rip), %rax     # 0x2c8a8
movq %rax, 0x1839a(%rip)     # 0x2c8e0
movq 0x18363(%rip), %rax     # 0x2c8b0
movq %rax, 0x18394(%rip)     # 0x2c8e8
movq 0x1835d(%rip), %rax     # 0x2c8b8
movq %rax, 0x1838e(%rip)     # 0x2c8f0
movq 0x18377(%rip), %rdi     # 0x2c8e0
callq 0xf780
movq $0x0, 0x1837f(%rip) # 0x2c8f8
cmpl $-0x1, 0x182a8(%rip)    # 0x2c828
jne 0x145eb
cmpq $0x0, -0x30(%rbp)
je 0x145eb
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x145e9
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x145e7
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x9700
movq %rax, %rdi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x60(%rbp), %r8d
movl $0x1, %esi
callq 0x14710
cmpl $0x0, 0x18192(%rip)     # 0x2c768
je 0x145da
jmp 0x145e7
jmp 0x145dc
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x145a1
jmp 0x145e9
jmp 0x145eb
cmpb $0x0, -0x65(%rbp)
je 0x1462b
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x58(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x14622
movl -0x5c(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0x9700
movq %rax, %rdi
callq 0x12c40
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x145f8
leaq -0x50(%rbp), %rdi
callq 0x8540
cmpl $0x32, 0x18136(%rip)    # 0x2c768
jne 0x1463e
movl $0x0, 0x1812a(%rip)     # 0x2c768
cmpl $0x0, 0x18123(%rip)     # 0x2c768
jne 0x1469f
movq 0x182aa(%rip), %rax     # 0x2c8f8
movq %rax, 0x18253(%rip)     # 0x2c8a8
movq 0x182a4(%rip), %rax     # 0x2c900
movq %rax, 0x1824d(%rip)     # 0x2c8b0
movq 0x1829e(%rip), %rax     # 0x2c908
movq %rax, 0x18247(%rip)     # 0x2c8b8
movl $0xffffffff, 0x181ad(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x18225(%rip)     # 0x2c8a8
je 0x1469d
movq 0x1821c(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
addq $0xd0, %rax
movq %rax, 0x181b3(%rip)     # 0x2c850
jmp 0x1469f
movq $0x0, 0x181ae(%rip) # 0x2c858
leaq 0x1809f(%rip), %rdi     # 0x2c750
addq $0x190, %rdi            # imm = 0x190
callq 0xf7d0
movq -0x18(%rbp), %rax
movq %rax, 0x18218(%rip)     # 0x2c8e0
movq -0x10(%rbp), %rax
movq %rax, 0x18215(%rip)     # 0x2c8e8
movq -0x8(%rbp), %rax
movq %rax, 0x18212(%rip)     # 0x2c8f0
movq $0x0, 0x1820f(%rip) # 0x2c8f8
addq $0x70, %rsp
popq %rbp
retq
nop