// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: main
int main(int argc, char** argv)/*{{{*/
{
    bool isNonOptionArg = false;

    if(argc < 2) 
    {
        PrintHelp(argv);
        return 0;
    }
    int i,j;
    char outfile[MAX_PATH+1] = "";
    char fileListFile[MAX_PATH+1] ="";
    const char control_option[] = ""; //options which control the program, and does not take parameters
    //bool isAll = false;
    //bool isQuiet = false;
    //bool isSingle = false;
    bool isOutputQ3 = true;
    int fileFormat = 1;
    char chkFstFolder[MAX_PATH+1] ="";
    
    set <string> ::iterator iss;
    set <string> fileList_set;

    char infile [MAX_PATH+1] = "";
    int linesize;
    int maxline = 300;
    Array1D <char> line_1darray(maxline+1);
    char *line = line_1darray.array1D;
    i = 1;
    while(i < argc)/*{{{*/
    {
        if(argv[i][0] == '-' && !isNonOptionArg) //options
        {
            isNonOptionArg = false;
            if(IsInCharSet(argv[i][1], control_option))//if argv[i][1] is in control_option, it might be used as -aqs
            {
                for(j = 1 ; j < int(strlen(argv[i])); j++)
                {
                    switch (argv[i][j])
                    {
                        default : fprintf(stderr,"Invalid option, non-control option '%c' can be used together with contorl-option\n", argv[i][j]); return -1;
                    }
                }
                i ++;
            }
            else if(strcmp(argv[i],"-h") == 0 ||strcmp(argv[i],"--help")==0 )
            {
                PrintHelp(argv); 
                return 0;
            }
            else if(strcmp(argv[i],"-H") == 0 )
            {
                PrintVerboseHelp();
                return 0;
            }
            else if( (strcmp(argv[i],"-o") == 0) || (strcmp(argv[i], "--out") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, outfile)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-l") == 0) || (strcmp(argv[i], "--list") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, fileListFile)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-chkfstdir") == 0) || (strcmp(argv[i], "--chkfstdir") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, chkFstFolder)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-q3") == 0) || (strcmp(argv[i], "--isOutQ3") == 0))  
            {
                char tmpstr[MAX_PATH+1] ="";
                if( ( i = option_parser_filename(argc, argv, i, tmpstr)) == -1)
                    return -1;
                if (strncasecmp(tmpstr,"yes", 1) == 0)
                {
                    isOutputQ3 = true;
                }
                else
                {
                    isOutputQ3 = false;
                }
            }
            else if( (strcmp(argv[i],"-polypara") == 0) || (strcmp(argv[i], "--polypara") == 0))  
            {
                if (!IsNumeric(argv[i+1]) || !IsNumeric(argv[i+2]) || !IsNumeric(argv[i+3]) )
                {
                    fprintf(stderr,"Error! Option -polypara should be followed by three floating values\n");
                }
                else
                {
                    poly_a1 = atof(argv[i+1]);
                    poly_a2 = atof(argv[i+2]);
                    poly_a3 = atof(argv[i+3]);
                }
                i = i + 4;
            }
            else if( (strcmp(argv[i], "-f") == 0) || strcmp(argv[i], "--format") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, fileFormat, true, 0, 4)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-max") == 0) || strcmp(argv[i], "--max-length") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, maxSeqLength, true, 0, MAX_INT)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-statq3") == 0) )  
            {
                isStatQ3Conf = true;
                i ++;
            }
            else if( (strcmp(argv[i], "-proof") == 0) )  
            {
                isProofReading = true;
                i ++;
            }
            else if( (strcmp(argv[i], "-proofmethod") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, method_ProofReading, true, 0, 10)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-selconf") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, typeConfidence, true, 0, 1)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-binwidth") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, binWidth, true, 0.0, 100.0)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-m") == 0) || strcmp(argv[i], "--method") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, method_HSR, true, 0, 4)) == -1)
                    return -1;
            }
            else if (strcmp(argv[i], "--") == 0)//next item is non option argument
            {
                isNonOptionArg = true;
                i ++;
                continue;
            }
            else
            {
                fprintf(stderr,"Error! Invalid argument '%s'\n", argv[i]);
                return -1;
            }
        }
        else //non-option argument
        {
            fileList_set.insert(argv[i]);
            i ++;
        }
    }/*}}}*/
    if (isStatQ3Conf)
    {
        if (strcmp(chkFstFolder, "") == 0)
        {
            fprintf (stderr,"chkFstFolder not set, since -q3stat is enabled. Exit!\n");
            return -1;
        }
    }

    double halfBinWidth = binWidth/2;

    if (strcmp(fileListFile , "") != 0)
    {
        FILE *fpList=fopen(fileListFile, "r");
        checkfilestream(fpList, fileListFile,"r", false);
        if (fpList != NULL)
        {
            while((linesize=fgetline(fpList, line, maxline)) != EOF)
            {
                fileList_set.insert(line);
            }
            fclose(fpList);
        }
    }
    FILE *fpout = NULL;
    if(strcmp(outfile,"") == 0 || strcasecmp(outfile, "stdout") == 0)
    {
        fpout = stdout;
    }
    else
    {
        fpout = fopen(outfile, "w");
        checkfilestream(fpout, outfile,"w");
    }
    /*add code here*/

    /*============================= main procedure goes here ================ */


    if(fileList_set.size()> 0 )
    {
        /*print out the header annotation*/
        fprintf(fpout,"%-10s %8s %6s %6s %6s %7s %7s %6s %6s %6s ", "Item", "All(SOV)", "H(SOV)", "S(SOV)", "R(SOV)", "numAll", "numH", "numS", "numR", "seqLen");
        if(isOutputQ3)
        {
            fprintf(fpout,"%7s %6s %6s %6s %7s %6s %6s %6s", "All(Q3)", "H(Q3)", "S(Q3)", "R(Q3)", "numAll", "numH", "numS", "numR");
        }
        fprintf(fpout,"\n");
    }
    Array1D <char> aaSeq_1darray(maxSeqLength);
    Array1D <char> obsSec_1darray(maxSeqLength);
    Array1D <char> predSec_1darray(maxSeqLength);
    aaSeq_1darray.Init('-');
    obsSec_1darray.Init('-');
    predSec_1darray.Init('-');
    char *aaSeq = aaSeq_1darray.array1D;
    char *obsSec = obsSec_1darray.array1D;
    char *predSec = predSec_1darray.array1D;


    Array1D <double> q3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> sovHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numQ3CorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> numSOVCorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numSOVHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumQ3CorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalNumSOVCorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumSOVHSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalSOVHSR_1darray(NUM_HSR_STATE+1);

    q3HSR_1darray.Init(0);
    sovHSR_1darray.Init(0);
    numQ3CorrectHSR_1darray.Init(0);
    numQ3HSR_1darray.Init(0);
    numSOVCorrectHSR_1darray.Init(0);
    numSOVHSR_1darray.Init(0);
    totalNumQ3CorrectHSR_1darray.Init(0);
    totalNumQ3HSR_1darray.Init(0);
    totalQ3HSR_1darray.Init(0);
    totalNumSOVCorrectHSR_1darray.Init(0);
    totalNumSOVHSR_1darray.Init(0);
    totalSOVHSR_1darray.Init(0);


    double *q3HSR = q3HSR_1darray.array1D;
    double *sovHSR = sovHSR_1darray.array1D;

    int *numQ3CorrectHSR = numQ3CorrectHSR_1darray.array1D;
    int *numQ3HSR= numQ3HSR_1darray.array1D;   /*number of residues for each state when for analysis of Q3*/  
    double *numSOVCorrectHSR=numSOVCorrectHSR_1darray.array1D;
    int *numSOVHSR = numSOVHSR_1darray.array1D; /*number of residues for each state when for analysis of SOV*/

    int *totalNumQ3CorrectHSR = totalNumQ3CorrectHSR_1darray.array1D;
    int *totalNumQ3HSR = totalNumQ3HSR_1darray.array1D;
    double *totalQ3HSR = totalQ3HSR_1darray.array1D;

    double *totalNumSOVCorrectHSR = totalNumSOVCorrectHSR_1darray.array1D;
    int *totalNumSOVHSR = totalNumSOVHSR_1darray.array1D;
    double *totalSOVHSR = totalSOVHSR_1darray.array1D;

    /*variable for analysis of the q3 within each confidence bin*/
    Array1D <double> predConf_1darray(maxSeqLength);

    int numBin = 101;

    Array2D <int> statNumQ3CorrectHSR_2darray(numBin ,NUM_HSR_STATE+1);
    Array2D <int> statNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statQ3HSR_2darray(numBin,NUM_HSR_STATE+1);

    Array2D <int> statTotalNumQ3CorrectHSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <int> statTotalNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statTotalQ3HSR_2darray(numBin, NUM_HSR_STATE+1);

    Array2D <int> statAccumulateNumQ3CorrectHSR_2darray(numBin ,NUM_HSR_STATE+1);
    Array2D <int> statAccumulateNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statAccumulateQ3HSR_2darray(numBin,NUM_HSR_STATE+1);

    Array2D <int> statTotalAccumulateNumQ3CorrectHSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <int> statTotalAccumulateNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statTotalAccumulateQ3HSR_2darray(numBin, NUM_HSR_STATE+1);


    predConf_1darray.Init(0.0);

    statNumQ3CorrectHSR_2darray.Init(0);
    statNumQ3HSR_2darray.Init(0);
    statQ3HSR_2darray.Init(0.0);

    statTotalNumQ3CorrectHSR_2darray.Init(0);
    statTotalNumQ3HSR_2darray.Init(0);
    statTotalQ3HSR_2darray.Init(0);

    statAccumulateNumQ3CorrectHSR_2darray.Init(0);
    statAccumulateNumQ3HSR_2darray.Init(0);
    statAccumulateQ3HSR_2darray.Init(0.0);

    statTotalAccumulateNumQ3CorrectHSR_2darray.Init(0);
    statTotalAccumulateNumQ3HSR_2darray.Init(0);
    statTotalAccumulateQ3HSR_2darray.Init(0);

    double *predConf =predConf_1darray.array1D;

    int **statNumQ3CorrectHSR = statNumQ3CorrectHSR_2darray.array2D;
    int **statNumQ3HSR = statNumQ3HSR_2darray.array2D;
    double **statQ3HSR = statQ3HSR_2darray.array2D;

    int **statTotalNumQ3CorrectHSR = statTotalNumQ3CorrectHSR_2darray.array2D;
    int **statTotalNumQ3HSR = statTotalNumQ3HSR_2darray.array2D;
    double **statTotalQ3HSR = statTotalQ3HSR_2darray.array2D;

    int **statAccumulateNumQ3CorrectHSR = statAccumulateNumQ3CorrectHSR_2darray.array2D;
    int **statAccumulateNumQ3HSR = statAccumulateNumQ3HSR_2darray.array2D;
    double **statAccumulateQ3HSR = statAccumulateQ3HSR_2darray.array2D;

    int **statTotalAccumulateNumQ3CorrectHSR = statTotalAccumulateNumQ3CorrectHSR_2darray.array2D;
    int **statTotalAccumulateNumQ3HSR = statTotalAccumulateNumQ3HSR_2darray.array2D;
    double **statTotalAccumulateQ3HSR = statTotalAccumulateQ3HSR_2darray.array2D;


    int iBin = 0;
    int seqLength = 0;
    int totalLength = 0;     /*total number of residues for multiple files, even with those without structure definition*/

    char rtname [MAX_PATH+1] = "";
    char chkFstResFile [MAX_PATH+1] = "";

    for(iss = fileList_set.begin(); iss != fileList_set.end(); iss ++)
    {
        my_strcpy( infile, (*iss).c_str(), MAX_PATH-1);
        rootname(infile, rtname);
        seqLength = ReadInSecPredFile(infile, aaSeq, obsSec, predSec,predConf, typeConfidence, fileFormat);

        if (isProofReading)
        {
            ProofReading(predSec, seqLength, method_ProofReading);
        }
        /*multiply predConf by 100.0, to be percentages*/

        if (isStatQ3Conf)
        {
            sprintf(chkFstResFile, "%s/%s.txt", chkFstFolder, rtname);
            ReadConf(chkFstResFile, predConf, typeConfidence);
            for(i = 0; i < seqLength; i ++) { predConf[i] *= 100.0; }
        }

        CalSOV(obsSec, predSec, seqLength, numSOVCorrectHSR, numSOVHSR, sovHSR, NUM_HSR_STATE);
        fprintf(fpout,"%-10.10s %8.2f %6.2f %6.2f %6.2f %7d %7d %6d %6d %6d ", rtname,  sovHSR[3]*100.0,  sovHSR[0]*100.0, sovHSR[1]*100.0, sovHSR[2]*100.0, numSOVHSR[3],numSOVHSR[0], numSOVHSR[1],numSOVHSR[2], seqLength);
        /*print out the result*/
        if (isOutputQ3)
        {
            CalQ3(obsSec, predSec, seqLength, numQ3CorrectHSR, numQ3HSR, q3HSR, NUM_HSR_STATE);
            fprintf(fpout,"%7.2f %6.2f %6.2f %6.2f %7d %6d %6d %6d", q3HSR[3]*100.0,  q3HSR[0]*100.0,  q3HSR[1]*100.0, q3HSR[2]*100.0, numQ3HSR[3], numQ3HSR[0],numQ3HSR[1],numQ3HSR[2]);
        }
        fprintf(fpout,"\n");

        if (isStatQ3Conf) /*analyze Q3 at different confidence; 2009-08-02*/
        {
            CalQ3ConfBin(obsSec, predSec, predConf, seqLength, statNumQ3CorrectHSR, statNumQ3HSR, statQ3HSR, NUM_HSR_STATE, halfBinWidth);
            CalQ3ConfAccumulate(obsSec, predSec, predConf, seqLength, statAccumulateNumQ3CorrectHSR, statAccumulateNumQ3HSR, statAccumulateQ3HSR, NUM_HSR_STATE, halfBinWidth);
            for (i = 0; i< NUM_HSR_STATE+1; i ++)
            {
                for (iBin = 0; iBin <= 100; iBin ++)
                {
                    statTotalNumQ3CorrectHSR[iBin][i] += statNumQ3CorrectHSR[iBin][i];
                    statTotalNumQ3HSR[iBin][i] += statNumQ3HSR[iBin][i];

                    statTotalAccumulateNumQ3CorrectHSR[iBin][i] += statAccumulateNumQ3CorrectHSR[iBin][i];
                    statTotalAccumulateNumQ3HSR[iBin][i] += statAccumulateNumQ3HSR[iBin][i];
                }
            }

        }


        for (i = 0; i< NUM_HSR_STATE+1; i++)
        {
            totalNumSOVCorrectHSR[i] += numSOVCorrectHSR[i];
            totalNumSOVHSR[i] += numSOVHSR[i];

            totalNumQ3CorrectHSR[i] += numQ3CorrectHSR[i];
            totalNumQ3HSR[i] += numQ3HSR[i];

        }
        totalLength += seqLength;
        
    }
    /*output the summary results*/
    for (i = 0; i< NUM_HSR_STATE+1; i++)
    {
        totalSOVHSR[i] = totalNumSOVCorrectHSR[i] / double (totalNumSOVHSR[i]+1e-6);
        totalQ3HSR[i] = totalNumQ3CorrectHSR[i] / double (totalNumQ3HSR[i]+1e-6);
    }
    if (isStatQ3Conf)
    {
        for (i = 0; i< NUM_HSR_STATE+1; i++)
        {
            for (iBin = 0; iBin <= 100; iBin ++)
            {
                statTotalQ3HSR[iBin][i] = statTotalNumQ3CorrectHSR[iBin][i] / double (statTotalNumQ3HSR[iBin][i]+1e-6);
                statTotalAccumulateQ3HSR[iBin][i] = statTotalAccumulateNumQ3CorrectHSR[iBin][i] / double (statTotalAccumulateNumQ3HSR[iBin][i]+1e-6);
            }
        }
        /*print out*/
        fprintf(stdout,"# BinWidth = %f\n", binWidth);
        fprintf(stdout,"#%28s    %20s\n", "non-accumulate" , "accumulate");
        fprintf(stdout,"#%-7s %6s %7s %7s   %8s %7s %7s\n", "Conf" , "Q3", "numRes", "%numRes", "Q3", "numRes", "%numRes");

        double percentNumResBin =0.0;
        double percentNumResAccumulate = 0.0;
        for(iBin = 0; iBin <= 100; iBin ++)
        {
            percentNumResBin = statTotalNumQ3HSR[iBin][3]/(statTotalAccumulateNumQ3HSR[0][3]+1e-6)*100.0;
            percentNumResAccumulate = statTotalAccumulateNumQ3HSR[iBin][3]/(statTotalAccumulateNumQ3HSR[0][3]+1e-6)*100.0;
            
            fprintf(stdout,"%-8d %6.2f %7d %6.2f   %8.2f %7d %6.2f\n", iBin, statTotalQ3HSR[iBin][3]*100.0, statTotalNumQ3HSR[iBin][3],percentNumResBin,  statTotalAccumulateQ3HSR[iBin][3]*100.0, statTotalAccumulateNumQ3HSR[iBin][3], percentNumResAccumulate);
        }

    }

    fprintf(fpout,"%-10s %8.2f %6.2f %6.2f %6.2f %7d %7d %6d %6d %6d ", "Sum",  totalSOVHSR[3]*100.0,  totalSOVHSR[0]*100.0, totalSOVHSR[1]*100.0, totalSOVHSR[2]*100.0, totalNumSOVHSR[3],totalNumSOVHSR[0], totalNumSOVHSR[1],totalNumSOVHSR[2], totalLength);
    if (isOutputQ3)
    {
        fprintf(fpout,"%7.2f %6.2f %6.2f %6.2f %7d %6d %6d %6d", totalQ3HSR[3]*100.0,  totalQ3HSR[0]*100.0,  totalQ3HSR[1]*100.0, totalQ3HSR[2]*100.0, totalNumQ3HSR[3], totalNumQ3HSR[0],totalNumQ3HSR[1],totalNumQ3HSR[2]);
    }
    fprintf(fpout,"\n");

    /*============================= main procedure ends here ================ */



    if(fpout != NULL && fpout != stdout) fclose(fpout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x12a8, %rsp           # imm = 0x12A8
movl $0x0, -0x1c(%rbp)
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
cmpl $0x2, -0x20(%rbp)
jge 0x58bd
movq -0x28(%rbp), %rdi
callq 0x2500
movl $0x0, -0x1c(%rbp)
jmp 0x7d74
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl %esi, -0x1204(%rbp)
movl $0x1f5, %edx            # imm = 0x1F5
movq %rdx, -0x1200(%rbp)
callq 0x2140
movl -0x1204(%rbp), %esi
movq -0x1200(%rbp), %rdx
leaq -0x430(%rbp), %rdi
callq 0x2140
movl -0x1204(%rbp), %esi
movq -0x1200(%rbp), %rdx
movb $0x0, -0x431(%rbp)
movb $0x1, -0x432(%rbp)
movl $0x1, -0x438(%rbp)
leaq -0x630(%rbp), %rdi
callq 0x2140
leaq -0x638(%rbp), %rdi
callq 0x89d0
leaq -0x668(%rbp), %rdi
callq 0x89f0
movl -0x1204(%rbp), %esi
movq -0x1200(%rbp), %rdx
leaq -0x860(%rbp), %rdi
callq 0x2140
movl $0x12c, -0x868(%rbp)    # imm = 0x12C
movl -0x868(%rbp), %esi
incl %esi
leaq -0x878(%rbp), %rdi
callq 0x8320
jmp 0x5978
movq -0x870(%rbp), %rax
movq %rax, -0x890(%rbp)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6335
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x624c
testb $0x1, -0x29(%rbp)
jne 0x624c
movb $0x0, -0x29(%rbp)
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb 0x1(%rax), %al
leaq -0x431(%rbp), %rsi
xorl %edx, %edx
movsbl %al, %edi
callq 0x2e60
testb $0x1, %al
jne 0x59e8
jmp 0x5a7f
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x1208(%rbp)
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2110
movq %rax, %rcx
movl -0x1208(%rbp), %eax
cmpl %ecx, %eax
jge 0x5a71
jmp 0x5a2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d66
movq 0xd5a2(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq 0x7fae(%rip), %rsi      # 0xda02
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6247
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7fc2(%rip), %rsi      # 0xda54
callq 0x2320
cmpl $0x0, %eax
je 0x5ab9
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7fa8(%rip), %rsi      # 0xda57
callq 0x2320
cmpl $0x0, %eax
jne 0x5ad8
movq -0x28(%rbp), %rdi
callq 0x2500
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x894(%rbp)
jmp 0x7d40
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7f73(%rip), %rsi      # 0xda5e
callq 0x2320
cmpl $0x0, %eax
jne 0x5b10
callq 0x27d0
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x894(%rbp)
jmp 0x7d40
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7f3e(%rip), %rsi      # 0xda61
callq 0x2320
cmpl $0x0, %eax
je 0x5b4a
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7f24(%rip), %rsi      # 0xda64
callq 0x2320
cmpl $0x0, %eax
jne 0x5b83
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
leaq -0x230(%rbp), %rcx
callq 0x2940
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5b7e
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x6241
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7ed4(%rip), %rsi      # 0xda6a
callq 0x2320
cmpl $0x0, %eax
je 0x5bbd
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7eba(%rip), %rsi      # 0xda6d
callq 0x2320
cmpl $0x0, %eax
jne 0x5bf6
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
leaq -0x430(%rbp), %rcx
callq 0x2940
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5bf1
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x623f
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7e6c(%rip), %rsi      # 0xda75
callq 0x2320
cmpl $0x0, %eax
je 0x5c30
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7e4e(%rip), %rsi      # 0xda74
callq 0x2320
cmpl $0x0, %eax
jne 0x5c69
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
leaq -0x630(%rbp), %rcx
callq 0x2940
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5c64
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x623d
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7e04(%rip), %rsi      # 0xda80
callq 0x2320
cmpl $0x0, %eax
je 0x5ca3
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7deb(%rip), %rsi      # 0xda84
callq 0x2320
cmpl $0x0, %eax
jne 0x5d1c
leaq -0xa90(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2140
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
leaq -0xa90(%rbp), %rcx
callq 0x2940
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5cea
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
leaq -0xa90(%rbp), %rdi
leaq 0x7d96(%rip), %rsi      # 0xda8e
movl $0x1, %edx
callq 0x2300
cmpl $0x0, %eax
jne 0x5d10
movb $0x1, -0x432(%rbp)
jmp 0x5d17
movb $0x0, -0x432(%rbp)
jmp 0x623b
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7d64(%rip), %rsi      # 0xda93
callq 0x2320
cmpl $0x0, %eax
je 0x5d5a
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7d46(%rip), %rsi      # 0xda92
callq 0x2320
cmpl $0x0, %eax
jne 0x5e2e
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a80
testb $0x1, %al
jne 0x5d76
jmp 0x5dac
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a80
testb $0x1, %al
jne 0x5d92
jmp 0x5dac
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a80
testb $0x1, %al
jne 0x5dc6
movq 0xd225(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
leaq 0x7ce0(%rip), %rsi      # 0xda9d
movb $0x0, %al
callq 0x2330
jmp 0x5e20
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x22f0
movsd %xmm0, 0xd42c(%rip)     # 0x13210
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x22f0
movsd %xmm0, 0xd416(%rip)     # 0x13218
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x22f0
movsd %xmm0, 0xd400(%rip)     # 0x13220
movl -0x30(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x30(%rbp)
jmp 0x6239
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7ca1(%rip), %rsi      # 0xdae2
callq 0x2320
cmpl $0x0, %eax
je 0x5e68
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7c87(%rip), %rsi      # 0xdae5
callq 0x2320
cmpl $0x0, %eax
jne 0x5ed8
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rsp, %rax
movl $0x4, (%rax)
leaq -0x438(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x7e20
movl %eax, -0x120c(%rbp)
jmp 0x5e98
movl -0x120c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5ed3
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d5a
jmp 0x6237
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7c03(%rip), %rsi      # 0xdaee
callq 0x2320
cmpl $0x0, %eax
je 0x5f12
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7beb(%rip), %rsi      # 0xdaf3
callq 0x2320
cmpl $0x0, %eax
jne 0x5f6b
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rsp, %rax
movl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
leaq 0xd2dc(%rip), %rcx      # 0x13208
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x7e20
movl %eax, -0x1210(%rbp)
jmp 0x5f42
movl -0x1210(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x5f66
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x6235
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7b82(%rip), %rsi      # 0xdb00
callq 0x2320
cmpl $0x0, %eax
jne 0x5f9d
movb $0x1, 0xd2a6(%rip)      # 0x13235
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6233
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7b58(%rip), %rsi      # 0xdb08
callq 0x2320
cmpl $0x0, %eax
jne 0x5fcf
movb $0x1, 0xd27b(%rip)      # 0x1323c
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6231
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7b2d(%rip), %rsi      # 0xdb0f
callq 0x2320
cmpl $0x0, %eax
jne 0x6045
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rsp, %rax
movl $0xa, (%rax)
leaq 0xd23a(%rip), %rcx      # 0x13240
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x7e20
movl %eax, -0x1214(%rbp)
jmp 0x601c
movl -0x1214(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x6040
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x622f
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7ac4(%rip), %rsi      # 0xdb1c
callq 0x2320
cmpl $0x0, %eax
jne 0x60bb
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rsp, %rax
movl $0x1, (%rax)
leaq 0xd1bc(%rip), %rcx      # 0x13238
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x7e20
movl %eax, -0x1218(%rbp)
jmp 0x6092
movl -0x1218(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x60b6
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x622d
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x7a57(%rip), %rsi      # 0xdb25
callq 0x2320
cmpl $0x0, %eax
jne 0x6130
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
leaq 0xd117(%rip), %rcx      # 0x13200
movl $0x1, %r8d
xorps %xmm0, %xmm0
movsd 0x6f16(%rip), %xmm1     # 0xd010
callq 0x8090
movl %eax, -0x121c(%rbp)
jmp 0x6107
movl -0x121c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x612b
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x622b
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x79ec(%rip), %rsi      # 0xdb2f
callq 0x2320
cmpl $0x0, %eax
je 0x616a
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x79d2(%rip), %rsi      # 0xdb32
callq 0x2320
cmpl $0x0, %eax
jne 0x61c0
movl -0x20(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x30(%rbp), %edx
movq %rsp, %rax
movl $0x4, (%rax)
leaq 0xd06c(%rip), %rcx      # 0x131f0
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x7e20
movl %eax, -0x1220(%rbp)
jmp 0x619a
movl -0x1220(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, %eax
jne 0x61be
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x6229
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x74c0(%rip), %rsi      # 0xd693
callq 0x2320
cmpl $0x0, %eax
jne 0x61ef
movb $0x1, -0x29(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x598d
movq 0xcde2(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x792f(%rip), %rsi      # 0xdb3b
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x622b
jmp 0x622d
jmp 0x622f
jmp 0x6231
jmp 0x6233
jmp 0x6235
jmp 0x6237
jmp 0x6239
jmp 0x623b
jmp 0x623d
jmp 0x623f
jmp 0x6241
jmp 0x6243
jmp 0x6245
jmp 0x6247
jmp 0x6330
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1230(%rbp)
leaq -0xab1(%rbp), %rdi
movq %rdi, -0x1228(%rbp)
callq 0x2390
movq -0x1230(%rbp), %rsi
movq -0x1228(%rbp), %rdx
leaq -0xab0(%rbp), %rdi
callq 0x8a60
jmp 0x628e
leaq -0x668(%rbp), %rdi
leaq -0xab0(%rbp), %rsi
callq 0x8a10
movb %dl, -0x1239(%rbp)
movq %rax, -0x1238(%rbp)
jmp 0x62b0
movb -0x1239(%rbp), %al
movq -0x1238(%rbp), %rcx
movq %rcx, -0xac8(%rbp)
movb %al, -0xac0(%rbp)
leaq -0xab0(%rbp), %rdi
callq 0x2160
leaq -0xab1(%rbp), %rdi
callq 0x2260
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x631f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
leaq -0xab0(%rbp), %rdi
callq 0x2160
leaq -0xab1(%rbp), %rdi
callq 0x2260
jmp 0x7d5a
jmp 0x598d
testb $0x1, 0xcef9(%rip)      # 0x13235
je 0x6386
leaq -0x630(%rbp), %rdi
leaq 0x6fc0(%rip), %rsi      # 0xd30c
callq 0x2320
cmpl $0x0, %eax
jne 0x6384
movq 0xcc7b(%rip), %rax      # 0x12fd8
movq (%rax), %rdi
leaq 0x77f2(%rip), %rsi      # 0xdb59
movb $0x0, %al
callq 0x2330
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x894(%rbp)
jmp 0x7d40
jmp 0x6386
movsd 0xce72(%rip), %xmm0     # 0x13200
movsd 0x6c8a(%rip), %xmm1     # 0xd020
divsd %xmm1, %xmm0
movsd %xmm0, -0xad0(%rbp)
leaq -0x430(%rbp), %rdi
leaq 0x6f5c(%rip), %rsi      # 0xd30c
callq 0x2320
cmpl $0x0, %eax
je 0x6535
leaq 0x76b9(%rip), %rsi      # 0xda7e
leaq -0x430(%rbp), %rdi
callq 0x22d0
movq %rax, -0x1248(%rbp)
jmp 0x63da
movq -0x1248(%rbp), %rax
movq %rax, -0xad8(%rbp)
movq -0xad8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
leaq 0x7681(%rip), %rdx      # 0xda7e
xorl %ecx, %ecx
callq 0x2ed0
cmpq $0x0, -0xad8(%rbp)
je 0x6533
jmp 0x6414
movq -0xad8(%rbp), %rdi
movq -0x890(%rbp), %rsi
movl -0x868(%rbp), %edx
callq 0x2dc0
movl %eax, -0x124c(%rbp)
jmp 0x6435
movl -0x124c(%rbp), %eax
movl %eax, -0x864(%rbp)
cmpl $-0x1, %eax
je 0x6523
movq -0x890(%rbp), %rax
movq %rax, -0x1260(%rbp)
leaq -0xaf9(%rbp), %rdi
movq %rdi, -0x1258(%rbp)
callq 0x2390
movq -0x1260(%rbp), %rsi
movq -0x1258(%rbp), %rdx
leaq -0xaf8(%rbp), %rdi
callq 0x8a60
jmp 0x6487
leaq -0x668(%rbp), %rdi
leaq -0xaf8(%rbp), %rsi
callq 0x8a10
movb %dl, -0x1269(%rbp)
movq %rax, -0x1268(%rbp)
jmp 0x64a9
movb -0x1269(%rbp), %al
movq -0x1268(%rbp), %rcx
movq %rcx, -0xb10(%rbp)
movb %al, -0xb08(%rbp)
leaq -0xaf8(%rbp), %rdi
callq 0x2160
leaq -0xaf9(%rbp), %rdi
callq 0x2260
jmp 0x6414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x6512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
leaq -0xaf8(%rbp), %rdi
callq 0x2160
leaq -0xaf9(%rbp), %rdi
callq 0x2260
jmp 0x7d5a
movq -0xad8(%rbp), %rdi
callq 0x2210
jmp 0x6531
jmp 0x6533
jmp 0x6535
movq $0x0, -0xb18(%rbp)
leaq -0x230(%rbp), %rdi
leaq 0x6dbe(%rip), %rsi      # 0xd30c
callq 0x2320
cmpl $0x0, %eax
je 0x6570
leaq -0x230(%rbp), %rdi
leaq 0x762a(%rip), %rsi      # 0xdb90
callq 0x2280
cmpl $0x0, %eax
jne 0x6583
movq 0xca49(%rip), %rax      # 0x12fc0
movq (%rax), %rax
movq %rax, -0xb18(%rbp)
jmp 0x65c9
leaq 0x760d(%rip), %rsi      # 0xdb97
leaq -0x230(%rbp), %rdi
callq 0x22d0
movq %rax, -0x1278(%rbp)
jmp 0x659f
movq -0x1278(%rbp), %rax
movq %rax, -0xb18(%rbp)
movq -0xb18(%rbp), %rdi
leaq -0x230(%rbp), %rsi
leaq 0x75d5(%rip), %rdx      # 0xdb97
xorl %ecx, %ecx
callq 0x2ed0
leaq -0x668(%rbp), %rdi
callq 0x8b10
cmpq $0x0, %rax
jbe 0x66d5
movq -0xb18(%rbp), %rdi
leaq 0x75ac(%rip), %rsi      # 0xdb99
leaq 0x75d0(%rip), %rdx      # 0xdbc4
leaq 0x75ce(%rip), %rcx      # 0xdbc9
leaq 0x75d0(%rip), %r8       # 0xdbd2
leaq 0x75d0(%rip), %r9       # 0xdbd9
leaq 0x75d0(%rip), %r15      # 0xdbe0
leaq 0x75d0(%rip), %r14      # 0xdbe7
leaq 0x75d0(%rip), %rbx      # 0xdbee
leaq 0x75ce(%rip), %r11      # 0xdbf3
leaq 0x75cc(%rip), %r10      # 0xdbf8
leaq 0x75ca(%rip), %rax      # 0xdbfd
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2330
testb $0x1, -0x432(%rbp)
je 0x66c0
movq -0xb18(%rbp), %rdi
leaq 0x7596(%rip), %rsi      # 0xdc04
leaq 0x75af(%rip), %rdx      # 0xdc24
leaq 0x75b0(%rip), %rcx      # 0xdc2c
leaq 0x75af(%rip), %r8       # 0xdc32
leaq 0x75ae(%rip), %r9       # 0xdc38
leaq 0x7556(%rip), %rbx      # 0xdbe7
leaq 0x7556(%rip), %r11      # 0xdbee
leaq 0x7554(%rip), %r10      # 0xdbf3
leaq 0x7552(%rip), %rax      # 0xdbf8
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x2330
movq -0xb18(%rbp), %rdi
leaq 0x6c3d(%rip), %rsi      # 0xd30b
movb $0x0, %al
callq 0x2330
movl 0xcb2d(%rip), %esi      # 0x13208
leaq -0xb28(%rbp), %rdi
callq 0x8320
jmp 0x66e9
movl 0xcb19(%rip), %esi      # 0x13208
leaq -0xb38(%rbp), %rdi
callq 0x8320
jmp 0x66fd
movl 0xcb05(%rip), %esi      # 0x13208
leaq -0xb48(%rbp), %rdi
callq 0x8320
jmp 0x6711
leaq -0xb28(%rbp), %rdi
movl $0x2d, %esi
callq 0x8b30
jmp 0x6724
leaq -0xb38(%rbp), %rdi
movl $0x2d, %esi
callq 0x8b30
jmp 0x6737
leaq -0xb48(%rbp), %rdi
movl $0x2d, %esi
callq 0x8b30
jmp 0x674a
movq -0xb20(%rbp), %rax
movq %rax, -0xb50(%rbp)
movq -0xb30(%rbp), %rax
movq %rax, -0xb58(%rbp)
movq -0xb40(%rbp), %rax
movq %rax, -0xb60(%rbp)
leaq -0xb70(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x6787
leaq -0xb80(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x679a
leaq -0xb90(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x67ad
leaq -0xba0(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x67c0
leaq -0xbb0(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x67d3
leaq -0xbc0(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x67e6
leaq -0xbd0(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x67f9
leaq -0xbe0(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x680c
leaq -0xbf0(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x681f
leaq -0xc00(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x6832
leaq -0xc10(%rbp), %rdi
movl $0x4, %esi
callq 0x8be0
jmp 0x6845
leaq -0xc20(%rbp), %rdi
movl $0x4, %esi
callq 0x8b80
jmp 0x6858
leaq -0xb70(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x6869
leaq -0xb80(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x687a
leaq -0xb90(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x688a
leaq -0xba0(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x689a
leaq -0xbb0(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x68ab
leaq -0xbc0(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x68bb
leaq -0xbd0(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x68cb
leaq -0xbe0(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x68db
leaq -0xbf0(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x68ec
leaq -0xc00(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x68fd
leaq -0xc10(%rbp), %rdi
xorl %esi, %esi
callq 0x8c90
jmp 0x690d
leaq -0xc20(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x691e
movq -0xb68(%rbp), %rax
movq %rax, -0xc28(%rbp)
movq -0xb78(%rbp), %rax
movq %rax, -0xc30(%rbp)
movq -0xb88(%rbp), %rax
movq %rax, -0xc38(%rbp)
movq -0xb98(%rbp), %rax
movq %rax, -0xc40(%rbp)
movq -0xba8(%rbp), %rax
movq %rax, -0xc48(%rbp)
movq -0xbb8(%rbp), %rax
movq %rax, -0xc50(%rbp)
movq -0xbc8(%rbp), %rax
movq %rax, -0xc58(%rbp)
movq -0xbd8(%rbp), %rax
movq %rax, -0xc60(%rbp)
movq -0xbe8(%rbp), %rax
movq %rax, -0xc68(%rbp)
movq -0xbf8(%rbp), %rax
movq %rax, -0xc70(%rbp)
movq -0xc08(%rbp), %rax
movq %rax, -0xc78(%rbp)
movq -0xc18(%rbp), %rax
movq %rax, -0xc80(%rbp)
movl 0xc83c(%rip), %esi      # 0x13208
leaq -0xc90(%rbp), %rdi
callq 0x8b80
jmp 0x69da
movl $0x65, -0xc94(%rbp)
movl -0xc94(%rbp), %esi
leaq -0xca8(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x69fd
movl -0xc94(%rbp), %esi
leaq -0xcb8(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6a16
movl -0xc94(%rbp), %esi
leaq -0xcc8(%rbp), %rdi
movl $0x4, %edx
callq 0x8d90
jmp 0x6a2f
movl -0xc94(%rbp), %esi
leaq -0xcd8(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6a48
movl -0xc94(%rbp), %esi
leaq -0xce8(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6a61
movl -0xc94(%rbp), %esi
leaq -0xcf8(%rbp), %rdi
movl $0x4, %edx
callq 0x8d90
jmp 0x6a7a
movl -0xc94(%rbp), %esi
leaq -0xd08(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6a93
movl -0xc94(%rbp), %esi
leaq -0xd18(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6aac
movl -0xc94(%rbp), %esi
leaq -0xd28(%rbp), %rdi
movl $0x4, %edx
callq 0x8d90
jmp 0x6ac5
movl -0xc94(%rbp), %esi
leaq -0xd38(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6ade
movl -0xc94(%rbp), %esi
leaq -0xd48(%rbp), %rdi
movl $0x4, %edx
callq 0x8ce0
jmp 0x6af7
movl -0xc94(%rbp), %esi
leaq -0xd58(%rbp), %rdi
movl $0x4, %edx
callq 0x8d90
jmp 0x6b10
leaq -0xc90(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8c40
jmp 0x6b21
leaq -0xca8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6b31
leaq -0xcb8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6b41
leaq -0xcc8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8eb0
jmp 0x6b52
leaq -0xcd8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6b62
leaq -0xce8(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6b72
leaq -0xcf8(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8eb0
jmp 0x6b83
leaq -0xd08(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6b93
leaq -0xd18(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6ba3
leaq -0xd28(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8eb0
jmp 0x6bb4
leaq -0xd38(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6bc4
leaq -0xd48(%rbp), %rdi
xorl %esi, %esi
callq 0x8e40
jmp 0x6bd4
leaq -0xd58(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x8eb0
jmp 0x6be5
movq -0xc88(%rbp), %rax
movq %rax, -0xd60(%rbp)
movq -0xca8(%rbp), %rax
movq %rax, -0xd68(%rbp)
movq -0xcb8(%rbp), %rax
movq %rax, -0xd70(%rbp)
movq -0xcc8(%rbp), %rax
movq %rax, -0xd78(%rbp)
movq -0xcd8(%rbp), %rax
movq %rax, -0xd80(%rbp)
movq -0xce8(%rbp), %rax
movq %rax, -0xd88(%rbp)
movq -0xcf8(%rbp), %rax
movq %rax, -0xd90(%rbp)
movq -0xd08(%rbp), %rax
movq %rax, -0xd98(%rbp)
movq -0xd18(%rbp), %rax
movq %rax, -0xda0(%rbp)
movq -0xd28(%rbp), %rax
movq %rax, -0xda8(%rbp)
movq -0xd38(%rbp), %rax
movq %rax, -0xdb0(%rbp)
movq -0xd48(%rbp), %rax
movq %rax, -0xdb8(%rbp)
movq -0xd58(%rbp), %rax
movq %rax, -0xdc0(%rbp)
movl $0x0, -0xdc4(%rbp)
movl $0x0, -0xdc8(%rbp)
movl $0x0, -0xdcc(%rbp)
leaq -0xfd0(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2140
leaq -0x11d0(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x2140
leaq -0x668(%rbp), %rdi
callq 0x8f20
movq %rax, -0x11d8(%rbp)
movq -0x11d8(%rbp), %rax
movq %rax, -0x638(%rbp)
leaq -0x668(%rbp), %rdi
callq 0x8f80
movq %rax, -0x11e0(%rbp)
leaq -0x638(%rbp), %rdi
leaq -0x11e0(%rbp), %rsi
callq 0x8f50
testb $0x1, %al
jne 0x6d2f
jmp 0x755c
leaq -0x638(%rbp), %rdi
callq 0x8fb0
movq %rax, %rdi
callq 0x2100
movq %rax, %rsi
leaq -0x860(%rbp), %rdi
movq %rdi, -0x1280(%rbp)
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x2830
movq -0x1280(%rbp), %rdi
leaq -0xfd0(%rbp), %rsi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x2890
jmp 0x6d78
movq -0xb50(%rbp), %rsi
movq -0xb58(%rbp), %rdx
movq -0xb60(%rbp), %rcx
movq -0xd60(%rbp), %r8
movl 0xc49d(%rip), %r9d      # 0x13238
movl -0x438(%rbp), %edi
movq %rsp, %rax
movl %edi, (%rax)
leaq -0x860(%rbp), %rdi
callq 0x31c0
movl %eax, -0x1284(%rbp)
jmp 0x6dba
movl -0x1284(%rbp), %eax
movl %eax, -0xdc8(%rbp)
testb $0x1, 0xc46f(%rip)      # 0x1323c
je 0x7080
movq -0xb60(%rbp), %rdi
movl -0xdc8(%rbp), %esi
movl 0xc45a(%rip), %edx      # 0x13240
callq 0x3a10
jmp 0x7080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7d02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7cae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7ca2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7c06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
jmp 0x7bfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x880(%rbp)
movl %eax, -0x884(%rbp)
leaq -0xd58(%rbp), %rdi
callq 0x9010
jmp 0x7bfa
testb $0x1, 0xc1ae(%rip)      # 0x13235
je 0x710e
leaq 0x6baa(%rip), %rsi      # 0xdc3e
xorl %eax, %eax
leaq -0x11d0(%rbp), %rdi
movq %rdi, -0x1290(%rbp)
leaq -0x630(%rbp), %rdx
leaq -0xfd0(%rbp), %rcx
callq 0x20a0
movq -0x1290(%rbp), %rdi
movq -0xd60(%rbp), %rsi
movl 0xc16d(%rip), %edx      # 0x13238
callq 0x3d30
jmp 0x70d2
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xdc8(%rbp), %eax
jge 0x710c
movq -0xd60(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd 0x5f19(%rip), %xmm0     # 0xd010
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x70d9
jmp 0x710e
movq -0xb58(%rbp), %rdi
movq -0xb60(%rbp), %rsi
movl -0xdc8(%rbp), %edx
movq -0xc48(%rbp), %rcx
movq -0xc50(%rbp), %r8
movq -0xc30(%rbp), %r9
movq %rsp, %rax
movl $0x3, (%rax)
callq 0x40c0
jmp 0x7147
movq -0xb18(%rbp), %rdi
leaq -0xfd0(%rbp), %rdx
movq -0xc30(%rbp), %rax
movsd 0x5eac(%rip), %xmm0     # 0xd010
mulsd 0x18(%rax), %xmm0
movq -0xc30(%rbp), %rax
movsd 0x5e98(%rip), %xmm1     # 0xd010
mulsd (%rax), %xmm1
movq -0xc30(%rbp), %rax
movsd 0x5e85(%rip), %xmm2     # 0xd010
mulsd 0x8(%rax), %xmm2
movq -0xc30(%rbp), %rax
movsd 0x5e71(%rip), %xmm3     # 0xd010
mulsd 0x10(%rax), %xmm3
movq -0xc50(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0xc50(%rbp), %rax
movl (%rax), %r8d
movq -0xc50(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0xc50(%rbp), %rax
movl 0x8(%rax), %r10d
movl -0xdc8(%rbp), %eax
leaq 0x6a6d(%rip), %rsi      # 0xdc48
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x4, %al
callq 0x2330
testb $0x1, -0x432(%rbp)
je 0x72b9
movq -0xb58(%rbp), %rdi
movq -0xb60(%rbp), %rsi
movl -0xdc8(%rbp), %edx
movq -0xc38(%rbp), %rcx
movq -0xc40(%rbp), %r8
movq -0xc28(%rbp), %r9
movl $0x3, (%rsp)
callq 0x50c0
movq -0xb18(%rbp), %rdi
movq -0xc28(%rbp), %rax
movsd 0x5dce(%rip), %xmm0     # 0xd010
mulsd 0x18(%rax), %xmm0
movq -0xc28(%rbp), %rax
movsd 0x5dba(%rip), %xmm1     # 0xd010
mulsd (%rax), %xmm1
movq -0xc28(%rbp), %rax
movsd 0x5da7(%rip), %xmm2     # 0xd010
mulsd 0x8(%rax), %xmm2
movq -0xc28(%rbp), %rax
movsd 0x5d93(%rip), %xmm3     # 0xd010
mulsd 0x10(%rax), %xmm3
movq -0xc40(%rbp), %rax
movl 0xc(%rax), %edx
movq -0xc40(%rbp), %rax
movl (%rax), %ecx
movq -0xc40(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0xc40(%rbp), %rax
movl 0x8(%rax), %r9d
leaq 0x69cc(%rip), %rsi      # 0xdc7e
movb $0x4, %al
callq 0x2330
movq -0xb18(%rbp), %rdi
leaq 0x6044(%rip), %rsi      # 0xd30b
movb $0x0, %al
callq 0x2330
testb $0x1, 0xbf60(%rip)      # 0x13235
je 0x748f
movq -0xb58(%rbp), %rdi
movq -0xb60(%rbp), %rsi
movq -0xd60(%rbp), %rdx
movl -0xdc8(%rbp), %ecx
movq -0xd68(%rbp), %r8
movq -0xd70(%rbp), %r9
movq -0xd78(%rbp), %rax
movsd -0xad0(%rbp), %xmm0
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
callq 0x52a0
movq -0xb58(%rbp), %rdi
movq -0xb60(%rbp), %rsi
movq -0xd60(%rbp), %rdx
movl -0xdc8(%rbp), %ecx
movq -0xd98(%rbp), %r8
movq -0xda0(%rbp), %r9
movq -0xda8(%rbp), %rax
movsd -0xad0(%rbp), %xmm0
movq %rax, (%rsp)
movl $0x3, 0x8(%rsp)
callq 0x55a0
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x748d
movl $0x0, -0xdc4(%rbp)
cmpl $0x64, -0xdc4(%rbp)
jg 0x747d
movq -0xd68(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xd80(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0xd70(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xd88(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0xd98(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xdb0(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0xda0(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xdb8(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0xdc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc4(%rbp)
jmp 0x7388
jmp 0x747f
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7374
jmp 0x748f
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x7530
movq -0xc48(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0xc70(%rbp), %rax
movslq -0x30(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0xc50(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xc78(%rbp), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0xc38(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xc58(%rbp), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0xc40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0xc60(%rbp), %rax
movslq -0x30(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7496
movl -0xdc8(%rbp), %eax
addl -0xdcc(%rbp), %eax
movl %eax, -0xdcc(%rbp)
leaq -0x638(%rbp), %rdi
xorl %esi, %esi
callq 0x8fd0
movq %rax, -0x11e8(%rbp)
jmp 0x6d00
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x75fb
movq -0xc70(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0xc78(%rbp), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd 0x5a73(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0xc80(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xc58(%rbp), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movq -0xc60(%rbp), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd 0x5a33(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0xc68(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7563
testb $0x1, 0xbc33(%rip)      # 0x13235
je 0x7915
movl $0x0, -0x30(%rbp)
cmpl $0x4, -0x30(%rbp)
jge 0x7716
movl $0x0, -0xdc4(%rbp)
cmpl $0x64, -0xdc4(%rbp)
jg 0x7706
movq -0xd80(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movq -0xd88(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd 0x599a(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0xd90(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0xdb0(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movq -0xdb8(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
movsd 0x5939(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq -0xdc0(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0xdc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc4(%rbp)
jmp 0x7623
jmp 0x7708
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x760f
movq 0xb8a3(%rip), %rax      # 0x12fc0
movq (%rax), %rdi
movsd 0xbad8(%rip), %xmm0     # 0x13200
leaq 0x6577(%rip), %rsi      # 0xdca6
movb $0x1, %al
callq 0x2330
movq 0xb883(%rip), %rax      # 0x12fc0
movq (%rax), %rdi
leaq 0x6570(%rip), %rsi      # 0xdcb7
leaq 0x6578(%rip), %rdx      # 0xdcc6
leaq 0x6575(%rip), %rcx      # 0xdcca
movb $0x0, %al
callq 0x2330
movq 0xb85d(%rip), %rax      # 0x12fc0
movq (%rax), %rdi
leaq 0x6568(%rip), %rsi      # 0xdcd5
leaq 0x6582(%rip), %rdx      # 0xdcf6
leaq 0x6310(%rip), %r11      # 0xda8b
leaq 0x657a(%rip), %r10      # 0xdcfc
leaq 0x6572(%rip), %rax      # 0xdcfb
movq %r11, %rcx
movq %r10, %r8
movq %rax, %r9
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x2330
xorps %xmm0, %xmm0
movsd %xmm0, -0x11f0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x11f8(%rbp)
movl $0x0, -0xdc4(%rbp)
cmpl $0x64, -0xdc4(%rbp)
jg 0x7913
movq -0xd88(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movq -0xdb8(%rbp), %rax
movq (%rax), %rax
cvtsi2sdl 0xc(%rax), %xmm1
movsd 0x5806(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x57fe(%rip), %xmm1     # 0xd010
mulsd %xmm1, %xmm0
movsd %xmm0, -0x11f0(%rbp)
movq -0xdb8(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cvtsi2sdl 0xc(%rax), %xmm0
movq -0xdb8(%rbp), %rax
movq (%rax), %rax
cvtsi2sdl 0xc(%rax), %xmm1
movsd 0x57bc(%rip), %xmm2     # 0xd008
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x57b4(%rip), %xmm1     # 0xd010
mulsd %xmm1, %xmm0
movsd %xmm0, -0x11f8(%rbp)
movq 0xb751(%rip), %rax      # 0x12fc0
movq (%rax), %rdi
movl -0xdc4(%rbp), %edx
movq -0xd90(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd 0x577e(%rip), %xmm0     # 0xd010
mulsd 0x18(%rax), %xmm0
movq -0xd88(%rbp), %rax
movslq -0xdc4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0xc(%rax), %ecx
movsd -0x11f0(%rbp), %xmm1
movq -0xdc0(%rbp), %rax
movslq -0xdc4(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movsd 0x5742(%rip), %xmm2     # 0xd010
mulsd 0x18(%rax), %xmm2
movq -0xdb8(%rbp), %rax
movslq -0xdc4(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movl 0xc(%rax), %r8d
movsd -0x11f8(%rbp), %xmm3
leaq 0x640b(%rip), %rsi      # 0xdd03
movb $0x4, %al
callq 0x2330
movl -0xdc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xdc4(%rbp)
jmp 0x77c7
jmp 0x7915
movq -0xb18(%rbp), %rdi
movq -0xc80(%rbp), %rax
movsd 0x56e5(%rip), %xmm0     # 0xd010
mulsd 0x18(%rax), %xmm0
movq -0xc80(%rbp), %rax
movsd 0x56d1(%rip), %xmm1     # 0xd010
mulsd (%rax), %xmm1
movq -0xc80(%rbp), %rax
movsd 0x56be(%rip), %xmm2     # 0xd010
mulsd 0x8(%rax), %xmm2
movq -0xc80(%rbp), %rax
movsd 0x56aa(%rip), %xmm3     # 0xd010
mulsd 0x10(%rax), %xmm3
movq -0xc78(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0xc78(%rbp), %rax
movl (%rax), %r8d
movq -0xc78(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0xc78(%rbp), %rax
movl 0x8(%rax), %r10d
movl -0xdcc(%rbp), %eax
leaq 0x6389(%rip), %rsi      # 0xdd2b
leaq 0x63b5(%rip), %rdx      # 0xdd5e
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x4, %al
callq 0x2330
testb $0x1, -0x432(%rbp)
je 0x7a52
movq -0xb18(%rbp), %rdi
movq -0xc68(%rbp), %rax
movsd 0x5635(%rip), %xmm0     # 0xd010
mulsd 0x18(%rax), %xmm0
movq -0xc68(%rbp), %rax
movsd 0x5621(%rip), %xmm1     # 0xd010
mulsd (%rax), %xmm1
movq -0xc68(%rbp), %rax
movsd 0x560e(%rip), %xmm2     # 0xd010
mulsd 0x8(%rax), %xmm2
movq -0xc68(%rbp), %rax
movsd 0x55fa(%rip), %xmm3     # 0xd010
mulsd 0x10(%rax), %xmm3
movq -0xc60(%rbp), %rax
movl 0xc(%rax), %edx
movq -0xc60(%rbp), %rax
movl (%rax), %ecx
movq -0xc60(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0xc60(%rbp), %rax
movl 0x8(%rax), %r9d
leaq 0x6233(%rip), %rsi      # 0xdc7e
movb $0x4, %al
callq 0x2330
movq -0xb18(%rbp), %rdi
leaq 0x58ab(%rip), %rsi      # 0xd30b
movb $0x0, %al
callq 0x2330
cmpq $0x0, -0xb18(%rbp)
je 0x7a94
movq -0xb18(%rbp), %rax
movq 0xb541(%rip), %rcx      # 0x12fc0
cmpq (%rcx), %rax
je 0x7a94
movq -0xb18(%rbp), %rdi
callq 0x2210
jmp 0x7a92
jmp 0x7a94
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x894(%rbp)
leaq -0xd58(%rbp), %rdi
callq 0x9010
leaq -0xd48(%rbp), %rdi
callq 0x90a0
leaq -0xd38(%rbp), %rdi
callq 0x90a0
leaq -0xd28(%rbp), %rdi
callq 0x9010
leaq -0xd18(%rbp), %rdi
callq 0x90a0
leaq -0xd08(%rbp), %rdi
callq 0x90a0
leaq -0xcf8(%rbp), %rdi
callq 0x9010
leaq -0xce8(%rbp), %rdi
callq 0x90a0
leaq -0xcd8(%rbp), %rdi
callq 0x90a0
leaq -0xcc8(%rbp), %rdi
callq 0x9010
leaq -0xcb8(%rbp), %rdi
callq 0x90a0
leaq -0xca8(%rbp), %rdi
callq 0x90a0
leaq -0xc90(%rbp), %rdi
callq 0x9130
leaq -0xc20(%rbp), %rdi
callq 0x9130
leaq -0xc10(%rbp), %rdi
callq 0x9180
leaq -0xc00(%rbp), %rdi
callq 0x9130
leaq -0xbf0(%rbp), %rdi
callq 0x9130
leaq -0xbe0(%rbp), %rdi
callq 0x9180
leaq -0xbd0(%rbp), %rdi
callq 0x9180
leaq -0xbc0(%rbp), %rdi
callq 0x9180
leaq -0xbb0(%rbp), %rdi
callq 0x9130
leaq -0xba0(%rbp), %rdi
callq 0x9180
leaq -0xb90(%rbp), %rdi
callq 0x9180
leaq -0xb80(%rbp), %rdi
callq 0x9130
leaq -0xb70(%rbp), %rdi
callq 0x9130
leaq -0xb48(%rbp), %rdi
callq 0x8360
leaq -0xb38(%rbp), %rdi
callq 0x8360
leaq -0xb28(%rbp), %rdi
callq 0x8360
jmp 0x7d40
leaq -0xd48(%rbp), %rdi
callq 0x90a0
leaq -0xd38(%rbp), %rdi
callq 0x90a0
leaq -0xd28(%rbp), %rdi
callq 0x9010
leaq -0xd18(%rbp), %rdi
callq 0x90a0
leaq -0xd08(%rbp), %rdi
callq 0x90a0
leaq -0xcf8(%rbp), %rdi
callq 0x9010
leaq -0xce8(%rbp), %rdi
callq 0x90a0
leaq -0xcd8(%rbp), %rdi
callq 0x90a0
leaq -0xcc8(%rbp), %rdi
callq 0x9010
leaq -0xcb8(%rbp), %rdi
callq 0x90a0
leaq -0xca8(%rbp), %rdi
callq 0x90a0
leaq -0xc90(%rbp), %rdi
callq 0x9130
leaq -0xc20(%rbp), %rdi
callq 0x9130
leaq -0xc10(%rbp), %rdi
callq 0x9180
leaq -0xc00(%rbp), %rdi
callq 0x9130
leaq -0xbf0(%rbp), %rdi
callq 0x9130
leaq -0xbe0(%rbp), %rdi
callq 0x9180
leaq -0xbd0(%rbp), %rdi
callq 0x9180
leaq -0xbc0(%rbp), %rdi
callq 0x9180
leaq -0xbb0(%rbp), %rdi
callq 0x9130
leaq -0xba0(%rbp), %rdi
callq 0x9180
leaq -0xb90(%rbp), %rdi
callq 0x9180
leaq -0xb80(%rbp), %rdi
callq 0x9130
leaq -0xb70(%rbp), %rdi
callq 0x9130
leaq -0xb48(%rbp), %rdi
callq 0x8360
leaq -0xb38(%rbp), %rdi
callq 0x8360
leaq -0xb28(%rbp), %rdi
callq 0x8360
jmp 0x7d5a
leaq -0x878(%rbp), %rdi
callq 0x8360
leaq -0x668(%rbp), %rdi
callq 0x91d0
jmp 0x7d74
leaq -0x878(%rbp), %rdi
callq 0x8360
leaq -0x668(%rbp), %rdi
callq 0x91d0
jmp 0x7d85
movl -0x1c(%rbp), %eax
addq $0x12a8, %rsp           # imm = 0x12A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x880(%rbp), %rdi
callq 0x2380
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)