// File: /workspace/github_c_makefile_star2_O0/Gaurang18[P]Compiler-Project-BITS-Pilani/./symboltable.c
// Function: populateSymbolTable
void populateSymbolTable(FILE *fp, parsetree head, char *scope){

    if(head==NULL)
        return;

    if(head->value==4){
         hash_insert_func("driver","", "");
         strcpy(scope, "driver");
         // assert(0);
        }

    populateSymbolTable(fp, head->child, scope);

    

    if(head->value==106){

        if(head->parent->value==5)
        {
            
            if(check_func_present(head->Lex->tk->value))
                fprintf(fp,"ERROR 1: Function %s already Defined, Erroneous declaration, line number %d", head->Lex->tk->value,head->Lex->tk->line);
            else{

                parsetree root = head;
                while(root->value!=1)
                    root = root->parent;


                
                populateFunctionDefinitions(fp, root, head->Lex->tk->value);
                //if(check_func_present(head->Lex->tk->value))
                    //printf("Yay\n");
            }
        }

        if(head->parent->value == 7)
        {
            if(!check_func_present(head->Lex->tk->value))
                populateFunctionDefinitions(fp, head, head->Lex->tk->value);
        }



        //Changes scope
        if(head->parent->value==7)
        {
            strcpy(scope, head->Lex->tk->value);
        }

        //Declare Statements

        if(head->parent->value == 33 && head->parent->parent->value==20)
        {   
            if(checksymbolpresent(head->Lex->tk->value, scope))
                fprintf(fp,"ERROR 9: Redeclaration of variable %s in the same scope, line number %d\n", head->Lex->tk->value, head->Lex->tk->line);
            
            
            switch(head->parent->right->rule)
            {
                case 18: hashinsert(head->Lex->tk->value,"INTEGER",scope,"___");
                    break;
                case 19:hashinsert(head->Lex->tk->value,"REAL",scope,"___");
                    break;
                case 20:hashinsert(head->Lex->tk->value,"BOOLEAN",scope,"___");
                    break;
                case 21: 

                    // int range = atoi(head->parent->right->child->right->child->right->right->Lex->tk->value) - atoi(head->parent->right->child->right->child->Lex->tk->value);
                    // char value[3] = {"0"};
                    // value[0] = range;
                    // value[1] = '\0';
                    {parsetree range = head->parent->right->child->right;
                    int r1 = atoi(range->child->Lex->tk->value);
                    int r2 = atoi(range->child->right->right->Lex->tk->value);
                    int r = r2 -r1 +1;
                    char size[3];
                    ////sprintf(size,"%d",r);

                    // printf("range %d\n", r);
                    char type[100] = {'\0'};



                    switch(range->right->rule){
                        case 22: strcat(type, "ARRAY(INTEGER, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 23:strcat(type, "ARRAY(REAL, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 24:strcat(type, "ARRAY(BOOLEAN, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                    }}
                    break;
            }
        }

        //Declaring more than one identifier

        if(head->parent->value == 34)
        {
                parsetree temphead = head;
                while(temphead->parent->value!=33)
                    temphead = temphead->parent;

            if(temphead->parent->value == 33 && temphead->parent->parent->value==20){
            
            switch(temphead->parent->right->rule)
            {
                case 18: hashinsert(head->Lex->tk->value,"INTEGER",scope,"___");
                    break;
                case 19:hashinsert(head->Lex->tk->value,"REAL",scope,"___");
                    break;
                case 20:hashinsert(head->Lex->tk->value,"BOOLEAN",scope,"___");
                    break;
                case 21: 

                    // int range = atoi(head->parent->right->child->right->child->right->right->Lex->tk->value) - atoi(head->parent->right->child->right->child->Lex->tk->value);
                    // char value[3] = {"0"};
                    // value[0] = range;
                    // value[1] = '\0';
                    {parsetree range = temphead->parent->right->child->right;
                    int r1 = atoi(range->child->Lex->tk->value);
                    int r2 = atoi(range->child->right->right->Lex->tk->value);
                    int r = r2 -r1 +1;
                    char size[3];
                    //sprintf(size,"%d",r);

                    // printf("range %d\n", r);
                    char type[100] = {'\0'};



                    switch(range->right->rule){
                        case 22: strcat(type, "ARRAY(INTEGER, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 23:strcat(type, "ARRAY(REAL, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 24:strcat(type, "ARRAY(BOOLEAN, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                    }}
                    break;
            }
        }}

        //input parameters declaration

        if(head->parent->value == 8 || head->parent->value == 9){

            

            // printf("%s \n", head->Lex->tk->value);

            switch(head->right->rule){
                case 18: hashinsert(head->Lex->tk->value,"INTEGER",scope,"___");
                    break;
                case 19:hashinsert(head->Lex->tk->value,"REAL",scope,"___");
                    break;
                case 20:hashinsert(head->Lex->tk->value,"BOOLEAN",scope,"___");
                    break;
                case 21: 

                    // int range = atoi(head->parent->right->child->right->child->right->right->Lex->tk->value) - atoi(head->parent->right->child->right->child->Lex->tk->value);
                    // char value[3] = {"0"};
                    // value[0] = range;
                    // value[1] = '\0';
                    {parsetree range = head->right->child->right;

                   int r1 = atoi(range->child->Lex->tk->value);
                    int r2 = atoi(range->child->right->right->Lex->tk->value);
                    int r = r2 -r1 + 1;
                    char size[3];
                    //sprintf(size,"%d",r);

                    // printf("range %d\n", r);

                    char type[100] = {'\0'};



                    switch(range->right->rule){
                        case 22: strcat(type, "ARRAY(INTEGER, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 23:strcat(type, "ARRAY(REAL, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                        case 24:strcat(type, "ARRAY(BOOLEAN, ");
                                 strcat(type, size);
                                 strcat(type, ")");
                                 hashinsert(head->Lex->tk->value, type ,scope, "___");
                                break;
                    }}
                    break;
            }

        }

        //outputparameters declaration

        if(head->parent->value == 11 || head->parent->value == 12){

        

            // printf("%s \n", head->Lex->tk->value);

            switch(head->right->rule){
                        case 22: hashinsert(head->Lex->tk->value,"INTEGER",scope, "___");
                        break;
                        case 23:hashinsert(head->Lex->tk->value,"REAL",scope,"___");
                        break;
                        case 24:hashinsert(head->Lex->tk->value,"BOOLEAN",scope,"___");
                        break;
                    }
        }


        // display(scope);
        // printf("------------------\n");

        if(head->parent->value != 7 && head->parent->value != 5 && head->parent->value != 26 && !checksymbolpresent(head->Lex->tk->value, scope))
            fprintf(fp,"ERROR 2: identifier %s not declared, line number %d\n", head->Lex->tk->value, head->Lex->tk->line);


        //Module Reuse Statement

        if(head->parent->value == 26){
            if(!check_func_present(head->Lex->tk->value))
                fprintf(fp,"ERROR 3: Function definition for %s not found, line number %d\n", head->Lex->tk->value, head->Lex->tk->line);

            else{

                char inputtype[1000] = {'\0'};
                char outputtype[1000] = {'\0'};
                if(head->parent->child->rule == 56){
                    parsetree outlist = head->parent->child->child;
                    strcat(outputtype, gettype(outlist->child->Lex->tk->value, scope));
                    parsetree outlistprime = outlist->child->right;

                    while(outlistprime->rule!= 59){
                        strcat(outputtype, "; ");
                        strcat(outputtype, gettype(outlistprime->child->Lex->tk->value, scope));
                        outlistprime = outlistprime->child->right;
                    }
                }

                parsetree inputlist = head->right;
                strcat(inputtype, gettype(inputlist->child->Lex->tk->value, scope));

                parsetree inputlistprime = inputlist->child->right;

                    while(inputlistprime->rule!= 59){
                        strcat(inputtype, "; ");
                        strcat(inputtype, gettype(inputlistprime->child->Lex->tk->value, scope));
                        inputlistprime = inputlistprime->child->right;
                    }
                 
                if(strcmp(inputtype, get_Function_input_type(head->Lex->tk->value))!=0){
                    fprintf(fp,"\nERROR 4: input types do not match at line number %d \n", head->Lex->tk->line);
                    fprintf(fp,"Entered input parameters - %s\n", inputtype);
                    fprintf(fp,"Expected input parameters - %s\n", get_Function_input_type(head->Lex->tk->value));
                }
                if(strcmp(outputtype, get_Function_output_type(head->Lex->tk->value))!=0){
                    fprintf(fp,"\nERROR 5: output types do not match at line number %d\n", head->Lex->tk->line);
                    fprintf(fp,"Entered output parameters - %s\n", outputtype);
                    fprintf(fp,"Expected output parameters - %s\n", get_Function_output_type(head->Lex->tk->value));
                }





            }
          }

          //Check that array index is always integer
          if(head->parent->value==24){
            //assert(0);
            if(strcmp(gettype(head->Lex->tk->value, scope), "INTEGER")!=0)
                fprintf(fp,"ERROR 6: Array index should be of type integer but here, %s has type %s, line number %d\n", head->Lex->tk->value, gettype(head->Lex->tk->value, scope), head->Lex->tk->line);
            }

          if(head->parent->rule == 41 && head->right->rule==44)
          {
            //char[100] type = {'\0'};
            //type = gettype(head->Lex->tk->value, scope);
            char *token = NULL;
            token = strtok(gettype(head->Lex->tk->value, scope), "(");
            if(token==NULL)
                fprintf(fp,"ERROR 7: Indexing cannot be done on %s which is not an array, but of type %s , line number %d\n", head->Lex->tk->value, gettype(head->Lex->tk->value, scope), head->Lex->tk->line);
            if(strcmp(token,"ARRAY")!=0){
                fprintf(fp,"ERROR 8: Indexing cannot be done on %s which is not an array, but of type %s , line number %d\n", head->Lex->tk->value, gettype(head->Lex->tk->value, scope), head->Lex->tk->line);
            }
          }

          
    }

    //type checking for assignment
    if(head->value==100 && (head->parent->value == 28 || head->parent->value == 29)){
        //printf("Type checking for line number %d\n", head->Lex->tk->line);
        int err = TypeChecker(fp, head, scope);
        //printf("err is %d\n", err);
    }

    if(head->value==21){
        int type2, error = 0;
        int type = TypeChecker(fp, head->child->right, scope);
        parsetree caseStmts = head->child->right->right->right;
        //assert(0);

        if(type==1)
            fprintf(fp,"ERROR 9: The switch statement cannot have identifier of type real, line number %d\n", head->Lex->tk->line);

        else{

            if(type==0 && caseStmts->right->rule != 85)
                fprintf(fp,"ERROR 10: The switch statement has identifier of type integer but no default statement, line number %d\n", head->Lex->tk->line);

            if(type==-1 && caseStmts->right->rule != 84)
                fprintf(fp,"ERROR 11: The switch statement has identifier of type boolean cannot have default statement, line number %d\n", caseStmts->right->Lex->tk->line);



             while(caseStmts->child->value!=109)
            {   
                // printf("%s\n", terms[caseStmts->child->right->child->value]);
                type2 = TypeChecker(fp, caseStmts->child->right->child, scope);

                if(type == type2){
                    caseStmts = caseStmts->child->right->right->right->right;
                    //assert(0);
                }
                else
                {   
                    error = 1;
                    break;
                }

            }

        }
       
        if(error){

            fprintf(fp,"ERROR 12: The type of identifier of switch statement is different from the types of case labels, line number %d\n", caseStmts->child->right->child->Lex->tk->line);
        }
    }

    if(head->value==22 && head->rule==39){
        int type = TypeChecker(fp, head->child->right, scope);
        if(type!=0)
            fprintf(fp,"ERROR 13: The identifier in FOR loop has to be integer, line number %d\n", head->Lex->tk->line);

    }

    if(head->value==22 && head->rule==40){
        int type = TypeChecker(fp, head->child->right, scope);
        if(type!=-1)
            fprintf(fp,"ERROR 14: The expression in WHILE loop has to be of type boolean, line number %d\n", head->Lex->tk->line);



    }




    populateSymbolTable(fp, head->right, scope);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp            # imm = 0xA80
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x87c3
jmp 0x9bb1
movq -0x10(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x87f3
leaq 0x3b8b(%rip), %rdi      # 0xc35f
leaq 0x4ef0(%rip), %rdx      # 0xd6cb
movq %rdx, %rsi
callq 0x63e0
movq -0x18(%rbp), %rdi
leaq 0x3b71(%rip), %rsi      # 0xc35f
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x87a0
movq -0x10(%rbp), %rax
cmpl $0x6a, 0x8(%rax)
jne 0x98f9
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x5, 0x8(%rax)
jne 0x88ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x6a60
cmpl $0x0, %eax
je 0x886f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %ecx
leaq 0x43ed(%rip), %rsi      # 0xcc53
movb $0x0, %al
callq 0x2100
jmp 0x88aa
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x888f
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8877
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
callq 0x80c0
jmp 0x88ac
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x7, 0x8(%rax)
jne 0x88ef
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x6a60
cmpl $0x0, %eax
jne 0x88ed
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
callq 0x80c0
jmp 0x88ef
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x7, 0x8(%rax)
jne 0x8914
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
addq $0x1e, %rsi
callq 0x2050
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x21, 0x8(%rax)
jne 0x8c1c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
cmpl $0x14, 0x8(%rax)
jne 0x8c1c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x71d0
cmpl $0x0, %eax
je 0x8985
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %ecx
leaq 0x4321(%rip), %rsi      # 0xcc9f
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, -0x9e0(%rbp)
subl $0x3, %eax
ja 0x8c1a
movq -0x9e0(%rbp), %rax
leaq 0x38b5(%rip), %rcx      # 0xc26c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x422e(%rip), %rsi      # 0xcc07
leaq 0x4308(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c1a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x420e(%rip), %rsi      # 0xcc11
leaq 0x42de(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c1a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x41eb(%rip), %rsi      # 0xcc18
leaq 0x42b4(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c1a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x2c(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x34(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x9e4(%rbp)
subl $0x16, %eax
je 0x8b00
jmp 0x8adf
movl -0x9e4(%rbp), %eax
subl $0x17, %eax
je 0x8b60
jmp 0x8aec
movl -0x9e4(%rbp), %eax
subl $0x18, %eax
je 0x8bbd
jmp 0x8c18
leaq -0xa0(%rbp), %rdi
leaq 0x4114(%rip), %rsi      # 0xcc22
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq -0x37(%rbp), %rsi
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq 0x475b(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x4192(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c18
leaq -0xa0(%rbp), %rdi
leaq 0x40c6(%rip), %rsi      # 0xcc34
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq -0x37(%rbp), %rsi
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq 0x46fb(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x4132(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c18
leaq -0xa0(%rbp), %rdi
leaq 0x4078(%rip), %rsi      # 0xcc43
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq -0x37(%rbp), %rsi
callq 0x2190
leaq -0xa0(%rbp), %rdi
leaq 0x469e(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x40d5(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8c1a
jmp 0x8c1c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x22, 0x8(%rax)
jne 0x8f5e
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x21, 0x8(%rax)
je 0x8c5e
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xa8(%rbp)
jmp 0x8c39
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x21, 0x8(%rax)
jne 0x8f5c
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
cmpl $0x14, 0x8(%rax)
jne 0x8f5c
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, -0x9f0(%rbp)
subl $0x3, %eax
ja 0x8f5a
movq -0x9f0(%rbp), %rax
leaq 0x35bb(%rip), %rcx      # 0xc27c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3f24(%rip), %rsi      # 0xcc07
leaq 0x3ffe(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3f04(%rip), %rsi      # 0xcc11
leaq 0x3fd4(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3ee1(%rip), %rsi      # 0xcc18
leaq 0x3faa(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f5a
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0xb4(%rbp)
movq -0xb0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %eax
movl -0xb4(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0xbc(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0xe0(%rbp)
movaps %xmm0, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
movaps %xmm0, -0x110(%rbp)
movaps %xmm0, -0x120(%rbp)
movaps %xmm0, -0x130(%rbp)
movl $0x0, -0xd0(%rbp)
movq -0xb0(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x9f4(%rbp)
subl $0x16, %eax
je 0x8e37
jmp 0x8e16
movl -0x9f4(%rbp), %eax
subl $0x17, %eax
je 0x8e9a
jmp 0x8e23
movl -0x9f4(%rbp), %eax
subl $0x18, %eax
je 0x8efa
jmp 0x8f58
leaq -0x130(%rbp), %rdi
leaq 0x3ddd(%rip), %rsi      # 0xcc22
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq -0xbf(%rbp), %rsi
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq 0x4421(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x130(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3e58(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f58
leaq -0x130(%rbp), %rdi
leaq 0x3d8c(%rip), %rsi      # 0xcc34
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq -0xbf(%rbp), %rsi
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq 0x43be(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x130(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3df5(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f58
leaq -0x130(%rbp), %rdi
leaq 0x3d3b(%rip), %rsi      # 0xcc43
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq -0xbf(%rbp), %rsi
callq 0x2190
leaq -0x130(%rbp), %rdi
leaq 0x435e(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x130(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3d95(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x8f5a
jmp 0x8f5c
jmp 0x8f5e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x8, 0x8(%rax)
je 0x8f7e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x9, 0x8(%rax)
jne 0x9240
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, -0xa00(%rbp)
subl $0x3, %eax
ja 0x923e
movq -0xa00(%rbp), %rax
leaq 0x32e0(%rip), %rcx      # 0xc28c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c39(%rip), %rsi      # 0xcc07
leaq 0x3d13(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c19(%rip), %rsi      # 0xcc11
leaq 0x3ce9(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x3bf6(%rip), %rsi      # 0xcc18
leaq 0x3cbf(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0x13c(%rbp)
movq -0x138(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x2170
movl %eax, -0x140(%rbp)
movl -0x140(%rbp), %eax
movl -0x13c(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x144(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x160(%rbp)
movaps %xmm0, -0x170(%rbp)
movaps %xmm0, -0x180(%rbp)
movaps %xmm0, -0x190(%rbp)
movaps %xmm0, -0x1a0(%rbp)
movaps %xmm0, -0x1b0(%rbp)
movl $0x0, -0x150(%rbp)
movq -0x138(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0xa04(%rbp)
subl $0x16, %eax
je 0x911b
jmp 0x90fa
movl -0xa04(%rbp), %eax
subl $0x17, %eax
je 0x917e
jmp 0x9107
movl -0xa04(%rbp), %eax
subl $0x18, %eax
je 0x91de
jmp 0x923c
leaq -0x1b0(%rbp), %rdi
leaq 0x3af9(%rip), %rsi      # 0xcc22
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq -0x147(%rbp), %rsi
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq 0x413d(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x1b0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3b74(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923c
leaq -0x1b0(%rbp), %rdi
leaq 0x3aa8(%rip), %rsi      # 0xcc34
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq -0x147(%rbp), %rsi
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq 0x40da(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x1b0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3b11(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923c
leaq -0x1b0(%rbp), %rdi
leaq 0x3a57(%rip), %rsi      # 0xcc43
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq -0x147(%rbp), %rsi
callq 0x2190
leaq -0x1b0(%rbp), %rdi
leaq 0x407a(%rip), %rsi      # 0xd28c
callq 0x2190
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
leaq -0x1b0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3ab1(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x923e
jmp 0x9240
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xb, 0x8(%rax)
je 0x9260
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0xc, 0x8(%rax)
jne 0x9307
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0xa08(%rbp)
subl $0x16, %eax
je 0x9292
jmp 0x9278
movl -0xa08(%rbp), %eax
subl $0x17, %eax
je 0x92b9
jmp 0x9285
movl -0xa08(%rbp), %eax
subl $0x18, %eax
je 0x92e0
jmp 0x9305
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x395c(%rip), %rsi      # 0xcc07
leaq 0x3a36(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x9305
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x393f(%rip), %rsi      # 0xcc11
leaq 0x3a0f(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x9305
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rdx
leaq 0x391f(%rip), %rsi      # 0xcc18
leaq 0x39e8(%rip), %rcx      # 0xcce8
callq 0x6bd0
jmp 0x9307
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x7, 0x8(%rax)
je 0x937a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x5, 0x8(%rax)
je 0x937a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1a, 0x8(%rax)
je 0x937a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x71d0
cmpl $0x0, %eax
jne 0x937a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %ecx
leaq 0x3979(%rip), %rsi      # 0xccec
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1a, 0x8(%rax)
jne 0x970c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x6a60
cmpl $0x0, %eax
jne 0x93d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
addq $0x1e, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %ecx
leaq 0x3957(%rip), %rsi      # 0xcd21
movb $0x0, %al
callq 0x2100
jmp 0x970a
leaq -0x5a0(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
leaq -0x990(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x20c0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x38, 0xc(%rax)
jne 0x94ef
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x998(%rbp)
leaq -0x990(%rbp), %rax
movq %rax, -0xa10(%rbp)
movq -0x998(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa10(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq -0x998(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9a0(%rbp)
movq -0x9a0(%rbp), %rax
cmpl $0x3b, 0xc(%rax)
je 0x94ed
leaq -0x990(%rbp), %rdi
leaq 0x38cb(%rip), %rsi      # 0xcd60
callq 0x2190
leaq -0x990(%rbp), %rax
movq %rax, -0xa18(%rbp)
movq -0x9a0(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa18(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq -0x9a0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9a0(%rbp)
jmp 0x947a
jmp 0x94ef
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9a8(%rbp)
leaq -0x5a0(%rbp), %rax
movq %rax, -0xa20(%rbp)
movq -0x9a8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa20(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq -0x9a8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9b0(%rbp)
movq -0x9b0(%rbp), %rax
cmpl $0x3b, 0xc(%rax)
je 0x95c2
leaq -0x5a0(%rbp), %rdi
leaq 0x37f6(%rip), %rsi      # 0xcd60
callq 0x2190
leaq -0x5a0(%rbp), %rax
movq %rax, -0xa28(%rbp)
movq -0x9b0(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa28(%rbp), %rdi
movq %rax, %rsi
callq 0x2190
movq -0x9b0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9b0(%rbp)
jmp 0x954f
leaq -0x5a0(%rbp), %rax
movq %rax, -0xa30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x68a0
movq -0xa30(%rbp), %rdi
movq %rax, %rsi
callq 0x20f0
cmpl $0x0, %eax
je 0x9665
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x3754(%rip), %rsi      # 0xcd63
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
leaq -0x5a0(%rbp), %rdx
leaq 0x3772(%rip), %rsi      # 0xcd9a
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq %rax, -0xa38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x68a0
movq -0xa38(%rbp), %rdi
movq %rax, %rdx
leaq 0x375b(%rip), %rsi      # 0xcdb9
movb $0x0, %al
callq 0x2100
leaq -0x990(%rbp), %rax
movq %rax, -0xa40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x6980
movq -0xa40(%rbp), %rdi
movq %rax, %rsi
callq 0x20f0
cmpl $0x0, %eax
je 0x9708
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x3727(%rip), %rsi      # 0xcdd9
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rdi
leaq -0x990(%rbp), %rdx
leaq 0x3745(%rip), %rsi      # 0xce10
movb $0x0, %al
callq 0x2100
movq -0x8(%rbp), %rax
movq %rax, -0xa48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
callq 0x6980
movq -0xa48(%rbp), %rdi
movq %rax, %rdx
leaq 0x372f(%rip), %rsi      # 0xce30
movb $0x0, %al
callq 0x2100
jmp 0x970a
jmp 0x970c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x18, 0x8(%rax)
jne 0x97af
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq %rax, %rdi
leaq 0x34c8(%rip), %rsi      # 0xcc07
callq 0x20f0
cmpl $0x0, %eax
je 0x97ad
movq -0x8(%rbp), %rax
movq %rax, -0xa58(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq $0x1e, %rax
movq %rax, -0xa50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa58(%rbp), %rdi
movq -0xa50(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %r8d
leaq 0x36ab(%rip), %rsi      # 0xce51
movb $0x0, %al
callq 0x2100
jmp 0x97af
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x29, 0xc(%rax)
jne 0x98f7
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x2c, 0xc(%rax)
jne 0x98f7
movq $0x0, -0x9b8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq %rax, %rdi
leaq 0x2cdb(%rip), %rsi      # 0xc4da
callq 0x2160
movq %rax, -0x9b8(%rbp)
cmpq $0x0, -0x9b8(%rbp)
jne 0x9879
movq -0x8(%rbp), %rax
movq %rax, -0xa68(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq $0x1e, %rax
movq %rax, -0xa60(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa68(%rbp), %rdi
movq -0xa60(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %r8d
leaq 0x3638(%rip), %rsi      # 0xceaa
movb $0x0, %al
callq 0x2100
movq -0x9b8(%rbp), %rdi
leaq 0x2b58(%rip), %rsi      # 0xc3df
callq 0x20f0
cmpl $0x0, %eax
je 0x98f5
movq -0x8(%rbp), %rax
movq %rax, -0xa78(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
addq $0x1e, %rax
movq %rax, -0xa70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
addq $0x1e, %rdi
movq -0x18(%rbp), %rsi
callq 0x7340
movq -0xa78(%rbp), %rdi
movq -0xa70(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %r8d
leaq 0x361b(%rip), %rsi      # 0xcf09
movb $0x0, %al
callq 0x2100
jmp 0x98f7
jmp 0x98f9
movq -0x10(%rbp), %rax
cmpl $0x64, 0x8(%rax)
jne 0x9936
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1c, 0x8(%rax)
je 0x991f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1d, 0x8(%rax)
jne 0x9936
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7670
movl %eax, -0x9bc(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x15, 0x8(%rax)
jne 0x9ae2
movl $0x0, -0x9c4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7670
movl %eax, -0x9c8(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9d0(%rbp)
cmpl $0x1, -0x9c8(%rbp)
jne 0x99b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35bf(%rip), %rsi      # 0xcf68
movb $0x0, %al
callq 0x2100
jmp 0x9aa9
cmpl $0x0, -0x9c8(%rbp)
jne 0x99ee
movq -0x9d0(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x55, 0xc(%rax)
je 0x99ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35d4(%rip), %rsi      # 0xcfbb
movb $0x0, %al
callq 0x2100
cmpl $-0x1, -0x9c8(%rbp)
jne 0x9a2e
movq -0x9d0(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x54, 0xc(%rax)
je 0x9a2e
movq -0x8(%rbp), %rdi
movq -0x9d0(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35fc(%rip), %rsi      # 0xd023
movb $0x0, %al
callq 0x2100
jmp 0x9a30
movq -0x9d0(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x6d, 0x8(%rax)
je 0x9aa7
movq -0x8(%rbp), %rdi
movq -0x9d0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7670
movl %eax, -0x9c0(%rbp)
movl -0x9c8(%rbp), %eax
cmpl -0x9c0(%rbp), %eax
jne 0x9a99
movq -0x9d0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x9d0(%rbp)
jmp 0x9aa5
movl $0x1, -0x9c4(%rbp)
jmp 0x9aa7
jmp 0x9a30
jmp 0x9aa9
cmpl $0x0, -0x9c4(%rbp)
je 0x9ae0
movq -0x8(%rbp), %rdi
movq -0x9d0(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35b7(%rip), %rsi      # 0xd090
movb $0x0, %al
callq 0x2100
jmp 0x9ae2
movq -0x10(%rbp), %rax
cmpl $0x16, 0x8(%rax)
jne 0x9b3f
movq -0x10(%rbp), %rax
cmpl $0x27, 0xc(%rax)
jne 0x9b3f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7670
movl %eax, -0x9d4(%rbp)
cmpl $0x0, -0x9d4(%rbp)
je 0x9b3d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35cb(%rip), %rsi      # 0xd101
movb $0x0, %al
callq 0x2100
jmp 0x9b3f
movq -0x10(%rbp), %rax
cmpl $0x16, 0x8(%rax)
jne 0x9b9c
movq -0x10(%rbp), %rax
cmpl $0x28, 0xc(%rax)
jne 0x9b9c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x7670
movl %eax, -0x9d8(%rbp)
cmpl $-0x1, -0x9d8(%rbp)
je 0x9b9a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0x3c(%rax), %edx
leaq 0x35b6(%rip), %rsi      # 0xd149
movb $0x0, %al
callq 0x2100
jmp 0x9b9c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x87a0
addq $0xa80, %rsp            # imm = 0xA80
popq %rbp
retq
nopw (%rax,%rax)