// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl $0x14c0, %edi           # imm = 0x14C0
callq 0x81d0
movq %rax, -0x38(%rbp)
movl $0x3, -0x58(%rbp)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
jne 0x9cc4
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x225e1(%rip)     # 0x2c298
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb5a0
movq -0x38(%rbp), %rax
movq $0x0, 0x1208(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x1228(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x1448(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x1468(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x1488(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x14a8(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x143c(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x1438(%rax)
movl $0x0, -0x50(%rbp)
cmpl $0xb, -0x50(%rbp)
jge 0x9d8c
movl $0x0, -0x54(%rbp)
cmpl $0xb, -0x54(%rbp)
jge 0x9d7f
movq -0x38(%rbp), %rax
addq $0x1254, %rax           # imm = 0x1254
movslq -0x50(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x54(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x9d4e
jmp 0x9d81
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x9d41
movl $0x0, -0x44(%rbp)
cmpl $0x80, -0x44(%rbp)
jge 0x9dbe
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x9d93
movl -0x24(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x81d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x1240(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
movl $0x38, %edx
movsd 0x1820d(%rip), %xmm0    # 0x22008
movl $0x1, %ecx
callq 0x8460
cmpl $0x0, %eax
jne 0x9ed3
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
xorl %ecx, %ecx
movl $0x4, %edx
movsd 0x181e0(%rip), %xmm0    # 0x22008
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
jne 0x9ed3
movq -0x38(%rbp), %rax
cmpq $0x0, 0x1240(%rax)
je 0x9ed3
movq -0x38(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
xorl %ecx, %ecx
movl $0x38, %edx
movsd 0x181a4(%rip), %xmm0    # 0x22008
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
jne 0x9ed3
movq -0x38(%rbp), %rdi
addq $0x1460, %rdi           # imm = 0x1460
xorl %ecx, %ecx
movl $0x4, %edx
xorps %xmm0, %xmm0
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
jne 0x9ed3
movq -0x38(%rbp), %rdi
addq $0x1480, %rdi           # imm = 0x1480
xorl %ecx, %ecx
movl $0x4, %edx
xorps %xmm0, %xmm0
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
jne 0x9ed3
movq -0x38(%rbp), %rdi
addq $0x14a0, %rdi           # imm = 0x14A0
xorl %ecx, %ecx
movl $0x10, %edx
xorps %xmm0, %xmm0
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
je 0x9efd
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x223a8(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl $0x0, -0xb8(%rbp)
cmpl $0x80, -0xb8(%rbp)
jge 0x9f3a
movq -0x38(%rbp), %rax
movslq -0xb8(%rbp), %rcx
movl $0x0, 0x1000(%rax,%rcx,4)
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0x9f07
cmpl $0x0, -0x14(%rbp)
jl 0x9f46
cmpl $0x0, -0x24(%rbp)
jge 0x9f70
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl $0x0, 0x22335(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9ff3
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x38(%rbp), %rax
movq 0x1240(%rax), %rax
movslq -0x48(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x9fe6
movq -0x20(%rbp), %rax
movslq -0x48(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
je 0x9fe6
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
xorl %eax, %eax
subl -0x48(%rbp), %eax
subl $0x1, %eax
movl %eax, 0x222bf(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0x9fe8
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x9f77
movq -0x38(%rbp), %rax
movq 0x1240(%rax), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
movq 0x1240(%rax), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x1250(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x124c(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x1248(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x3c(%rbp)
cmpl $0x80, -0x3c(%rbp)
jge 0xa0bf
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
xorl %ecx, %ecx
movl $0x18, %edx
movsd 0x17f8c(%rip), %xmm0    # 0x22008
movl %ecx, %esi
callq 0x8460
cmpl $0x0, %eax
je 0xa0b2
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x221f3(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xa0b4
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xa055
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %esi
callq 0x9700
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %esi
callq 0x9700
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x11c(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %esi
callq 0x9700
movl -0x11c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %esi
callq 0x9700
movl $0x1, 0x2c(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x2, %esi
callq 0x9700
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x2, %esi
callq 0x9700
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x118(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x2, %esi
callq 0x9700
movl -0x118(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x2, %esi
callq 0x9700
movl $0x1, 0x2c(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x2, %esi
callq 0x9700
movb $0x1, 0x22(%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0x1434(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movl $0x64, 0x14(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movl -0x114(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movl $0x1, 0x2c(%rax)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movl $0x6, 0x30(%rax)
movl $0x0, -0x54(%rbp)
cmpl $0xa, -0x54(%rbp)
jge 0xa2b2
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x3, %esi
callq 0x9700
movslq -0x54(%rbp), %rcx
movb $0x1, 0x18(%rax,%rcx)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xa283
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl $0x6, %esi
movl $0x1, %edx
callq 0x8e70
cmpl $0x0, %eax
je 0xa2fb
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, 0x21faa(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %esi
subl $0x3, %esi
callq 0x9700
movl $0x1, (%rax)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %esi
subl $0x1, %esi
callq 0x9700
movl $0x1, (%rax)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %esi
callq 0x9700
movl $0x1, (%rax)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb4ea
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc(%rbp)
movl $0xffffffff, -0xe0(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xe4(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xe8(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xec(%rbp)
movl $0x0, -0xf4(%rbp)
movb $0x0, -0xf5(%rbp)
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movsbl (%rax), %ecx
movsbl 0x17c61(%rip), %edx     # 0x22050
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x11d(%rbp)
je 0xa423
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
movsbl 0x17c38(%rip), %ecx     # 0x22050
cmpl %ecx, %eax
sete %al
movb %al, -0x11d(%rbp)
movb -0x11d(%rbp), %al
andb $0x1, %al
movb %al, -0xf7(%rbp)
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17c10(%rip), %ecx     # 0x22052
cmpl %ecx, %eax
jl 0xa595
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17bf9(%rip), %ecx     # 0x22054
cmpl %ecx, %eax
jg 0xa595
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %edx
movl %edx, %esi
callq 0x8e70
cmpl $0x0, %eax
je 0xa4b4
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21df1(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17b91(%rip), %ecx     # 0x22056
cmpl %ecx, %eax
jl 0xa4f9
movl -0x58(%rbp), %edx
movq -0x38(%rbp), %rax
movq -0xd8(%rbp), %rcx
movsbl (%rcx), %ecx
movsbl 0x17b75(%rip), %esi     # 0x22056
subl %esi, %ecx
movslq %ecx, %rcx
movl %edx, 0x1248(%rax,%rcx,4)
leaq -0xd8(%rbp), %rdi
callq 0xb6c0
movl $0x1, -0xf4(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17b2a(%rip), %ecx     # 0x22058
cmpl %ecx, %eax
jg 0xa54e
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
jmp 0xa568
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl $0x64, 0x14(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl -0x124(%rbp), %ecx
movl %ecx, 0xc(%rax)
jmp 0xab08
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17ab4(%rip), %ecx     # 0x2205a
cmpl %ecx, %eax
jl 0xa6dc
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17c7b(%rip), %ecx     # 0x2223a
cmpl %ecx, %eax
jg 0xa6dc
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17a82(%rip), %ecx     # 0x2205a
subl %ecx, %eax
movl %eax, -0xe0(%rbp)
movl -0xe0(%rbp), %eax
movsbl 0x17a63(%rip), %ecx     # 0x22050
movsbl 0x17a66(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xa626
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21c7f(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl -0xe0(%rbp), %eax
movsbl 0x17a29(%rip), %ecx     # 0x2205c
movsbl 0x17a20(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xa66c
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21c39(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl $0x1, -0xf4(%rbp)
movb $0x1, -0xf5(%rbp)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
movb $0x1, %al
leaq 0x1eacc(%rip), %rcx     # 0x29170
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x125(%rbp)
je 0xa6d0
movq -0xd8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1eaad(%rip), %rax     # 0x29170
cmpl $0x1, (%rax,%rcx,4)
sete %al
movb %al, -0x125(%rbp)
movb -0x125(%rbp), %al
testb $0x1, %al
jne 0xa67d
jmp 0xa6dc
cmpb $0x0, -0xf7(%rbp)
je 0xa6ee
movb $0x1, -0xf6(%rbp)
jmp 0xa6f5
movb $0x0, -0xf6(%rbp)
jmp 0xa6f7
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xaa10
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x17943(%rip), %ecx     # 0x2205e
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0xf8(%rbp)
movq -0xd8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
movb $0x1, %al
leaq 0x1ea33(%rip), %rcx     # 0x29170
cmpl $0x1, (%rcx,%rdx,4)
movb %al, -0x126(%rbp)
je 0xa769
movq -0xd8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x1ea14(%rip), %rax     # 0x29170
cmpl $0x0, (%rax,%rcx,4)
sete %al
movb %al, -0x126(%rbp)
movb -0x126(%rbp), %al
testb $0x1, %al
jne 0xa775
jmp 0xa789
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0xa728
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa79d
jmp 0xaa10
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl $0x1, %edx
movl %edx, %esi
callq 0x8e70
cmpl $0x0, %eax
je 0xa7ee
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21ab7(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0x38(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movq -0x130(%rbp), %rdi
movq %rax, %rdx
movl -0x58(%rbp), %ecx
movb -0xf5(%rbp), %r9b
movb -0xf6(%rbp), %r10b
movl -0x58(%rbp), %eax
subl -0xdc(%rbp), %eax
leaq -0xd8(%rbp), %rsi
xorl %r8d, %r8d
movsbl %r9b, %r9d
movsbl %r10b, %r10d
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0xb710
movl %eax, -0xf0(%rbp)
cmpl $0x0, -0xf0(%rbp)
je 0xa894
movq -0x38(%rbp), %rdi
callq 0xb5b0
movl -0xf0(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21a11(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x177b5(%rip), %ecx     # 0x2205a
cmpl %ecx, %eax
jl 0xa8fa
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x177a6(%rip), %ecx     # 0x22060
cmpl %ecx, %eax
jg 0xa8fa
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x1778b(%rip), %ecx     # 0x2205a
subl %ecx, %eax
movl %eax, -0xe4(%rbp)
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0xa904
movl $0xffffffff, -0xe4(%rbp) # imm = 0xFFFFFFFF
movb -0xf8(%rbp), %al
movb %al, -0x13a(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movb -0x13a(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0xf7(%rbp), %al
movb %al, -0x139(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movb -0x139(%rbp), %cl
movb %cl, 0x9(%rax)
movl -0xe0(%rbp), %eax
movl %eax, -0x138(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl -0x138(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0xe4(%rbp), %eax
movl %eax, -0x134(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl -0x134(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl -0x58(%rbp), %eax
cmpl -0xdc(%rbp), %eax
je 0xa9ff
movl -0x58(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x144(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
movl -0x144(%rbp), %ecx
movl %ecx, 0x24(%rax)
movl -0x58(%rbp), %eax
movl %eax, -0x140(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
subl $0x1, %esi
callq 0x9700
movl -0x140(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0xe4(%rbp), %eax
movl %eax, -0xe0(%rbp)
jmp 0xa6f7
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
cmpl $-0x1, 0x10(%rax)
jne 0xaa75
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0x58(%rbp), %esi
callq 0x9700
cmpl $-0x1, 0x14(%rax)
jne 0xaa75
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x148(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movl -0x148(%rbp), %ecx
movl %ecx, 0xc(%rax)
jmp 0xab06
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x14c(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movl -0x14c(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
jl 0xaad8
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jle 0xab04
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x217a1(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xab06
jmp 0xab08
movl -0xe4(%rbp), %eax
movsbl 0x1753b(%rip), %ecx     # 0x22050
movsbl 0x1753e(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xab4e
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21757(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl -0xe4(%rbp), %eax
movsbl 0x17501(%rip), %ecx     # 0x2205c
movsbl 0x174f8(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jne 0xab94
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x5, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21711(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x174a3(%rip), %ecx     # 0x22062
cmpl %ecx, %eax
jne 0xabe2
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movb $0x1, 0x22(%rax)
jmp 0xace9
jmp 0xabe4
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xace7
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0xacd0
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0xacd0
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movq -0xc0(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
movb $0x1, 0x18(%rax,%rcx)
cmpl $-0x1, -0xe8(%rbp)
jne 0xac64
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xe8(%rbp)
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x173dd(%rip), %ecx     # 0x22052
cmpl %ecx, %eax
jl 0xacce
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x173ce(%rip), %ecx     # 0x22058
cmpl %ecx, %eax
jg 0xacce
movl -0xdc(%rbp), %edx
movq -0x38(%rbp), %rax
addq $0x1254, %rax           # imm = 0x1254
movq -0xd8(%rbp), %rcx
movsbl (%rcx), %ecx
movsbl 0x173a3(%rip), %esi     # 0x22052
subl %esi, %ecx
movslq %ecx, %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movq -0xc0(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xacd0
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0xabe4
jmp 0xace9
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %eax
addl $0x1, %eax
movl %eax, -0x150(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movl -0x150(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl $0x0, -0xb4(%rbp)
cmpl $0x9, -0xb4(%rbp)
jge 0xad60
movslq -0xb4(%rbp), %rax
movl $0x0, -0x80(%rbp,%rax,4)
movslq -0xb4(%rbp), %rax
movl $0x0, -0xb0(%rbp,%rax,4)
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0xad25
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x172d1(%rip), %ecx     # 0x2205c
cmpl %ecx, %eax
jne 0xb279
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb274
jmp 0xadba
movq -0xc0(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x151(%rbp)
je 0xae31
movq -0xc0(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x151(%rbp)
je 0xae31
movq -0xc0(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %edx
xorl %eax, %eax
leaq 0x1e373(%rip), %rcx     # 0x29170
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x152(%rbp)
jne 0xae25
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x1724b(%rip), %ecx     # 0x22065
cmpl %ecx, %eax
setne %al
movb %al, -0x152(%rbp)
movb -0x152(%rbp), %al
movb %al, -0x151(%rbp)
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0xae3d
jmp 0xae54
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0xadba
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb26f
movl $0x0, -0xfc(%rbp)
movl $0x1, -0x100(%rbp)
movl $0xffffffff, -0x108(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x110(%rbp)
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x171c4(%rip), %ecx     # 0x22065
cmpl %ecx, %eax
jne 0xaed0
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
movl $0x4, -0x108(%rbp)
movl $0x2, -0x100(%rbp)
jmp 0xb089
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
je 0xaeee
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0xaefa
movl $0x1, -0x108(%rbp)
jmp 0xaf50
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x50, %eax
je 0xaf18
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0xaf24
movl $0x2, -0x108(%rbp)
jmp 0xaf4e
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4a, %eax
je 0xaf42
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6a, %eax
jne 0xaf4c
movl $0x3, -0x108(%rbp)
jmp 0xaf4e
jmp 0xaf50
cmpl $-0x1, -0x108(%rbp)
je 0xaf75
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
movl $0x3, -0x100(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq -0xc9(%rbp), %rdx
callq 0xbb10
cmpl $0x0, %eax
je 0xafce
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x6, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x212d7(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
cmpb $0x0, -0xc9(%rbp)
jne 0xb008
cmpl $-0x1, -0x108(%rbp)
je 0xb034
movsd 0x17020(%rip), %xmm0    # 0x22008
ucomisd -0xc8(%rbp), %xmm0
ja 0xb008
movsd -0xc8(%rbp), %xmm0
movsd 0x1700e(%rip), %xmm1    # 0x22010
ucomisd %xmm1, %xmm0
jbe 0xb034
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21271(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xb036
cvttsd2si -0xc8(%rbp), %eax
movl %eax, -0xfc(%rbp)
cmpl $0x1, -0x108(%rbp)
jne 0xb087
movl -0xfc(%rbp), %eax
cmpl -0xf4(%rbp), %eax
jle 0xb087
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x2121e(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xb089
cmpl $-0x1, -0x108(%rbp)
jne 0xb0af
cmpl $0x0, -0xfc(%rbp)
jne 0xb0af
movl $0x0, -0x108(%rbp)
movl $0x2, -0x100(%rbp)
cmpl $0x2, -0x108(%rbp)
jne 0xb114
movl -0xec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xec(%rbp)
movl -0xfc(%rbp), %eax
subl $0x1, %eax
cltq
movl $0x1, -0xb0(%rbp,%rax,4)
cmpl $0x9, -0xec(%rbp)
jle 0xb112
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21193(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xb114
cmpl $0x3, -0x108(%rbp)
jne 0xb130
movl -0xfc(%rbp), %eax
subl $0x1, %eax
cltq
movl $0x1, -0x80(%rbp,%rax,4)
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x100(%rbp), %esi
xorl %edx, %edx
callq 0x8e70
cmpl $0x0, %eax
je 0xb18c
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x21119(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
cmpl $-0x1, -0x108(%rbp)
jne 0xb1ec
movl -0xfc(%rbp), %eax
movl %eax, -0x158(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x104(%rbp), %esi
callq 0x9700
movl -0x158(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xfc(%rbp)
jne 0xb1e7
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x104(%rbp), %esi
addl $0x1, %esi
callq 0x9700
movl $0x0, (%rax)
jmp 0xb26d
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x104(%rbp), %esi
callq 0x9700
movl $0x0, (%rax)
movl -0x108(%rbp), %eax
movl %eax, -0x15c(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x104(%rbp), %esi
addl $0x1, %esi
callq 0x9700
movl -0x15c(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x3, -0x100(%rbp)
jne 0xb26b
movl -0xfc(%rbp), %eax
movl %eax, -0x160(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movl -0x104(%rbp), %esi
addl $0x2, %esi
callq 0x9700
movl -0x160(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xb26d
jmp 0xb26f
jmp 0xada5
jmp 0xb411
cmpb $0x0, -0xf7(%rbp)
jne 0xb40f
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movl $0x0, 0x30(%rax)
movsbl 0x16dc2(%rip), %eax     # 0x2206c
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movsbl 0x16f83(%rip), %ecx     # 0x2223a
cmpl %ecx, %eax
jg 0xb2d8
movslq -0x4c(%rbp), %rcx
leaq 0x1deaa(%rip), %rax     # 0x29170
movl $0x5, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb2ad
movq -0x38(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movl -0xe8(%rbp), %edx
callq 0xbd60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movsbl 0x16d6f(%rip), %eax     # 0x2206c
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movsbl 0x16f30(%rip), %ecx     # 0x2223a
cmpl %ecx, %eax
jg 0xb32b
movslq -0x4c(%rbp), %rcx
leaq 0x1de57(%rip), %rax     # 0x29170
movl $0x0, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb300
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xb34d
movq -0x38(%rbp), %rdi
movl -0xe8(%rbp), %esi
xorl %edx, %edx
callq 0xcec0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xb37a
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
movq -0x38(%rbp), %rax
movl 0x1460(%rax), %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0xb3b1
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x20ef4(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movq -0x38(%rbp), %rax
addq $0x1460, %rax           # imm = 0x1460
movq %rax, -0x170(%rbp)
movq -0x38(%rbp), %rax
addq $0x1220, %rax           # imm = 0x1220
movq %rax, -0x168(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movq -0x170(%rbp), %rdi
movq -0x168(%rbp), %rdx
movl 0x2c(%rax), %ecx
movq -0x38(%rbp), %rax
movl 0x1460(%rax), %r8d
movl $0x1, %esi
callq 0x8a90
jmp 0xb411
movl $0x0, -0xb4(%rbp)
cmpl $0x9, -0xb4(%rbp)
jge 0xb482
movslq -0xb4(%rbp), %rax
cmpl $0x0, -0xb0(%rbp,%rax,4)
jne 0xb46f
movslq -0xb4(%rbp), %rax
cmpl $0x0, -0x80(%rbp,%rax,4)
je 0xb46f
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x20e36(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xb471
movl -0xb4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb4(%rbp)
jmp 0xb41b
movq -0x38(%rbp), %rax
movl 0x1220(%rax), %eax
movl %eax, -0x178(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movq %rax, %rcx
movl -0x178(%rbp), %eax
subl 0x2c(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x174(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movl -0xdc(%rbp), %esi
callq 0x9700
movl -0x174(%rbp), %ecx
movl %ecx, 0x30(%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xa368
movq -0x38(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
callq 0x8f70
cmpl $0x0, %eax
jne 0xb514
movq -0x38(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
callq 0x8f70
cmpl $0x0, %eax
je 0xb53b
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x20d67(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
movl $0x0, -0x3c(%rbp)
cmpl $0x80, -0x3c(%rbp)
jge 0xb598
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x8f70
cmpl $0x0, %eax
je 0xb58b
movq -0x38(%rbp), %rdi
callq 0xb5b0
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, 0x20d17(%rip)     # 0x2c298
movq $0x0, -0x8(%rbp)
jmp 0xb5a0
jmp 0xb58d
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb542
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopl (%rax)