// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/cmpile.c
// Function: tokenize
ccInt tokenize(compiler_type *compiler, char *charPtr, ccInt scriptType)
{
    linkedlist nextTokenStack;
    ccInt prevTokenType = 0, theTokenType = 0, tokenErrPosition = 1, prevErrPosition, rtrn;
    ccInt nextRightArgType = scriptType, lastRightArgType = scriptType, loopSkippedToken, expectedArgType;
    ccFloat theNum;
    char *tokenCharStartPtr = charPtr, *scriptStartPtr = charPtr;
    ccBool expectLHarg = ccFalse, ifFloat;
    tokenSpecType *theTokenSpec = NULL;
    
    typedef struct {
        char *name;
        ccInt tokenID;
        ccInt prevScriptToken;    } tokenStackElementType;
    
    resizeLinkedList(&(compiler->scriptTokens), 0, ccFalse);
    
    while (lettertype(charPtr) == unprintable)  charPtr++;
    
    rtrn = newLinkedList(&nextTokenStack, 0, sizeof(tokenStackElementType), 1., ccFalse);
    if (rtrn != passed)  return rtrn;
    
    while (*charPtr != 0)  {
        
        ccInt constDataSize = 0, *constData = NULL, otherTokenType = 0, varID = 0;
        ccBool isNumber = ccFalse;
        
        prevTokenType = theTokenType;
        prevErrPosition = tokenErrPosition;
        
        theTokenType = 0;
        
            // read to the end of the longest token that matches our starting point
            // theTokenType > 0 means it's a known operator; theTokenType < 0 means that it's a user-defined variable
            // if the token wasn't found, then theTokenType == 0
        
        while ((lettertype(charPtr) == a_space) || (lettertype(charPtr) == unprintable))  charPtr++;
        if (*charPtr == 0)  break;
        
        tokenCharStartPtr = charPtr;
        tokenErrPosition = (ccInt) (tokenCharStartPtr-scriptStartPtr+1);
        
        
            // if it's a numeric constant, read it and store the number
        
        if ( ((*charPtr >= '0') && (*charPtr <= '9')) || (*charPtr == '-') || (*charPtr == '.')) {
            
            rtrn = readNum(&charPtr, &theNum, &ifFloat);
            if ((rtrn == passed) || (rtrn == overflow_err) || (rtrn == underflow_err))  {
                if (rtrn != passed)  {  compilerWarning = rtrn;  errPosition = tokenErrPosition;  }
                
                isNumber = ccTrue;
                
                if (expectLHarg)  charPtr = tokenCharStartPtr;
                else  {
                    if ((!ifFloat) && (compiler->specialTokens[0] == -1))  ifFloat = ccTrue;
                    
                    if ((!ifFloat) && (compiler->specialTokens[0] > -1))  {
                        theTokenType = compiler->specialTokens[0];
                        constDataSize = 1;
                        constData = (ccInt *) malloc(constDataSize*sizeof(ccInt));
                        if (constData == NULL)  errOut(out_of_memory_err)
                        *constData = (ccInt) theNum;          }
                    
                    else if ((ifFloat) && (compiler->specialTokens[1] > -1))  {
                        theTokenType = compiler->specialTokens[1];
                        constDataSize = (ccInt) ceil(1.*sizeof(ccFloat)/sizeof(ccInt));
                        constData = (ccInt *) malloc(constDataSize*sizeof(ccInt));
                        if (constData == NULL)  errOut(out_of_memory_err)
                        *((ccFloat *) constData) = theNum;
        }   }  }    }
        
        
            // if we're reading a macro-command and it's an argument, store the arg-command and argument number
        
        else if ((*charPtr >= *arg1) && (*charPtr <= *arg9))  {
            
            theTokenType = 3;
            
            constData = (ccInt *) malloc(sizeof(ccInt));
            if (constData == NULL)  errOut(out_of_memory_err)
            *((ccInt *) constData) = (*charPtr) - (*arg1) + 1;
            constDataSize = 1;
            
            charPtr++;          }
        
        
            // otherwise we assume it's an operator and use the token tables to find out which one it is
        
        if (theTokenType == 0)  {
            
            linkedlist *theList = compiler->tokens + ((ccInt) *charPtr);
            ccInt tokenListElement, ifFound;
            tokenStringType *theTokenString = NULL;
            ccBool followingToken = ccFalse;
            
            ifFound = findToken(compiler, theList, &charPtr, &tokenListElement, ccFalse, ccTrue);
            if (ifFound)  {
                
                ccInt loopNextToken, nextTokenID = 0;
                
                theTokenString = (tokenStringType *) element(theList, tokenListElement);
                if ((theTokenString->tokenID_LHarg == 0) && (theTokenString->tokenID_noLHarg == 0))  followingToken = ccTrue;
                varID = theTokenString->varID;
                
                
                    // it might be a 'next' token we are expecting ('in' after 'for' for example)...
                    
                    // if we skipped an optional argument or two, mark their nextScriptToken fields as 0
                
                for (loopNextToken = nextTokenStack.elementNum; loopNextToken >= 1; loopNextToken--)  {
                    if ( (theTokenString->name == tokenStackElement(loopNextToken)->name) && ((nextTokenID == 0)
                                    || (tokenSpec(tokenStackElement(loopNextToken)->tokenID)->isOptional == ccFalse)) )  {
                        nextTokenID = loopNextToken;
                        for (loopSkippedToken = loopNextToken+1; loopSkippedToken <= nextTokenStack.elementNum; loopSkippedToken++)  {
                            ccInt pST = tokenStackElement(loopSkippedToken)->prevScriptToken;
                            if (pST > 0)  scriptToken(pST)->nextScriptToken = 0;
                    }   }
                    if (tokenSpec(tokenStackElement(loopNextToken)->tokenID)->isOptional == ccFalse)  break;         }
                
                if (nextTokenID != 0)  {
                    theTokenType = tokenStackElement(nextTokenID)->tokenID;
                    deleteElements(&nextTokenStack, nextTokenID, nextTokenStack.elementNum);      }
                
                
                    // otherwise, it's probably a stored token with or without a left-hand argument
                
                else if (!expectLHarg)  {
                    theTokenType = theTokenString->tokenID_noLHarg;   }
                else  {
                    theTokenType = theTokenString->tokenID_LHarg;   }
                
                if (theTokenType > 0)  theTokenSpec = tokenSpec(theTokenType);
                
                
                    // if we expect a token without, and only have a token with, a left argument,
                    // then try to fix this problem with a nothing-adapter
                    
                    // case 1:  we hit the end of a block and expect an argument (such as '(a +)' or '{x =}')
                
                if ((!expectLHarg) && (nextTokenID != 0) && (theTokenSpec->leftArgType <= (*typeXarg-*type0arg)))  {
                    
                    expectedArgType = theTokenSpec->leftArgType;
                    if (prevTokenType > 0)  {
                    if (tokenSpec(prevTokenType)->precedence > theTokenSpec->precedence)  {
                        expectedArgType = tokenSpec(prevTokenType)->rightArgType;
                    }}
                    
                    if (expectedArgType != constDataArgType)  {
                    if (compiler->adapters[10][expectedArgType] != 0)  {
                        rtrn = addScriptToken(compiler, compiler->adapters[10][expectedArgType], tokenErrPosition, NULL, 0);
                        if (rtrn != passed)  errOut(rtrn)
                }}  }
                
                    // case 2:  we aren't expecting a left-hand argument and we only have an operator that takes one (e.g. '+2')
                
                else if ((!expectLHarg) && (theTokenType == 0) && (!followingToken))  {
                    
                    otherTokenType = theTokenString->tokenID_LHarg;
                    expectedArgType = tokenSpec(otherTokenType)->leftArgType;
                    if (prevTokenType > 0)  {
                    if (tokenSpec(prevTokenType)->precedence > tokenSpec(otherTokenType)->precedence)  {
                        expectedArgType = tokenSpec(prevTokenType)->rightArgType;
                    }}
                    
                    if (expectedArgType != constDataArgType)  {
                    if (compiler->adapters[10][expectedArgType] != 0)  {
                        rtrn = addScriptToken(compiler, compiler->adapters[10][expectedArgType], tokenErrPosition, NULL, 0);
                        if (rtrn != passed)  errOut(rtrn)
                        theTokenType = otherTokenType;
                        theTokenSpec = tokenSpec(theTokenType);
                        expectLHarg = !expectLHarg;
            }   }   }}
            
            
            if (theTokenType > 0)  {
            if (theTokenSpec->nextToken != 0)  {
                rtrn = addElements(&nextTokenStack, 1, ccFalse);
                if (rtrn != passed)  errOut(rtrn)
                tokenStackElement(nextTokenStack.elementNum)->name = tokenSpec(theTokenSpec->nextToken)->name;
                tokenStackElement(nextTokenStack.elementNum)->tokenID = theTokenSpec->nextToken;
                if (theTokenSpec->tobeRemoved)  {
                    tokenStackElement(nextTokenStack.elementNum)->prevScriptToken = 0;  }
                else  {
                    tokenStackElement(nextTokenStack.elementNum)->prevScriptToken = compiler->scriptTokens.elementNum+1;
            }}  }
            
            
                // alternatively, add a new variable name if it's a word that we haven't seen before
            
            else  {
                
                if ((!ifFound) && (lettertype(tokenCharStartPtr) == a_letter) && (compiler->specialTokens[2] > -1))  {
                    
                    compiler->numVariables++;
                    varID = compiler->numVariables;
                    
                    charPtr = tokenCharStartPtr;
                    rtrn = addTokenSpec(compiler, &charPtr, NULL, compiler->specialTokens[2], ccTrue, expectLHarg, ccFalse, 0, varID);
                    if (rtrn != passed)  errOut(rtrn)
                    
                    theTokenType = compiler->specialTokens[2];
                    theTokenSpec = tokenSpec(theTokenType);             }
                
                
                    // if it's none of the above throw some sort of error
                
                else  {
                    if (isNumber)  errOut(no_left_arg_allowed_err)
                    else if (!ifFound)  errOut(unknown_command_err)
                    else if (followingToken)  errOut(unexpected_token_err)
                    
                    if ((prevTokenType > 0) && (otherTokenType != 0))  {
                    if (tokenSpec(prevTokenType)->precedence > tokenSpec(otherTokenType)->precedence)  {
                        tokenErrPosition = prevErrPosition;
                        if (expectLHarg)  errOut(no_right_arg_allowed_err)
                        else  errOut(right_arg_expected_err);           }}
                    
                    if (expectLHarg)  errOut(no_left_arg_allowed_err)
                    else  errOut(left_arg_expected_err);
        }   }   }
        
        else  theTokenSpec = tokenSpec(theTokenType);
        
        if (nextRightArgType != (*commentarg - *type0arg))  lastRightArgType = nextRightArgType;
        nextRightArgType = theTokenSpec->rightArgType;
        
        
            // if it's a variable, make room for the variable ID
        
        if (varID > 0)  {
            constDataSize = 1;
            constData = (ccInt *) malloc(constDataSize*sizeof(ccInt));
            if (constData == NULL)  errOut(out_of_memory_err)
            *((ccInt *) constData) = varID;         }
        
        
            // if it's a string constant, read in the string
        
        else if ((nextRightArgType == (ccInt) (*chararg - *type0arg)) || (nextRightArgType == (ccInt) (*stringarg - *type0arg)))  {
            
            char *closingStr = tokenSpec(theTokenSpec->nextToken)->name;
            
            rtrn = readTextString(&charPtr, closingStr, &constData, &constDataSize, nextRightArgType == (ccInt) (*chararg - *type0arg));
            if (rtrn != passed)  errOut(rtrn)        }
        
        
            // store the token if it's a known symbol, or a known variable name ending at the last allowable name character,
            // and expand constants as separate tokens (as they appear as arguments in the bytecode string)
        
        if (!theTokenSpec->tobeRemoved)  {
            rtrn = addScriptToken(compiler, theTokenType, tokenErrPosition, NULL, 0);
            if (rtrn != passed)  errOut(rtrn)
            if (constData != NULL)  {
                rtrn = addScriptToken(compiler, 1, tokenErrPosition, constData, constDataSize);
                if (rtrn != passed)  errOut(rtrn)
        }   }
        
        
            // deal with the right-hand argument of the token, if it has one;
            // if it's a comment argument, skip over it
        
        if (nextRightArgType == (ccInt) (*commentarg - *type0arg))  {
            
            char *holdCharPtr;
            tokenSpecType *LHtokenSpec = theTokenSpec;
            
            
                // if this comment is contributing to the bytecode (i.e. via its flanking arguments),
                // represent the comment literal with a blank token
            
            if (!theTokenSpec->tobeRemoved)  {
                rtrn = addScriptToken(compiler, 1, tokenErrPosition, NULL, 0);
                if (rtrn != passed)  errOut(rtrn)       }
            
            theTokenType = theTokenSpec->nextToken;
            theTokenSpec = tokenSpec(theTokenType);
            
            holdCharPtr = charPtr;
            if (theTokenType >= 0)  charPtr = strstr(charPtr, theTokenSpec->name);
            if (charPtr == NULL)  {
                charPtr = holdCharPtr;
                while (*charPtr != 0)  charPtr++;   }
            
            
                // we don't expect a left-hand argument if this comment has flanking arguments (think 'type0arg | ... \n type0arg')
            
            else if ((LHtokenSpec->leftArgType != -1) || (theTokenSpec->rightArgType != -1))  {
                expectLHarg = ccFalse;
        }   }
        
        
            // move on to the next token; don't update expectLHarg if we're passing over a comment
        
        else if (theTokenSpec->leftArgType != (ccInt) (*commentarg - *type0arg))  {
            if ((nextRightArgType == -1) || (nextRightArgType == constDataArgType))  expectLHarg = ccTrue;
            else  expectLHarg = ccFalse;        }
        
        else  nextRightArgType = lastRightArgType;                  // in case this is the last thing we read
    }
    
    lastScriptChar = (ccInt) (charPtr-scriptStartPtr+1);
    
    
        // we should not be missing an argument at the end of the code block
    
    for (loopSkippedToken = nextTokenStack.elementNum; loopSkippedToken >= 1; loopSkippedToken--)  {
    if (tokenSpec(tokenStackElement(loopSkippedToken)->tokenID)->isOptional == ccTrue)  {
        ccInt pST = tokenStackElement(loopSkippedToken)->prevScriptToken;
        if (pST > 0)  scriptToken(pST)->nextScriptToken = 0;
        deleteElement(&nextTokenStack, loopSkippedToken);
    }}
    
    if ((!expectLHarg) || (nextTokenStack.elementNum > 0))  {
        
        if (compiler->scriptTokens.elementNum == 0)  rtrn = arg_expected_err;
        else if (!expectLHarg)  rtrn = right_arg_expected_err;
        else  rtrn = token_expected_err;
        
        
            // if the last operator was a comment, look back at what the previous operator wanted
        
        if (nextRightArgType != *commentarg - *type0arg)  expectedArgType = nextRightArgType;
        else  expectedArgType = tokenSpec(prevTokenType)->rightArgType;
        
        if (expectedArgType != constDataArgType)  {
        if (compiler->adapters[10][expectedArgType] != 0)  {
            rtrn = addScriptToken(compiler, compiler->adapters[10][expectedArgType], tokenErrPosition, NULL, 0);   }}
        
        if (rtrn != passed)  {
            if (rtrn == token_expected_err)  {
                tokenErrPosition = lastScriptChar;
                expectedTokenName = tokenStackElement(nextTokenStack.elementNum)->name;        }
            errOut(rtrn)
    }   }
    
    deleteLinkedList(&nextTokenStack);
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x1, -0x4c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x81(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
xorl %edx, %edx
movl %edx, %esi
callq 0x8ee0
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1d393(%rip), %rax     # 0x29170
cmpl $0x0, (%rax,%rcx,4)
jne 0xbdf1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbdcd
leaq -0x40(%rbp), %rdi
xorl %ecx, %ecx
movl $0x10, %edx
movsd 0x16204(%rip), %xmm0    # 0x22008
movl %ecx, %esi
callq 0x8460
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xbe1f
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xbe21
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xcce3
movl $0x0, -0x94(%rbp)
movq $0x0, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movl $0x0, -0xa8(%rbp)
movb $0x0, -0xa9(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
movb $0x1, %al
leaq 0x1d2ea(%rip), %rcx     # 0x29170
cmpl $0x1, (%rcx,%rdx,4)
movb %al, -0xf5(%rbp)
je 0xbeaf
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1d2ce(%rip), %rax     # 0x29170
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0xf5(%rbp)
movb -0xf5(%rbp), %al
testb $0x1, %al
jne 0xbebb
jmp 0xbec9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbe74
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xbeda
jmp 0xcce3
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xbf0c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0xbf28
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xbf28
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xc0b5
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x82(%rbp), %rdx
callq 0xbb10
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xbf55
cmpl $0x7, -0x54(%rbp)
je 0xbf55
cmpl $0x8, -0x54(%rbp)
jne 0xc0b0
cmpl $0x0, -0x54(%rbp)
je 0xbf6d
movl -0x54(%rbp), %eax
movl %eax, 0x20338(%rip)     # 0x2c29c
movl -0x4c(%rbp), %eax
movl %eax, 0x2032b(%rip)     # 0x2c298
movb $0x1, -0xa9(%rbp)
cmpb $0x0, -0x81(%rbp)
je 0xbf8a
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc0ae
cmpb $0x0, -0x82(%rbp)
jne 0xbfa7
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1248(%rax)
jne 0xbfa7
movb $0x1, -0x82(%rbp)
cmpb $0x0, -0x82(%rbp)
jne 0xc026
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1248(%rax)
jle 0xc026
movq -0x10(%rbp), %rax
movl 0x1248(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x1, -0x94(%rbp)
movslq -0x94(%rbp), %rdi
shlq $0x2, %rdi
callq 0x81d0
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0xc013
movl -0x4c(%rbp), %eax
movl %eax, 0x2029a(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x1, -0x4(%rbp)
jmp 0xcea6
cvttsd2si -0x70(%rbp), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, (%rax)
jmp 0xc0ac
cmpb $0x0, -0x82(%rbp)
je 0xc0aa
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x124c(%rax)
jle 0xc0aa
movq -0x10(%rbp), %rax
movl 0x124c(%rax), %eax
movl %eax, -0x48(%rbp)
movsd 0x15fcf(%rip), %xmm0    # 0x22020
cvttsd2si %xmm0, %eax
movl %eax, -0x94(%rbp)
movslq -0x94(%rbp), %rdi
shlq $0x2, %rdi
callq 0x81d0
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0xc09a
movl -0x4c(%rbp), %eax
movl %eax, 0x20213(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x1, -0x4(%rbp)
jmp 0xcea6
movsd -0x70(%rbp), %xmm0
movq -0xa0(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xc0ac
jmp 0xc0ae
jmp 0xc0b0
jmp 0xc151
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x15fa9(%rip), %ecx     # 0x2206c
cmpl %ecx, %eax
jl 0xc14f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x16161(%rip), %ecx     # 0x2223a
cmpl %ecx, %eax
jg 0xc14f
movl $0x3, -0x48(%rbp)
movl $0x4, %edi
callq 0x81d0
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0xc11d
movl -0x4c(%rbp), %eax
movl %eax, 0x20190(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x1, -0x4(%rbp)
jmp 0xcea6
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movsbl 0x15f41(%rip), %eax     # 0x2206c
subl %eax, %ecx
addl $0x1, %ecx
movq -0xa0(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x94(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc151
cmpl $0x0, -0x48(%rbp)
jne 0xc97c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq $0x0, -0xc8(%rbp)
movb $0x0, -0xc9(%rbp)
movq -0x10(%rbp), %rdi
movq -0xb8(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0xbc(%rbp), %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0xcfe0
movl %eax, -0xc0(%rbp)
cmpl $0x0, -0xc0(%rbp)
je 0xc61a
movl $0x0, -0xd4(%rbp)
movq -0xb8(%rbp), %rdi
movl -0xbc(%rbp), %esi
callq 0x9700
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xc204
movq -0xc8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0xc204
movb $0x1, -0xc9(%rbp)
movq -0xc8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xa8(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xd0(%rbp)
cmpl $0x1, -0xd0(%rbp)
jl 0xc358
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movl -0xd0(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq (%rcx), %rax
jne 0xc308
cmpl $0x0, -0xd4(%rbp)
je 0xc29e
movq -0x10(%rbp), %rax
addq $0x1200, %rax           # imm = 0x1200
movq %rax, -0x108(%rbp)
movl -0xd0(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq -0x108(%rbp), %rdi
movl 0x8(%rax), %esi
callq 0x9700
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xc308
movl -0xd0(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x40(%rbp), %eax
jg 0xc306
movl -0x60(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl 0xc(%rax), %eax
movl %eax, -0xd8(%rbp)
cmpl $0x0, -0xd8(%rbp)
jle 0xc2f9
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0xd8(%rbp), %esi
callq 0x9700
movl $0x0, 0x14(%rax)
jmp 0xc2fb
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xc2b6
jmp 0xc308
movq -0x10(%rbp), %rax
addq $0x1200, %rax           # imm = 0x1200
movq %rax, -0x110(%rbp)
movl -0xd0(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq -0x110(%rbp), %rdi
movl 0x8(%rax), %esi
callq 0x9700
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xc342
jmp 0xc358
jmp 0xc344
movl -0xd0(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xd0(%rbp)
jmp 0xc21d
cmpl $0x0, -0xd4(%rbp)
je 0xc38a
movl -0xd4(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0xd4(%rbp), %esi
movl -0x40(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x8880
jmp 0xc3b1
cmpb $0x0, -0x81(%rbp)
jne 0xc3a2
movq -0xc8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0xc3af
movq -0xc8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0xc3b1
cmpl $0x0, -0x48(%rbp)
jle 0xc3d1
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x48(%rbp), %esi
callq 0x9700
movq %rax, -0x90(%rbp)
cmpb $0x0, -0x81(%rbp)
jne 0xc4c6
cmpl $0x0, -0xd4(%rbp)
je 0xc4c6
movq -0x90(%rbp), %rax
movl 0x10(%rax), %eax
movsbl 0x15c6c(%rip), %ecx     # 0x22068
movsbl 0x15c57(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jg 0xc4c6
movq -0x90(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x44(%rbp)
jle 0xc45d
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0xc(%rax), %eax
movq -0x90(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xc45b
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0x14(%rax), %eax
movl %eax, -0x64(%rbp)
jmp 0xc45d
cmpl $0x64, -0x64(%rbp)
je 0xc4c1
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
cmpl $0x0, 0x140c(%rax,%rcx,4)
je 0xc4bf
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
movl 0x140c(%rax,%rcx,4), %esi
movl -0x4c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xc4bd
movl -0x4c(%rbp), %eax
movl %eax, 0x1fdef(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xc4bf
jmp 0xc4c1
jmp 0xc618
cmpb $0x0, -0x81(%rbp)
jne 0xc616
cmpl $0x0, -0x48(%rbp)
jne 0xc616
cmpb $0x0, -0xc9(%rbp)
jne 0xc616
movq -0xc8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xa4(%rbp), %esi
callq 0x9700
movl 0x10(%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x44(%rbp)
jle 0xc577
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0xc(%rax), %eax
movl %eax, -0x114(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xa4(%rbp), %esi
callq 0x9700
movq %rax, %rcx
movl -0x114(%rbp), %eax
cmpl 0xc(%rcx), %eax
jle 0xc575
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0x14(%rax), %eax
movl %eax, -0x64(%rbp)
jmp 0xc577
cmpl $0x64, -0x64(%rbp)
je 0xc614
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
cmpl $0x0, 0x140c(%rax,%rcx,4)
je 0xc612
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
movl 0x140c(%rax,%rcx,4), %esi
movl -0x4c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xc5db
movl -0x4c(%rbp), %eax
movl %eax, 0x1fcd1(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
movl -0xa4(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x48(%rbp), %esi
callq 0x9700
movq %rax, -0x90(%rbp)
cmpb $0x0, -0x81(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x81(%rbp)
jmp 0xc614
jmp 0xc616
jmp 0xc618
jmp 0xc61a
cmpl $0x0, -0x48(%rbp)
jle 0xc71b
movq -0x90(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xc716
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xc66b
movl -0x4c(%rbp), %eax
movl %eax, 0x1fc41(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movq -0x90(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x9700
movq (%rax), %rax
movq %rax, -0x120(%rbp)
movl -0x40(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq -0x120(%rbp), %rcx
movq %rcx, (%rax)
movq -0x90(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x118(%rbp)
movl -0x40(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl -0x118(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x90(%rbp), %rax
cmpb $0x0, 0x9(%rax)
je 0xc6ec
movl -0x40(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl $0x0, 0xc(%rax)
jmp 0xc714
movq -0x10(%rbp), %rax
movl 0x1440(%rax), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
movl -0x40(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl -0x124(%rbp), %ecx
movl %ecx, 0xc(%rax)
jmp 0xc716
jmp 0xc97a
cmpl $0x0, -0xc0(%rbp)
jne 0xc816
movq -0x78(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1ca38(%rip), %rax     # 0x29170
cmpl $0x3, (%rax,%rcx,4)
jne 0xc816
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1250(%rax)
jle 0xc816
movq -0x10(%rbp), %rax
movl 0x1438(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1438(%rax)
movq -0x10(%rbp), %rax
movl 0x1438(%rax), %eax
movl %eax, -0xa8(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1250(%rax), %ecx
movb -0x81(%rbp), %r9b
movl -0xa8(%rbp), %eax
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %r8d
xorl %r10d, %r10d
movsbl %r9b, %r9d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0xb710
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xc7ea
movl -0x4c(%rbp), %eax
movl %eax, 0x1fac2(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
movq -0x10(%rbp), %rax
movl 0x1250(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x48(%rbp), %esi
callq 0x9700
movq %rax, -0x90(%rbp)
jmp 0xc978
cmpb $0x0, -0xa9(%rbp)
je 0xc83d
movl -0x4c(%rbp), %eax
movl %eax, 0x1fa70(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0xf, -0x4(%rbp)
jmp 0xcea6
cmpl $0x0, -0xc0(%rbp)
jne 0xc864
movl -0x4c(%rbp), %eax
movl %eax, 0x1fa49(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x9, -0x4(%rbp)
jmp 0xcea6
cmpb $0x0, -0xc9(%rbp)
je 0xc88b
movl -0x4c(%rbp), %eax
movl %eax, 0x1fa22(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0xa, -0x4(%rbp)
jmp 0xcea6
jmp 0xc88d
jmp 0xc88f
cmpl $0x0, -0x44(%rbp)
jle 0xc933
cmpl $0x0, -0xa4(%rbp)
je 0xc933
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0xc(%rax), %eax
movl %eax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xa4(%rbp), %esi
callq 0x9700
movq %rax, %rcx
movl -0x128(%rbp), %eax
cmpl 0xc(%rcx), %eax
jle 0xc931
movl -0x50(%rbp), %eax
movl %eax, -0x4c(%rbp)
cmpb $0x0, -0x81(%rbp)
je 0xc913
movl -0x4c(%rbp), %eax
movl %eax, 0x1f99a(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x10, -0x4(%rbp)
jmp 0xcea6
movl -0x4c(%rbp), %eax
movl %eax, 0x1f97c(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0xe, -0x4(%rbp)
jmp 0xcea6
jmp 0xc933
cmpb $0x0, -0x81(%rbp)
je 0xc95a
movl -0x4c(%rbp), %eax
movl %eax, 0x1f953(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0xf, -0x4(%rbp)
jmp 0xcea6
movl -0x4c(%rbp), %eax
movl %eax, 0x1f935(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0xd, -0x4(%rbp)
jmp 0xcea6
jmp 0xc97a
jmp 0xc996
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x48(%rbp), %esi
callq 0x9700
movq %rax, -0x90(%rbp)
movl -0x58(%rbp), %eax
movsbl 0x156c0(%rip), %ecx     # 0x22060
movsbl 0x156b3(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
je 0xc9b3
movl -0x58(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x90(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x58(%rbp)
cmpl $0x0, -0xa8(%rbp)
jle 0xca26
movl $0x1, -0x94(%rbp)
movslq -0x94(%rbp), %rdi
shlq $0x2, %rdi
callq 0x81d0
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0xca12
movl -0x4c(%rbp), %eax
movl %eax, 0x1f89b(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x1, -0x4(%rbp)
jmp 0xcea6
movl -0xa8(%rbp), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, (%rax)
jmp 0xcae2
movl -0x58(%rbp), %eax
movsbl 0x15620(%rip), %ecx     # 0x22050
movsbl 0x15623(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
je 0xca58
movl -0x58(%rbp), %eax
movsbl 0x15615(%rip), %ecx     # 0x2205c
movsbl 0x1560c(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xcae0
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movq -0x90(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x9700
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rsi
movl -0x58(%rbp), %eax
movsbl 0x155c3(%rip), %ecx     # 0x22050
movsbl 0x155c6(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
leaq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq -0x94(%rbp), %rcx
movsbl %al, %r8d
callq 0xd610
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xcade
movl -0x4c(%rbp), %eax
movl %eax, 0x1f7ce(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xcae0
jmp 0xcae2
movq -0x90(%rbp), %rax
cmpb $0x0, 0x9(%rax)
jne 0xcb82
movq -0x10(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x4c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xcb2f
movl -0x4c(%rbp), %eax
movl %eax, 0x1f77d(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
cmpq $0x0, -0xa0(%rbp)
je 0xcb80
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %edx
movq -0xa0(%rbp), %rcx
movl -0x94(%rbp), %r8d
movl $0x1, %esi
callq 0xd4f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xcb7e
movl -0x4c(%rbp), %eax
movl %eax, 0x1f72e(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xcb80
jmp 0xcb82
movl -0x58(%rbp), %eax
movsbl 0x154d4(%rip), %ecx     # 0x22060
movsbl 0x154c7(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xcc9a
movq -0x90(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x90(%rbp), %rax
cmpb $0x0, 0x9(%rax)
jne 0xcbf8
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %edx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xcbf6
movl -0x4c(%rbp), %eax
movl %eax, 0x1f6b6(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xcbf8
movq -0x90(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x48(%rbp), %esi
callq 0x9700
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0xcc47
movq -0x18(%rbp), %rdi
movq -0x90(%rbp), %rax
movq (%rax), %rsi
callq 0x80a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xcc75
movq -0xe8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xcc73
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xcc59
jmp 0xcc98
movq -0xf0(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
jne 0xcc8f
movq -0x90(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
je 0xcc96
movb $0x0, -0x81(%rbp)
jmp 0xcc98
jmp 0xccde
movq -0x90(%rbp), %rax
movl 0x10(%rax), %eax
movsbl 0x153b5(%rip), %ecx     # 0x22060
movsbl 0x153a8(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
je 0xccd6
cmpl $-0x1, -0x58(%rbp)
je 0xccc4
cmpl $0x64, -0x58(%rbp)
jne 0xcccd
movb $0x1, -0x81(%rbp)
jmp 0xccd4
movb $0x0, -0x81(%rbp)
jmp 0xccdc
movl -0x5c(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0xccde
jmp 0xbe21
movq -0x18(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, 0x1f5b0(%rip)     # 0x2c2a8
movl -0x40(%rbp), %eax
movl %eax, -0x60(%rbp)
cmpl $0x1, -0x60(%rbp)
jl 0xcd94
movq -0x10(%rbp), %rax
addq $0x1200, %rax           # imm = 0x1200
movq %rax, -0x130(%rbp)
movl -0x60(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq -0x130(%rbp), %rdi
movl 0x8(%rax), %esi
callq 0x9700
movsbl 0x8(%rax), %eax
cmpl $0x1, %eax
jne 0xcd84
movl -0x60(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movl 0xc(%rax), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x0, -0xf4(%rbp)
jle 0xcd78
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0xf4(%rbp), %esi
callq 0x9700
movl $0x0, 0x14(%rax)
movl -0x60(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x8eb0
jmp 0xcd86
movl -0x60(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xccfe
cmpb $0x0, -0x81(%rbp)
je 0xcda7
cmpl $0x0, -0x40(%rbp)
jle 0xce96
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1440(%rax)
jne 0xcdbd
movl $0xc, -0x54(%rbp)
jmp 0xcdd8
cmpb $0x0, -0x81(%rbp)
jne 0xcdcf
movl $0xe, -0x54(%rbp)
jmp 0xcdd6
movl $0xb, -0x54(%rbp)
jmp 0xcdd8
movl -0x58(%rbp), %eax
movsbl 0x1527e(%rip), %ecx     # 0x22060
movsbl 0x15271(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
je 0xcdf7
movl -0x58(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0xce10
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x44(%rbp), %esi
callq 0x9700
movl 0x14(%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x64, -0x64(%rbp)
je 0xce4f
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
cmpl $0x0, 0x140c(%rax,%rcx,4)
je 0xce4d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
movl 0x140c(%rax,%rcx,4), %esi
movl -0x4c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x54(%rbp)
jmp 0xce4f
cmpl $0x0, -0x54(%rbp)
je 0xce94
cmpl $0xb, -0x54(%rbp)
jne 0xce7a
movl 0x1f447(%rip), %eax     # 0x2c2a8
movl %eax, -0x4c(%rbp)
movl -0x40(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x9700
movq (%rax), %rax
movq %rax, 0x1f426(%rip)     # 0x2c2a0
movl -0x4c(%rbp), %eax
movl %eax, 0x1f415(%rip)     # 0x2c298
leaq -0x40(%rbp), %rdi
callq 0x8540
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcea6
jmp 0xce96
leaq -0x40(%rbp), %rdi
callq 0x8540
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)