// File: /workspace/github_c_makefile_star2_O1/heltilda[P]cicada/cmpile.c
// Function: newCompiler
compiler_type *newCompiler(commandTokenType *commandTokens, ccInt numCommands, ccInt *OoOdirections, ccInt numOoOs, ccInt *rtrn)
{
    compiler_type *compiler = (compiler_type *) malloc(sizeof(compiler_type));
    ccInt loopList, loopCmd, loopTokenString, loopOoO, loopArgCmd, loopArgType, loopRtrnType, loopToken = 3;
    ccInt jumpTo[9], jumpMarkers[9], loopJump, loopStartingChar;
    char *oneChar;
    ccFloat theNum;
    ccBool ifFloat;
    
    *rtrn = passed;
    
    if (compiler == NULL)  {  *rtrn = out_of_memory_err;  errPosition = 0;  return compiler;  }
    
    compiler->tokenSpecs.memory = NULL;         // zero our pointers first so we know what we've allocated
    compiler->allCodeWords.memory = NULL;       // (in case we have to bail out before we've finished building arrays)
    compiler->scriptTokens.memory = NULL;
    compiler->bytecode.memory = NULL;
    compiler->opCharNum.memory = NULL;
    compiler->varNames.memory = NULL;
    compiler->numVariables = compiler->anonymousMemberNum = 0;
    
    for (loopArgType = 0; loopArgType < 11; loopArgType++)  {
    for (loopRtrnType = 0; loopRtrnType < 11; loopRtrnType++)  {
        compiler->adapters[loopArgType][loopRtrnType] = 0;
    }}
    
    for (loopTokenString = 0; loopTokenString < 128; loopTokenString++)  {
        compiler->tokens[loopTokenString].memory = NULL;        }
    
    
        // construct the jump tables from the language tokens
    
    compiler->OoOdirections = (ccInt *) malloc((numOoOs+2)*sizeof(ccInt));
    if ((newLinkedList(&(compiler->tokenSpecs), 3, sizeof(tokenSpecType), 1., ccTrue) != passed)
                || (newLinkedList(&(compiler->allCodeWords), 0, sizeof(ccInt), 1., ccFalse) != passed)
                || (compiler->OoOdirections == NULL)
                || (newLinkedList(&(compiler->scriptTokens), 0, sizeof(scriptTokenType), 1., ccFalse) != passed)
                || (newLinkedList(&(compiler->bytecode), 0, sizeof(ccInt), 0, ccFalse) != passed)
                || (newLinkedList(&(compiler->opCharNum), 0, sizeof(ccInt), 0, ccFalse) != passed)
                || (newLinkedList(&(compiler->varNames), 0, sizeof(varNameType), 0, ccFalse) != passed))
        errOut(out_of_memory_err, 0)
    
    for (loopStartingChar = 0; loopStartingChar < 128; loopStartingChar++)  {
        compiler->numLanguageOps[loopStartingChar] = 0;             }
    
    
        // read in miscellaneous information about the language; initialize memory
    
    if ((numCommands < 0) || (numOoOs < 0))  errOut(out_of_range_err, 0)
    
    for (loopOoO = 0; loopOoO < numOoOs; loopOoO++)  {
        compiler->OoOdirections[loopOoO] = OoOdirections[loopOoO];
        if ((OoOdirections[loopOoO] != l_to_r) && (OoOdirections[loopOoO] != r_to_l)) {
            errOut(out_of_range_err, -loopOoO-1)
    }   }
    compiler->OoOdirections[numOoOs] = l_to_r;
    compiler->OoOdirections[numOoOs+1] = l_to_r;
    
    compiler->specialTokens[0] = compiler->specialTokens[1] = compiler->specialTokens[2] = -1;
    
    for (loopList = 0; loopList < 128; loopList++)  {
    if (newLinkedList(compiler->tokens + loopList, 0, sizeof(tokenStringType), 1., ccFalse) != passed)  {
        errOut(out_of_memory_err, 0)
    }}
    
    
        // we start with a null token for comments, constant data and macro args, and the typeXadapter placeholder token
    
        // constant data:  we add an explicit token for this, so that, for example, strings won't feel that there's a
        // missing argument between the two quotation 'operators'
    
    tokenSpec(1)->leftArgType = tokenSpec(1)->rightArgType = -1;
    tokenSpec(1)->precedence = numOoOs+2;
    tokenSpec(1)->firstCodeWord = 1;
    
    
        // typeX adapter
    
    tokenSpec(2)->leftArgType = tokenSpec(2)->rightArgType = -1;
    tokenSpec(2)->precedence = numOoOs+2;
    tokenSpec(2)->firstCodeWord = 1;
    tokenSpec(2)->rtrnTypes[10] = ccTrue;
    compiler->adapters[10][10] = 2;
    
    
        // macro argument -- the idea here is that the code writes the compiler command to load an argument (0, 1, arg #)
        // into the result of the macro 'bytecode'
    
    tokenSpec(3)->leftArgType = -1;
    tokenSpec(3)->rightArgType = constDataArgType;
    tokenSpec(3)->precedence = numOoOs+1;
    tokenSpec(3)->firstCodeWord = 1;
    tokenSpec(3)->numCodeWords = 6;
    for (loopRtrnType = 0; loopRtrnType < 10; loopRtrnType++)
        tokenSpec(3)->rtrnTypes[loopRtrnType] = ccTrue;
    if (addElements(&(compiler->allCodeWords), 6, ccTrue) != passed)  errOut(out_of_memory_err, 1)
    *LL_int(&(compiler->allCodeWords), compiler->allCodeWords.elementNum-3) = 1;
    *LL_int(&(compiler->allCodeWords), compiler->allCodeWords.elementNum-1) = 1;
    *LL_int(&(compiler->allCodeWords), compiler->allCodeWords.elementNum) = 1;
    
    
        // read in each token along with its bytecode expansion
    
    for (loopCmd = 0; loopCmd < numCommands; loopCmd++)  {
        
        char *tokenChar = (char *) commandTokens[loopCmd].cmdString;
        ccInt firstToken = loopToken+1, LHarg = -1, RHarg = -1, firstRtrnType = -1, numJumps = 0, aOrtrn, numArgs = 0;
        ccBool expectLHarg = ccFalse, optionalLHarg;
        ccBool tobeRemoved = ( (*commandTokens[loopCmd].rtrnTypeString == *removedexpression)
                            || (*commandTokens[loopCmd].translation == *removedexpression) );
        
        
            // first we read the text description of an operation (usually a string interspersed with
            // 'typeNarg's, but may be something like 'int_constant', in which case we just mark the token number)
            
            // case 1:  it's a pre-defined object:  a constant, user-defined variable or argument adapter
        
        if ((*tokenChar >= *type0arg_adapter) && (*tokenChar <= *variable_name))  {
            
            loopToken++;
            if (addElements(&(compiler->tokenSpecs), 1, ccTrue) != passed)  errOut(out_of_memory_err, loopCmd+1)
            
            if (*tokenChar >= *int_constant)  {
                compiler->specialTokens[(ccInt) ((*tokenChar)-(*int_constant))] = loopToken;
                nextChar(&tokenChar);        }
            
            numArgs = 1;
            tokenSpec(loopToken)->leftArgType = -1;
            if (*tokenChar <= *noarg_adapter)  tokenSpec(loopToken)->rightArgType = -1;
            else  tokenSpec(loopToken)->rightArgType = constDataArgType;
            tokenSpec(loopToken)->precedence = numOoOs+1;        }
        
        
            // case 2:  it's an ordinary series of tokens and arguments -- read those until we run out
        
        else  {
            
                // first read in the left-hand argument type, if there is one
            
            if ((*tokenChar >= *type0arg) && (*tokenChar <= *type9arg))  {
                LHarg = ((ccInt) *tokenChar) - ((ccInt) *type0arg);
                if (LHarg == (ccInt) (*chararg - *type0arg))  errOut(char_read_err, loopCmd+1)
                if (LHarg == (ccInt) (*stringarg - *type0arg))  errOut(string_read_err, loopCmd+1)
                numArgs = 1;
                expectLHarg = ccTrue;
                do  {  tokenChar++;  }
                while ((lettertype(tokenChar) == unprintable) || (lettertype(tokenChar) == a_space));  }
            
            
                // removable expressions (comments) can happen irrespective of whether there is a left-hand argument
            
            if (tobeRemoved)  optionalLHarg = ccTrue;
            else  optionalLHarg = ccFalse;
            
            
                // now read in each token/argument type
            
            while (*tokenChar != 0)  {
                
                ccBool isOptional = (*tokenChar == *optionalargs);
                
                while ((lettertype(tokenChar) == a_space) || (lettertype(tokenChar) == unprintable))  tokenChar++;
                if (*tokenChar == 0)  break;
                
                loopToken++;
                if (addElements(&(compiler->tokenSpecs), 1, ccTrue) != passed)  errOut(out_of_memory_err, loopCmd+1)
                
                aOrtrn = addTokenSpec(compiler, &tokenChar, &(tokenSpec(loopToken)->name), loopToken, ccFalse,
                                        expectLHarg, optionalLHarg, loopToken-firstToken, 0);
                if (aOrtrn != passed)  errOut(aOrtrn, loopCmd+1)
                
                
                    // if there's a right-hand argument (or an argument in between tokens), mark its type
                
                if ((*tokenChar >= *type0arg) && (*tokenChar <= *commentarg))  {
                    RHarg = ((ccInt) *tokenChar) - ((ccInt) *type0arg);
                    numArgs++;
                    tokenChar++;        }
                else  RHarg = -1;
                
                
                    // store the token information and move on
                
                tokenSpec(loopToken)->isOptional = isOptional;
                tokenSpec(loopToken)->tobeRemoved = tobeRemoved;
                tokenSpec(loopToken)->leftArgType = LHarg;
                tokenSpec(loopToken)->rightArgType = RHarg;
                if (loopToken != firstToken)  {
                    tokenSpec(loopToken)->prevToken = loopToken-1;
                    tokenSpec(loopToken-1)->nextToken = loopToken;   }
                
                LHarg = RHarg;
            }
            
            
                // now store info about the command as a whole -- we use the first token for storing this information
                // first store the precedence level of the command
            
            if ((tokenSpec(firstToken)->leftArgType == -1) && (tokenSpec(loopToken)->rightArgType == -1))  {
                tokenSpec(firstToken)->precedence = numOoOs+2;        }
            else  {
                tokenSpec(firstToken)->precedence = commandTokens[loopCmd].precedence;
                
                if ((commandTokens[loopCmd].precedence < 1) || (commandTokens[loopCmd].precedence > numOoOs))  {
                    errOut(out_of_range_err, loopCmd+1)
        }   }   }
        
        
            // a character or string has to be flanked by opening and closing tokens
        
        if (RHarg == (ccInt) (*chararg - *type0arg))  errOut(char_read_err, loopCmd+1)
        if (RHarg == (ccInt) (*stringarg - *type0arg))  errOut(string_read_err, loopCmd+1)
        
        
            // read in the return types of the command
        
        oneChar = (char *) commandTokens[loopCmd].rtrnTypeString;
        
        if (*oneChar == *argXtype)  {
            tokenSpec(firstToken)->rtrnTypes[10] = ccTrue;       }
        else  {
        while (*oneChar != 0)  {
            if ((*oneChar >= '0') && (*oneChar <= '9'))  {
                tokenSpec(firstToken)->rtrnTypes[(*oneChar)-'0'] = ccTrue;
                if (firstRtrnType == -1)  firstRtrnType = (*oneChar)-'0';
                if ((*tokenChar >= *type0arg_adapter) && (*tokenChar <= *noarg_adapter))  {
                    compiler->adapters[(*tokenChar)-(*type0arg_adapter)][(*oneChar)-'0'] = firstToken;
            }   }
            
            oneChar++;
        }}
        
        
            // parse the string that stores the command's bytecode
        
        tokenSpec(firstToken)->firstCodeWord = compiler->allCodeWords.elementNum+1;
        
        
        for (loopJump = 0; loopJump < 9; loopJump++)  {  jumpMarkers[loopJump] = jumpTo[loopJump] = 0;  }
        
        
            // case #1:  the string is raw bytecode (i.e. it has an 'inbytecode' character at the beginning)
        
        oneChar = (char *) commandTokens[loopCmd].translation;
        if (*oneChar == *inbytecode)  {
            oneChar++;
            while (*oneChar != 0)  {
                while ( (*oneChar == ' ') || (*oneChar == '\t') ||
                        ((lettertype(oneChar) == unprintable) && (*oneChar != anonymousmember[1])) )  {
                    oneChar++;      }
                
                if (*oneChar != 0)  {
                    
                    ccInt intNum = 0, wordsToAdd = 1, wordPosition, wordType = -1;          // an ordinary command word
                    char *holdNumPos = NULL;
                    
                    if (*oneChar == anonymousmember[1])  {
                        oneChar++;
                        wordType = 4;
                        wordsToAdd = 2;         }
                    
                    else  {
                        if ((*oneChar == 'A') || (*oneChar == 'a'))  wordType = 1;        // an argument
                        else if ((*oneChar == 'P') || (*oneChar == 'p'))  wordType = 2;   // a code position marker
                        else if ((*oneChar == 'J') || (*oneChar == 'j'))  wordType = 3;   // a jump offset
                        
                        if (wordType != -1)  {
                            oneChar++;
                            wordsToAdd = 3;     }
                        
                        holdNumPos = oneChar;
                        if (readNum(&oneChar, &theNum, &ifFloat) != passed)
                            errOut(read_number_err, loopCmd+1)
                        else if ((ifFloat) || ((wordType != -1) && ((theNum < 1) || (theNum > 9))))
                            errOut(out_of_range_err, loopCmd+1)
                        intNum = (ccInt) theNum;
                        
                        if ((wordType == 1) && (intNum > numArgs))
                            errOut(out_of_range_err, loopCmd+1)       }
                    
                    if ((wordType == -1) && (intNum == 0))  {  wordType = 0;  wordsToAdd = 2;  }
                    if (wordType == 2)  {
                        numJumps++;
                        jumpMarkers[intNum-1] = 1;
                        if (numJumps > 9)  {
                            errOut(out_of_range_err, loopCmd+1)
                    }   }
                    
                    if (wordType == 3)  jumpTo[intNum-1] = 1;
                    
                    wordPosition = compiler->allCodeWords.elementNum+1;
                    if (addElements(&(compiler->allCodeWords), wordsToAdd, ccFalse) != passed)  errOut(out_of_memory_err, loopCmd+1)
                    
                    if (wordType == -1)  {
                        *LL_int(&(compiler->allCodeWords), wordPosition) = intNum;
                        if (intNum == 0)  *LL_int(&(compiler->allCodeWords), wordPosition+1) = 0;      }
                    else  {
                        *LL_int(&(compiler->allCodeWords), wordPosition) = 0;
                        *LL_int(&(compiler->allCodeWords), wordPosition+1) = wordType;
                        if (wordsToAdd == 3)  {
                            *LL_int(&(compiler->allCodeWords), wordPosition+2) = intNum;
        }   }  }   }   }
        
        
            // case #2:  the string is a macro command -- compile it using the commands we've already encountered
        
        else if (!tobeRemoved)  {
            tokenSpec(firstToken)->numCodeWords = 0;        // temporary patch, to ensure we can compile the macro string
            
            for (loopArgCmd = *arg1; loopArgCmd <= *arg9; loopArgCmd++)  lettertypeArray[loopArgCmd] = a_symbol;  
            *rtrn = tokenize(compiler, oneChar, firstRtrnType);
            for (loopArgCmd = *arg1; loopArgCmd <= *arg9; loopArgCmd++)  lettertypeArray[loopArgCmd] = unprintable;  
            
            if (*rtrn == passed)  *rtrn = reorderTokens(compiler, firstRtrnType, ccFalse);
            if (*rtrn == passed)  *rtrn = addElements(&(compiler->allCodeWords), compiler->bytecode.elementNum, ccFalse);
            if (*rtrn != passed)  errOut(*rtrn, loopCmd+1)
            
            copyElements(&(compiler->bytecode), 1,
                    &(compiler->allCodeWords), tokenSpec(firstToken)->firstCodeWord, compiler->bytecode.elementNum);
        }
        
        for (loopJump = 0; loopJump < 9; loopJump++)  {
        if ((jumpMarkers[loopJump] == 0) && (jumpTo[loopJump] != 0))  {
            errOut(out_of_range_err, loopCmd+1)
        }}
        
        tokenSpec(firstToken)->numCodeWords = compiler->allCodeWords.elementNum - tokenSpec(firstToken)->firstCodeWord + 1;
    }
    
    
        // defragment all the linked lists to make the parsing faster, and count number of operators
    
    if ((defragmentLinkedList(&(compiler->allCodeWords)) != passed)
                || (defragmentLinkedList(&(compiler->tokenSpecs)) != passed))  errOut(out_of_memory_err, 0)
    
    for (loopList = 0; loopList < 128; loopList++)  {
    if (defragmentLinkedList(compiler->tokens + loopList) != passed)  {
        errOut(out_of_memory_err, 0)
    }}
    
    return compiler;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r8, %rbx
movl %ecx, %r15d
movq %rdx, %rbp
movl %esi, %r12d
movq %rdi, %r13
movl $0x14c0, %edi           # imm = 0x14C0
callq 0x81d0
movl $0x0, (%rbx)
testq %rax, %rax
je 0x967f
movq %rax, %r14
movq %r13, 0xa8(%rsp)
movq %r15, 0x78(%rsp)
xorl %eax, %eax
movq %rax, 0x1208(%r14)
movq %rax, 0x1228(%r14)
movq %rax, 0x1448(%r14)
movq %rax, 0x1468(%r14)
movq %rax, 0x1488(%r14)
movq %rax, 0x14a8(%r14)
leaq 0x1254(%r14), %rdi
movl $0x1ec, %edx            # imm = 0x1EC
movq %rdi, 0xa0(%rsp)
xorl %esi, %esi
callq 0x80c0
leaq 0x1200(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x1440(%r14), %r15
leaq 0x1480(%r14), %r13
movl $0x8, %eax
movq $0x0, (%r14,%rax)
addq $0x20, %rax
cmpq $0x1008, %rax           # imm = 0x1008
jne 0x95ff
movslq 0x78(%rsp), %rax
leaq 0x8(,%rax,4), %rdi
callq 0x81d0
movq %rax, 0x1240(%r14)
movsd 0x119d4(%rip), %xmm0    # 0x1b008
movq 0x10(%rsp), %rdi
movl $0x3, %esi
movl $0x38, %edx
movl $0x1, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
leaq 0x1220(%r14), %rdi
movsd 0x119a8(%rip), %xmm0    # 0x1b008
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
je 0x96a7
movq %r14, %rdi
callq 0xa394
movl $0x1, (%rbx)
xorl %r15d, %r15d
movl %r15d, 0x1bc19(%rip)    # 0x252a8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x1240(%r14)
je 0x9677
movsd 0x1194f(%rip), %xmm0    # 0x1b008
movq %r15, %rdi
xorl %esi, %esi
movl $0x38, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
leaq 0x1460(%r14), %r15
xorpd %xmm0, %xmm0
movq %r15, %rdi
xorl %esi, %esi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
xorpd %xmm0, %xmm0
movq %r13, %rdi
xorl %esi, %esi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
leaq 0x14a0(%r14), %rdi
xorpd %xmm0, %xmm0
xorl %esi, %esi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
movq %r15, 0x88(%rsp)
leaq 0x1000(%r14), %rdi
xorl %r15d, %r15d
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x80c0
movq 0x78(%rsp), %rsi
movl %esi, %eax
orl %r12d, %eax
js 0x995f
movl %esi, %eax
testl %esi, %esi
movq 0x10(%rsp), %r13
jle 0x9790
movq 0x1240(%r14), %rcx
xorl %r15d, %r15d
movl (%rbp,%r15,4), %edx
movl %edx, (%rcx,%r15,4)
movl (%rbp,%r15,4), %edx
decl %edx
cmpl $0x2, %edx
jae 0x9972
incq %r15
cmpq %r15, %rax
jne 0x976f
leal 0x2(%rsi), %ecx
movl %ecx, 0x64(%rsp)
movq 0x1240(%r14), %rcx
movabsq $0x100000001, %rdx      # imm = 0x100000001
movq %rdx, (%rcx,%rax,4)
leal 0x1(%rsi), %eax
movl %eax, 0x68(%rsp)
movl $0xffffffff, 0x1250(%r14) # imm = 0xFFFFFFFF
movq $-0x1, 0x1248(%r14)
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
xorl %esi, %esi
movl $0x18, %edx
movsd 0x11829(%rip), %xmm0    # 0x1b008
xorl %ecx, %ecx
callq 0x83e1
testl %eax, %eax
jne 0x9677
addq $0x20, %r15
cmpq $0x1000, %r15           # imm = 0x1000
jne 0x97cc
movq %r13, %rdi
movl $0x1, %esi
callq 0x911c
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, 0x14(%rax)
movq %r13, %rdi
movl $0x1, %esi
callq 0x911c
movl %r15d, 0x10(%rax)
movq %r13, %rdi
movl $0x1, %esi
callq 0x911c
movl 0x64(%rsp), %ebp
movl %ebp, 0xc(%rax)
movq %r13, %rdi
movl $0x1, %esi
callq 0x911c
movl $0x1, %ecx
movl %ecx, 0x2c(%rax)
movq %r13, %rdi
movl $0x2, %esi
callq 0x911c
movl %r15d, 0x14(%rax)
movq %r13, %rdi
movl $0x2, %esi
callq 0x911c
movl %r15d, 0x10(%rax)
movq %r13, %rdi
movl $0x2, %esi
callq 0x911c
movl %ebp, 0xc(%rax)
movq %r13, %rdi
movl $0x2, %esi
callq 0x911c
movl $0x1, %ebp
movl %ebp, 0x2c(%rax)
movq %r13, %rdi
movl $0x2, %esi
callq 0x911c
movb $0x1, 0x22(%rax)
movl $0x2, 0x1434(%r14)
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movl %r15d, 0x10(%rax)
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movl $0x64, 0x14(%rax)
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movl 0x68(%rsp), %ecx
movl %ecx, 0xc(%rax)
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movl %ebp, 0x2c(%rax)
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movl $0x6, 0x30(%rax)
xorl %r15d, %r15d
movq %r13, %rdi
movl $0x3, %esi
callq 0x911c
movb $0x1, 0x18(%rax,%r15)
incq %r15
cmpq $0xa, %r15
jne 0x990f
movl $0x1, %r15d
movq 0x20(%rsp), %r13
movq %r13, %rdi
movl $0x6, %esi
movl $0x1, %edx
callq 0x8b6a
testl %eax, %eax
je 0x9988
movq %r14, %rdi
callq 0xa394
movl $0x1, (%rbx)
jmp 0x9688
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
jmp 0x9688
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
notl %r15d
jmp 0x9688
movl (%r13), %esi
addl $-0x3, %esi
movq %r13, %rdi
callq 0x911c
movl $0x1, %ebp
movl %ebp, (%rax)
movl (%r13), %esi
decl %esi
movq %r13, %rdi
callq 0x911c
movl %ebp, (%rax)
movl (%r13), %esi
movq %r13, %rdi
callq 0x911c
movl %ebp, (%rax)
testl %r12d, %r12d
jle 0xa34a
movl %r12d, %eax
movq %rax, 0x98(%rsp)
movl $0x3, %eax
movq %rax, 0x30(%rsp)
leaq 0x1879f(%rip), %r13     # 0x22180
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x5, %rax
movq 0xa8(%rsp), %rcx
leaq (%rcx,%rax), %rdx
movq %rdx, 0x70(%rsp)
movq (%rcx,%rax), %r15
movq %r15, 0x28(%rsp)
movq 0x10(%rcx,%rax), %rax
movb $0x1, 0x50(%rsp)
cmpb $0x1b, (%rax)
je 0x9a25
movq 0x70(%rsp), %rax
movq 0x18(%rax), %rax
cmpb $0x1b, (%rax)
sete 0x50(%rsp)
movq 0x30(%rsp), %rax
incl %eax
movl %eax, 0x4(%rsp)
movb (%r15), %al
leal 0x10(%rax), %ecx
cmpb $0xd, %cl
ja 0x9a81
movq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x8b6a
testl %eax, %eax
je 0x9d25
movq %r14, %rdi
callq 0xa394
movl $0x1, (%rbx)
leal 0x1(%r12), %eax
movl %eax, 0x1b838(%rip)     # 0x252a8
xorl %r15d, %r15d
movl 0x4(%rsp), %eax
movq %rax, 0x30(%rsp)
jmp 0xa316
addb $-0x10, %al
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x0, 0x6c(%rsp)
cmpb $0x9, %al
ja 0x9abd
movq 0x28(%rsp), %rcx
movzbl 0x1(%rcx), %edx
incq %rcx
cmpl $0x2, (%r13,%rdx,4)
jb 0x9a9b
movzbl %al, %edx
movq %rcx, 0x28(%rsp)
movb $0x1, %al
movl %eax, 0x6c(%rsp)
movl $0x1, %ecx
movl %edx, 0x60(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl %ecx, 0x5c(%rsp)
movq %r12, 0x48(%rsp)
leal 0x1(%r12), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl %eax, %esi
movq 0x28(%rsp), %rax
movb (%rax), %al
testb %al, %al
je 0x9ca2
movq 0x28(%rsp), %rcx
decq %rcx
movzbl 0x1(%rcx), %edx
incq %rcx
cmpl $0x2, (%r13,%rdx,4)
jb 0x9af9
cmpb $0x1e, %al
sete %al
movq %rcx, 0x28(%rsp)
testb %dl, %dl
je 0x9b4b
movb %al, 0xc(%rsp)
leal 0x1(%rsi), %ebp
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rsi, %r12
movl $0x1, %esi
movl $0x1, %edx
callq 0x8b6a
testl %eax, %eax
je 0x9b56
movq %r14, %rdi
callq 0xa394
movl $0x1, (%rbx)
jmp 0x9ba9
movl $0x1d, %r12d
xorl %r15d, %r15d
jmp 0x9bbe
movq %r15, %rdi
movl %ebp, %esi
callq 0x911c
movl %r12d, %r10d
subl 0x30(%rsp), %r10d
subq $0x8, %rsp
movzbl 0x58(%rsp), %r11d
movzbl 0x74(%rsp), %r9d
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
movq %rax, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
pushq $0x0
pushq %r10
pushq %r11
callq 0xa480
addq $0x20, %rsp
testl %eax, %eax
je 0x9bcc
movl %eax, %r15d
movq %r14, %rdi
callq 0xa394
movl %r15d, (%rbx)
movl 0x8(%rsp), %eax
movl %eax, 0x1b6f5(%rip)     # 0x252a8
movl $0x1, %r12d
xorl %r15d, %r15d
movl %ebp, %esi
testl %r12d, %r12d
je 0x9ae2
jmp 0x9c98
movq %r12, 0x80(%rsp)
movq 0x28(%rsp), %rax
movb (%rax), %cl
addb $-0x10, %cl
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpb $0xd, %cl
ja 0x9bf9
movzbl %cl, %r15d
incl 0x5c(%rsp)
incq %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x911c
movb 0xc(%rsp), %cl
movb %cl, 0x8(%rax)
movq %r12, %rdi
movl %ebp, %esi
callq 0x911c
movb 0x50(%rsp), %cl
movb %cl, 0x9(%rax)
movq %r12, %rdi
movl %ebp, %esi
callq 0x911c
movl 0x60(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %r12, %rdi
movl %ebp, %esi
callq 0x911c
movl %r15d, 0x14(%rax)
xorl %r12d, %r12d
movl %r15d, %ecx
movb $0x1, %r15b
movq 0x80(%rsp), %rax
cmpl 0x30(%rsp), %eax
movl %ecx, 0x44(%rsp)
jne 0x9c65
movl %ebp, %esi
movl %ecx, 0x60(%rsp)
jmp 0x9bbe
movq 0x10(%rsp), %rdi
movl %ebp, %esi
callq 0x911c
movq 0x80(%rsp), %rsi
movl %esi, 0x24(%rax)
movq 0x10(%rsp), %rdi
callq 0x911c
movl %ebp, 0x28(%rax)
movl %ebp, %esi
movl 0x44(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0x9bbe
cmpl $0x1d, %r12d
jne 0x9dba
movl %esi, %eax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x911c
cmpl $-0x1, 0x10(%rax)
movq 0x48(%rsp), %r12
jne 0x9cdc
movq %r15, %rdi
movq 0x30(%rsp), %rsi
callq 0x911c
cmpl $-0x1, 0x14(%rax)
je 0x9dc6
movq 0x70(%rsp), %rbp
movl 0x8(%rbp), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl 0xc(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0x8(%rbp), %eax
testl %eax, %eax
setg %cl
cmpl 0x78(%rsp), %eax
setle %al
testb %al, %cl
jne 0x9dd9
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
jmp 0x9df5
movsbq (%r15), %rax
cmpq $-0x5, %rax
jl 0x9d5f
addl $0x5, %eax
movl 0x4(%rsp), %ecx
movl %ecx, 0x1248(%r14,%rax,4)
movzbl (%r15), %eax
cmpl $0x6, (%r13,%rax,4)
je 0x9d5f
movzbl 0x1(%r15), %eax
incq %r15
cmpl $0x0, (%r13,%rax,4)
je 0x9d4a
movq %r15, 0x28(%rsp)
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
xorl %ebp, %ebp
cmpb $-0x5, (%rax)
setl %bpl
movq %r15, %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl 0x4(%rsp), %esi
negl %ebp
orl $0x64, %ebp
movl %ebp, 0x14(%rax)
movl $0x1, 0x5c(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x68(%rsp), %ebp
movl %esi, %eax
movq %rax, 0x30(%rsp)
jmp 0x9dce
movl %esi, %eax
movq %rax, 0x30(%rsp)
jmp 0xa311
movl 0x64(%rsp), %ebp
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x911c
movl %ebp, 0xc(%rax)
movl 0x44(%rsp), %eax
cmpl $0xc, %eax
je 0x9de7
cmpl $0xb, %eax
jne 0x9e08
movq %r14, %rdi
callq 0xa394
movl $0x5, (%rbx)
leal 0x1(%r12), %eax
movl %eax, 0x1b4a8(%rip)     # 0x252a8
xorl %r15d, %r15d
jmp 0xa316
movq %r12, 0x48(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
cmpb $-0x2, (%rax)
jne 0x9e39
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movb $0x1, 0x22(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x9eb0
movq 0x38(%rsp), %r15
movb (%r15), %al
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x9eab
movq 0x28(%rsp), %r12
addb $-0x30, %al
cmpb $0x9, %al
ja 0x9ea0
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movsbq (%r15), %rcx
movb $0x1, -0x18(%rcx,%rax)
cmpl $-0x1, %ebp
jne 0x9e78
movsbl (%r15), %ebp
addl $-0x30, %ebp
movb (%r12), %al
addb $0x10, %al
cmpb $0xa, %al
ja 0x9ea0
movzbl %al, %eax
movsbq (%r15), %rcx
imulq $0x2c, %rax, %rax
addq 0xa0(%rsp), %rax
movl 0x4(%rsp), %edx
movl %edx, -0xc0(%rax,%rcx,4)
movb 0x1(%r15), %al
incq %r15
testb %al, %al
jne 0x9e4f
movq %r15, 0x38(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %r15d
incl %r15d
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl %r15d, 0x2c(%rax)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xe0(%rsp)
movapd %xmm0, 0xf0(%rsp)
xorl %eax, %eax
movl %eax, 0x100(%rsp)
movl %eax, 0xd0(%rsp)
movapd %xmm0, 0xc0(%rsp)
movapd %xmm0, 0xb0(%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rax), %r15
movq %r15, 0x38(%rsp)
cmpb $0x1c, (%r15)
jne 0xa1ed
leaq 0x1(%r15), %rax
movq %rax, 0x38(%rsp)
cmpb $0x0, 0x1(%r15)
je 0xa2c0
movq 0x48(%rsp), %rax
incl %eax
movl %eax, 0xc(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x38(%rsp), %rax
movzbl (%rax), %ecx
cmpl $0x9, %ecx
je 0x9f65
cmpl $0x20, %ecx
je 0x9f65
cmpq $0x1a, %rcx
je 0x9f6a
cmpl $0x0, (%r13,%rcx,4)
jne 0x9f6a
incq %rax
jmp 0x9f4a
movq %rax, 0x38(%rsp)
leal -0x41(%rcx), %edx
cmpl $0x2f, %edx
ja 0x9faf
movabsq $0x100000001, %rsi      # imm = 0x100000001
btq %rdx, %rsi
jb 0x9fed
movabsq $0x20000000200, %rsi    # imm = 0x20000000200
btq %rdx, %rsi
jb 0x9fda
movabsq $0x800000008000, %rsi   # imm = 0x800000008000
btq %rdx, %rsi
jae 0x9faf
movl $0x2, %r12d
jmp 0x9fe0
testl %ecx, %ecx
je 0xa165
cmpl $0x1a, %ecx
jne 0xa05b
incq %rax
movq %rax, 0x38(%rsp)
movl $0x4, %r12d
movl $0x2, %ebp
xorl %edx, %edx
jmp 0xa0ab
movl $0x3, %r12d
xorl %r15d, %r15d
movl $0x0, 0x8(%rsp)
jmp 0x9ffc
movl $0x1, %r12d
movb $0x1, %cl
movl %ecx, 0x8(%rsp)
xorl %r15d, %r15d
movl $0x1, %ebp
testb %r15b, %r15b
jne 0xa013
incq %rax
movq %rax, 0x38(%rsp)
movl $0x3, %ebp
leaq 0x38(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x1f(%rsp), %rdx
callq 0xa70e
testl %eax, %eax
je 0xa041
movq %r14, %rdi
callq 0xa394
movl $0x6, (%rbx)
jmp 0xa14f
cmpb $0x0, 0x1f(%rsp)
je 0xa069
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
jmp 0xa14f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movb $0x1, %r15b
jmp 0x9fe3
testb %r15b, %r15b
jne 0xa08f
movsd 0x90(%rsp), %xmm0
movsd 0x10f89(%rip), %xmm1    # 0x1b008
ucomisd %xmm0, %xmm1
ja 0xa048
ucomisd 0x10f83(%rip), %xmm0    # 0x1b010
ja 0xa048
cvttsd2si 0x90(%rsp), %edx
cmpb $0x0, 0x8(%rsp)
je 0xa0ab
movl $0x1, %r12d
cmpl %edx, 0x5c(%rsp)
jl 0xa048
movl %r12d, %eax
notl %eax
orl %edx, %eax
movl $0x2, %eax
cmovel %eax, %ebp
movl $0x0, %eax
cmovel %eax, %r12d
cmpl $0x2, %r12d
movl %edx, 0x8(%rsp)
jne 0xa116
movq 0x50(%rsp), %rcx
leal 0x1(%rcx), %r15d
movslq %edx, %rax
movl $0x1, 0xac(%rsp,%rax,4)
cmpl $0x9, %ecx
jl 0xa10e
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x1b1a7(%rip)     # 0x252a8
xorl %r12d, %r12d
movl %r15d, %eax
movq %rax, 0x50(%rsp)
jmp 0xa15c
movl %r15d, %eax
movq %rax, 0x50(%rsp)
cmpl $0x3, %r12d
jne 0xa12c
movslq 0x8(%rsp), %rax
movl $0x1, 0xdc(%rsp,%rax,4)
movq 0x20(%rsp), %rdi
movl (%rdi), %r15d
movl %ebp, %esi
xorl %edx, %edx
callq 0x8b6a
testl %eax, %eax
je 0xa178
movq %r14, %rdi
callq 0xa394
movl $0x1, (%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x1b14f(%rip)     # 0x252a8
xorl %r12d, %r12d
testb %r12b, %r12b
je 0xa290
movq 0x38(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x9f45
jmp 0xa2c0
leal 0x1(%r15), %esi
movq 0x20(%rsp), %rdi
callq 0x911c
cmpl $-0x1, %r12d
je 0xa1c4
movl $0x0, (%rax)
leal 0x2(%r15), %esi
movq 0x20(%rsp), %rdi
callq 0x911c
movl %r12d, (%rax)
movb $0x1, %r12b
cmpl $0x3, %ebp
jne 0xa15c
addl $0x3, %r15d
movq 0x20(%rsp), %rdi
movl %r15d, %esi
callq 0x911c
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
jmp 0xa15c
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movb $0x1, %r12b
testl %ecx, %ecx
jne 0xa15c
addl $0x2, %r15d
movq 0x20(%rsp), %rdi
movl %r15d, %esi
callq 0x911c
movl $0x0, (%rax)
jmp 0xa15c
cmpb $0x0, 0x50(%rsp)
jne 0xa2c0
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl $0x0, 0x30(%rax)
xorl %eax, %eax
movl $0x5, 0x44(%r13,%rax,4)
incq %rax
cmpq $0x9, %rax
jne 0xa20f
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xa85a
movl %eax, (%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x17f88(%rip)    # 0x221c4
movupd %xmm0, 0x17f90(%rip)    # 0x221d4
movl $0x0, 0x17f96(%rip)     # 0x221e4
cmpl $0x0, (%rbx)
jne 0xa261
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xb5d1
movl %eax, (%rbx)
cmpl $0x0, (%rbx)
jne 0xa27e
movq 0x88(%rsp), %rax
movl (%rax), %esi
movq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x8b6a
movl %eax, (%rbx)
cmpl $0x0, (%rbx)
je 0xa295
movq %r14, %rdi
callq 0xa394
jmp 0xa340
xorl %r15d, %r15d
jmp 0xa311
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x911c
movl 0x2c(%rax), %ecx
movq 0x88(%rsp), %rdi
movl (%rdi), %r8d
movl $0x1, %esi
movq 0x20(%rsp), %rdx
callq 0x8821
xorl %eax, %eax
cmpl $0x0, 0xb0(%rsp,%rax,4)
jne 0xa2d6
cmpl $0x0, 0xe0(%rsp,%rax,4)
jne 0xa332
incq %rax
cmpq $0x9, %rax
jne 0xa2c2
movq 0x20(%rsp), %rax
movl (%rax), %ebp
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl 0x4(%rsp), %r12d
movl %r12d, %esi
callq 0x911c
subl 0x2c(%rax), %ebp
incl %ebp
movq %r15, %rdi
movl %r12d, %esi
callq 0x911c
movl %ebp, 0x30(%rax)
movb $0x1, %r15b
movq 0x48(%rsp), %r12
testb %r15b, %r15b
je 0x968f
incq %r12
cmpq 0x98(%rsp), %r12
jne 0x99e4
jmp 0xa34a
movq %r14, %rdi
callq 0xa394
movl $0x2, (%rbx)
movq 0x48(%rsp), %r12
jmp 0x9df5
movq 0x20(%rsp), %rdi
callq 0x8bb7
testl %eax, %eax
jne 0x9677
movq 0x10(%rsp), %rdi
callq 0x8bb7
testl %eax, %eax
jne 0x9677
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x8bb7
testl %eax, %eax
jne 0x9677
addq $0x20, %r15
cmpq $0x1000, %r15           # imm = 0x1000
jne 0xa371
jmp 0x9692