// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/bytecd.c
// Function: if_eq
void _if_eq()
{
    view firstArgView;
    ccInt firstDataType, secondDataType, intRegisterBackup = 0, rtrn;
    ccFloat doubleRegisterBackup = 0.;
    member fauxMember;
    window fauxStringWindow1, fauxStringWindow2, *windowToDeref = NULL;
    variable fauxStringVariable1, fauxStringVariable2;
    ccBool boolRegisterBackup1, boolRegisterBackup2, firstArgIsScalar, secondArgIsScalar;
    void *toCompare1 = NULL, *toCompare2 = NULL;
    
    
        // get the first argument
    
    copyCompareReadArg(callBytecodeFunction, &firstDataType, &firstArgIsScalar);
    if (errCode != passed)  return;
    
    if (firstArgIsScalar)  {
        firstArgView.multipleIndices = ccFalse;
        if (firstDataType == int_type)  {  intRegisterBackup = intRegister;  toCompare1 = &intRegisterBackup;  }
        else if (firstDataType == char_type)  {  boolRegisterBackup1 = (ccBool) intRegister;  toCompare1 = &boolRegisterBackup1;  }
        else if (firstDataType == double_type)  {  doubleRegisterBackup = doubleRegister;  toCompare1 = &doubleRegisterBackup;  }
        else if (firstDataType == bool_type)  {  boolRegisterBackup1 = boolRegister;  toCompare1 = &boolRegisterBackup1;  }
        else if (firstDataType == string_type)  {
            fauxStringWindow1.variable_ptr = &fauxStringVariable1;
            fauxStringWindow1.offset = 0;
            fauxStringWindow1.width = stringRegister.elementNum;
            
            firstArgView = searchView;
            refWindow(firstArgView.windowPtr);
            windowToDeref = firstArgView.windowPtr;
            
            rtrn = newLinkedList(&(fauxStringVariable1.mem.data), stringRegister.elementNum, 1, 0., ccFalse);
            if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
            copyElements(&stringRegister, 1, &(fauxStringVariable1.mem.data), 1, stringRegister.elementNum);
            toCompare1 = &fauxStringWindow1;
    }   }
    
    else  {
        firstArgView = searchView;
        if (firstArgView.windowPtr == NULL)  firstDataType = no_type;
        else  {
            refWindow(firstArgView.windowPtr);
            windowToDeref = firstArgView.windowPtr;
    }   }
    
    copyCompareReadArg(callBytecodeFunction, &secondDataType, &secondArgIsScalar);
    if (errCode == passed)  {
        
        if (secondArgIsScalar)  {
            searchView.multipleIndices = ccFalse;
            if (secondDataType == int_type)  toCompare2 = &intRegister;
            else if (secondDataType == char_type)  {  boolRegisterBackup2 = (ccBool) intRegister;  toCompare2 = &boolRegisterBackup2;  }
            else if (secondDataType == double_type)  toCompare2 = &doubleRegister;
            else if (secondDataType == bool_type)  {  boolRegisterBackup2 = boolRegister;  toCompare2 = &boolRegisterBackup2;  }
            else if (secondDataType == string_type)  {
                fauxStringWindow2.variable_ptr = &fauxStringVariable2;
                fauxStringWindow2.offset = 0;
                fauxStringWindow2.width = stringRegister.elementNum;
                fauxStringVariable2.mem.data = stringRegister;
                toCompare2 = &fauxStringWindow2;
        }   }
        
        boolRegister = ccTrue;      // the comparison functions only set falses upon finding a mismatch
        if (firstArgIsScalar)  {
            if ((secondDataType == var_type) || (secondDataType == no_type)) setError(type_mismatch_err, pcCodePtr-1);
            else if (secondArgIsScalar)  {
                if (secondDataType == string_type)  {  fauxMember.memberWindow = &fauxStringWindow2;  toCompare2 = &fauxMember;  }
                compareJumpTable[5*firstDataType + secondDataType](toCompare1, toCompare2);     }
            else if ((firstDataType == string_type) && (secondDataType == char_type))
                copyCompareMultiView(compareWindowData, &searchView, &firstArgView);
            else  copyCompareListToVar(toCompare1, firstDataType, &searchView, compareJumpTable);   }
        else if (firstDataType == no_type)  {
            if (secondDataType == no_type)  boolRegister = ccTrue;
            else  setError(type_mismatch_err, pcCodePtr-1);   }
        else  {
            if ((firstDataType != var_type) && (secondArgIsScalar))  {
                if ((firstDataType == char_type) && (secondDataType == string_type))
                    copyCompareMultiView(compareWindowData, &searchView, &firstArgView);
                else  copyCompareListToVar(toCompare2, secondDataType, &firstArgView, compareJumpTable);  }
            else if ( ((firstDataType == var_type) || (firstArgView.multipleIndices))
                            == ((secondDataType == var_type) || (searchView.multipleIndices)) )
                copyCompareMultiView(compareWindowData, &searchView, &firstArgView);
            else  setError(type_mismatch_err, pcCodePtr-1);
    }   }
    
    if ((firstArgIsScalar) && (firstDataType == string_type))  deleteLinkedList(&(fauxStringVariable1.mem.data));
    derefWindow(&windowToDeref);
    
    GL_Object.type = bool_type;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2d0, %rsp            # imm = 0x2D0
andl $0x0, 0x3c(%rsp)
andq $0x0, 0x40(%rsp)
andq $0x0, 0x30(%rsp)
leaq -0x32b3(%rip), %rdi     # 0xf64e
leaq 0x8(%rsp), %rsi
leaq 0x6(%rsp), %rdx
callq 0x10e48
cmpl $0x0, 0x11e61(%rip)     # 0x24778
jne 0x12c5a
movb 0x6(%rsp), %bpl
testb %bpl, %bpl
je 0x12956
movb $0x0, 0x20(%rsp)
movl 0x8(%rsp), %eax
cmpq $0x4, %rax
ja 0x1298f
leaq 0x73cf(%rip), %rcx      # 0x19d0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x48(%rsp), %rbx
jmpq *%rax
movb 0x11e77(%rip), %al      # 0x247c8
jmp 0x12a41
movups 0x11f5b(%rip), %xmm0    # 0x248b8
movaps %xmm0, 0x10(%rsp)
movq 0x11f5f(%rip), %rax     # 0x248c8
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x12987
movq %rbx, %rdi
callq 0xc7e1
movq %rbx, 0x30(%rsp)
jmp 0x1298f
movl $0x7, 0x8(%rsp)
xorl %ebx, %ebx
jmp 0x12a45
leaq 0x1d8(%rsp), %rax
movq %rax, 0x58(%rsp)
andl $0x0, 0x60(%rsp)
movl 0x11e2a(%rip), %eax     # 0x247d8
movl %eax, 0x64(%rsp)
movups 0x11eff(%rip), %xmm0    # 0x248b8
movaps %xmm0, 0x10(%rsp)
movq 0x11f03(%rip), %rax     # 0x248c8
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xc7e1
movq %r14, 0x30(%rsp)
leaq 0x1e8(%rsp), %r14
movl 0x11dee(%rip), %esi     # 0x247d8
pushq $0x1
popq %rdx
xorps %xmm0, %xmm0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x83d5
testl %eax, %eax
je 0x12a9d
movq 0x11e0f(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
movl %eax, %edi
callq 0xc7c2
jmp 0x12c5a
movl 0x11dad(%rip), %eax     # 0x247cc
leaq 0x3c(%rsp), %rbx
movl %eax, (%rbx)
jmp 0x12a45
movsd 0x11da0(%rip), %xmm0    # 0x247d0
leaq 0x40(%rsp), %rbx
movsd %xmm0, (%rbx)
jmp 0x12a45
movb 0x11d8b(%rip), %al      # 0x247cc
movb %al, 0x48(%rsp)
leaq -0x33fe(%rip), %rdi     # 0xf64e
leaq 0xc(%rsp), %rsi
leaq 0x7(%rsp), %rdx
callq 0x10e48
cmpl $0x0, 0x11d16(%rip)     # 0x24778
jne 0x12c30
movb 0x7(%rsp), %al
testb %al, %al
je 0x12a99
movb $0x0, 0x11e51(%rip)     # 0x248c8
movl 0xc(%rsp), %ecx
cmpq $0x4, %rcx
ja 0x12a99
leaq 0x7298(%rip), %rdx      # 0x19d20
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb 0x11d31(%rip), %cl      # 0x247c8
jmp 0x12b08
xorl %esi, %esi
jmp 0x12b12
movl 0x11d34(%rip), %r8d     # 0x247d8
leaq 0x11d2d(%rip), %rdi     # 0x247d8
pushq $0x1
popq %rcx
movl %ecx, %esi
movq %r14, %rdx
callq 0x87c7
jmp 0x12a45
leaq 0xe0(%rsp), %rcx
leaq 0x70(%rsp), %rsi
movq %rcx, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
movl 0x11d03(%rip), %edx     # 0x247d8
movl %edx, 0x1c(%rsi)
movups 0x11cf9(%rip), %xmm0    # 0x247d8
movups %xmm0, 0x10(%rcx)
movups 0x11cfe(%rip), %xmm0    # 0x247e8
movups %xmm0, 0x20(%rcx)
jmp 0x12b12
leaq 0x11cd5(%rip), %rsi     # 0x247cc
jmp 0x12b12
leaq 0x11cd0(%rip), %rsi     # 0x247d0
jmp 0x12b12
movb 0x11cc4(%rip), %cl      # 0x247cc
leaq 0xe0(%rsp), %rsi
movb %cl, (%rsi)
movb $0x1, 0x11caf(%rip)     # 0x247c8
testb %bpl, %bpl
je 0x12b49
movslq 0xc(%rsp), %rcx
cmpq $0x7, %rcx
je 0x12b2e
cmpl $-0x1, %ecx
jne 0x12b62
movq 0x11ce3(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x11
popq %rdi
callq 0xc7c2
movb $0x1, %bpl
jmp 0x12c30
movl 0x8(%rsp), %ecx
cmpl $0x7, %ecx
jne 0x12ba2
cmpl $0x7, 0xc(%rsp)
je 0x12c2e
jmp 0x12c1b
testb %al, %al
je 0x12c66
cmpl $0x4, %ecx
jne 0x12b7f
leaq 0x70(%rsp), %rax
leaq 0x98(%rsp), %rsi
movq %rax, (%rsi)
movslq 0x8(%rsp), %rax
leaq (%rax,%rax,4), %rax
addq %rcx, %rax
leaq 0xfbce(%rip), %rcx      # 0x22760
movq %rbx, %rdi
callq *(%rcx,%rax,8)
movb 0x6(%rsp), %bpl
jmp 0x12c30
cmpl $-0x1, %ecx
sete %dl
testb %al, %al
sete %al
orb %dl, %al
jne 0x12bd9
xorl $0x1, %ecx
movl 0xc(%rsp), %eax
movl %eax, %edx
xorl $0x4, %edx
orl %ecx, %edx
je 0x12c01
leaq 0xfb98(%rip), %rcx      # 0x22760
leaq 0x10(%rsp), %rdx
movq %rsi, %rdi
movl %eax, %esi
callq 0xcb60
jmp 0x12c2e
cmpl $-0x1, %ecx
sete %al
cmpb $0x0, 0x20(%rsp)
setne %cl
orb %al, %cl
cmpl $-0x1, 0xc(%rsp)
setne %al
cmpb $0x0, 0x11cd0(%rip)     # 0x248c8
sete %dl
andb %al, %dl
cmpb %dl, %cl
je 0x12c1b
leaq -0x62bc(%rip), %rdi     # 0xc94c
leaq 0x11ca9(%rip), %rsi     # 0x248b8
leaq 0x10(%rsp), %rdx
callq 0x1119b
jmp 0x12c2e
movq 0x11bf6(%rip), %rsi     # 0x24818
addq $-0x4, %rsi
pushq $0x11
popq %rdi
callq 0xc7c2
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x12c49
cmpl $0x4, 0x8(%rsp)
jne 0x12c49
leaq 0x1e8(%rsp), %rdi
callq 0x846b
leaq 0x30(%rsp), %rdi
callq 0xc801
andl $0x0, 0x11bde(%rip)     # 0x24838
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbx
popq %r14
popq %rbp
retq
movl 0x8(%rsp), %esi
movl %esi, %eax
xorl $0x4, %eax
xorl $0x1, %ecx
orl %eax, %ecx
jne 0x12c93
leaq -0x6331(%rip), %rdi     # 0xc94c
leaq 0x11c34(%rip), %rsi     # 0x248b8
leaq 0x10(%rsp), %rdx
callq 0x1119b
jmp 0x12b41
leaq 0x11c1e(%rip), %rdx     # 0x248b8
leaq 0xfabf(%rip), %rcx      # 0x22760
movq %rbx, %rdi
callq 0xcb60
jmp 0x12b41