// File: kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/check.cpp
// Function: AST_op::fill_and_check(symbol_table*)
void AST_op::fill_and_check(symbol_table* st){
    if ( left )
        left->fill_and_check(st);
    
    if ( right )
        right->fill_and_check(st);
    
    if ( !left || !right ){
        return;
    }
    
    // Ambos argumentos son invalidos
    if ( left->type == INVALID && right->type == INVALID ){
        type = INVALID;
        logger->error(line, column);
        return;
    }
    
    /* Un solo argumento invalido, tratar de validar el otro y colocar el valor
    * de la expresion segun el valor de ese argumento
    */
    else if ( left->type == INVALID || right->type == INVALID ){
        AST_expression* valido;
        char* nombre_valido;
        
        if ( left->type != INVALID ){
            valido = left;
            nombre_valido = (char*)"izquierdo";
        } else {
            valido = right;
            nombre_valido = (char*)"derecho";
        }
        
        switch( oper_type ){
            
            case MOD:
                
                type = INT;
                
                if ( valido->type != INT ){
                    logger->buf << "Operando '" << nombre_valido
                                << "' de tipo '" << types.types[valido->type]->name
                                << "', esperando int.";
                    logger->error(line, column);
                }
                break;
                
            /* Operadores aritmeticos: suma, resta, multiplicacion y division */
            case PLUS:
            case MINUS:
            case PROD:
            case DIV:
                
                if ( valido->type == INT
                     || valido->type == FLOAT
                   )
                {
                    type = valido->type;
                } else {
                    logger->buf << "Operando '" << nombre_valido
                                << "' de tipo '" << types.types[valido->type]->name
                                << "', esperando float o int.";
                    logger->error(line, column);
                }
                break;
            
            /* Operadores logicos: y, o, implica, consecuencia */
            case AND:
            case OR:
            case IMP:
            case CONSEQ:
                
                if ( valido->type == BOOLEAN ){
                    type = BOOLEAN;
                } else {
                    logger->buf << "Operando '" << nombre_valido
                                << "' de tipo '" << types.types[valido->type]->name
                                << "', esperando boolean.";
                    logger->error(line, column);
                }
                break;
            
            /* Operadores de comparación de igualdad: ==, != */
            case EQ:
            case UNEQ:
            
                type = BOOLEAN;
                break;
            
            /* Operadores de relación de orden: <, <=, >, >= */
            case LESS:
            case LESS_EQ:
            case GREAT:
            case GREAT_EQ:
            
                type = BOOLEAN;
                if (    valido->type != INT
                     && valido->type != FLOAT
                     && valido->type != CHAR
                   )
                {
                    logger->buf << "Operando '" << nombre_valido
                                << "' de tipo '" << types.types[valido->type]->name
                                << "', esperando float o int.";
                    logger->error(line, column);
                }
                break;
        }
        return;
    }
    
    /* else */
    
    // Ambos argumentos validos
    switch( oper_type ){
        
        case MOD:
            type = INT;
            
            if ( left->type != INT ){
                logger->buf << "Operando izquierdo de tipo '" << types.types[left->type]->name
                            << "', esperando int.";
                logger->error(line, column);
            } else if ( right->type != INT ) {
                logger->buf << "Operando derecho de tipo '" << types.types[right->type]->name
                            << "', esperando int.";
                logger->error(line, column);
            }
            
            break;
            
        /* Operadores aritmeticos: suma, resta, multiplicacion y division */
        case PLUS:
        case MINUS:
        case PROD:
        case DIV:
            
            if ( left->type == right->type ) {
                if ( left->type == INT || left->type == FLOAT )
                {
                    type = left->type;
                } else {
                    // Error de ambos argumentos con tipos invalidos
                    logger->buf << "Operando izquierdo de tipo '" << types.types[left->type]->name
                                << "', esperando float o int.";
                    logger->error(line, column);
                    
                    type = INVALID;
                }
                
            } else {
                // Argumento derecho con tipo invalido
                logger->buf << "Operandos de tipos incompatibles '"
                            << types.types[left->type]->name << "' y '"
                            << types.types[right->type]->name << "'";
                logger->error(line, column);
                type = INVALID;
            }
            break;
        
        /* Operadores logicos: y, o, implica, consecuencia */
        case AND:
        case OR:
        case IMP:
        case CONSEQ:
            
            if ( left->type == right->type )
            {
                type = BOOLEAN;
                if ( left->type != BOOLEAN )
                {
                    logger->buf << "Operandos de tipo '" << types.types[left->type]->name
                                << "', esperando boolean.";
                    logger->error(line, column);
                }
                
            } else {
                // Error de ambos argumentos con tipos invalidos
                logger->buf << "Operandos de tipos '"
                            << types.types[left->type]->name << "' y '"
                            << types.types[right->type]->name << "' esperados boolean.";
                logger->error(line, column);
            }
            
            break;
        
        /* Operadores de comparación de igualdad: ==, != */
        case EQ:
        case UNEQ:
            
            type = BOOLEAN;
            if ( left->type != right->type )
            {
                // Error de ambos argumentos con tipos invalidos
                logger->buf << "Operandos de tipos imcompratibles '"
                            << types.types[left->type]->name << "' y '"
                            << types.types[right->type]->name << "'";
                logger->error(line, column);
            }
            
            break;
        
        /* Operadores de relación de orden: <, <=, >, >= */
        case LESS:
        case LESS_EQ:
        case GREAT:
        case GREAT_EQ:
            
            type = BOOLEAN;
            
            if ( left->type == right->type )
            {
                if (    left->type != INT
                     && left->type != FLOAT
                     && left->type != CHAR
                   )
                {
                    // Error de ambos argumentos con tipos invalidos
                    logger->buf << "Operandos de tipos '"
                                << types.types[left->type]->name
                                << "' esperando float, int o char";
                    logger->error(line, column);
                }
                
            } else {
                // Error de ambos argumentos con tipos invalidos
                logger->buf << "Operandos de tipos imcompratibles '"
                            << types.types[left->type]->name << "' y '"
                            << types.types[right->type]->name << "'";
                logger->error(line, column);
            }
            
            break;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0x58(%rax)
je 0xb198
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0xb8(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa0(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0xb1c1
movq 0xa0(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0xb8(%rsp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa0(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0xb1df
movq 0xa0(%rsp), %rax
cmpq $0x0, 0x60(%rax)
jne 0xb1e4
jmp 0xbd80
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0xb231
movq 0xa0(%rsp), %rax
movq 0x60(%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0xb231
movq 0xa0(%rsp), %rax
movl $0x1, 0x10(%rax)
leaq 0x632ba(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbd80
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xb259
movq 0xa0(%rsp), %rax
movq 0x60(%rax), %rax
cmpl $0x1, 0x10(%rax)
jne 0xb63f
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x10(%rax)
je 0xb290
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq 0x4742e(%rip), %rax     # 0x526b4
movq %rax, 0xa8(%rsp)
jmp 0xb2b3
movq 0xa0(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq 0x48c11(%rip), %rax     # 0x53ebc
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rax
movl 0x68(%rax), %eax
movq %rax, 0x98(%rsp)
subq $0xe, %rax
ja 0xb63a
movq 0x98(%rsp), %rax
leaq 0x46e25(%rip), %rcx     # 0x52104
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xa0(%rsp), %rax
movl $0x3, 0x10(%rax)
movq 0xb0(%rsp), %rax
cmpl $0x3, 0x10(%rax)
je 0xb3a6
leaq 0x631c8(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x4739c(%rip), %rsi     # 0x526be
callq 0x6370
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x6370
movq %rax, %rdi
leaq 0x47388(%rip), %rsi     # 0x526c9
callq 0x6370
movq %rax, 0x90(%rsp)
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rsi
leaq 0x6317f(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x90(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x47351(%rip), %rsi     # 0x526d5
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x63140(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb63a
movq 0xb0(%rsp), %rax
cmpl $0x3, 0x10(%rax)
je 0xb3c7
movq 0xb0(%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xb3e2
movq 0xa0(%rsp), %rax
movq 0xb0(%rsp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0xb47f
leaq 0x630ef(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x472c3(%rip), %rsi     # 0x526be
callq 0x6370
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x6370
movq %rax, %rdi
leaq 0x472af(%rip), %rsi     # 0x526c9
callq 0x6370
movq %rax, 0x88(%rsp)
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rsi
leaq 0x630a6(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x88(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x4728a(%rip), %rsi     # 0x526e7
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x63067(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb63a
movq 0xb0(%rsp), %rax
cmpl $0x6, 0x10(%rax)
jne 0xb4a6
movq 0xa0(%rsp), %rax
movl $0x6, 0x10(%rax)
jmp 0xb543
leaq 0x6302b(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x471ff(%rip), %rsi     # 0x526be
callq 0x6370
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x6370
movq %rax, %rdi
leaq 0x471eb(%rip), %rsi     # 0x526c9
callq 0x6370
movq %rax, 0x80(%rsp)
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rsi
leaq 0x62fe2(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x80(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x471e0(%rip), %rsi     # 0x52701
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62fa3(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb63a
movq 0xa0(%rsp), %rax
movl $0x6, 0x10(%rax)
jmp 0xb63a
movq 0xa0(%rsp), %rax
movl $0x6, 0x10(%rax)
movq 0xb0(%rsp), %rax
cmpl $0x3, 0x10(%rax)
je 0xb638
movq 0xb0(%rsp), %rax
cmpl $0x4, 0x10(%rax)
je 0xb638
movq 0xb0(%rsp), %rax
cmpl $0x5, 0x10(%rax)
je 0xb638
leaq 0x62f30(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x47104(%rip), %rsi     # 0x526be
callq 0x6370
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x6370
movq %rax, %rdi
leaq 0x470f0(%rip), %rsi     # 0x526c9
callq 0x6370
movq %rax, 0x78(%rsp)
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rsi
leaq 0x62eea(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x78(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x470d1(%rip), %rsi     # 0x526e7
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62eae(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb63a
jmp 0xbd80
jmp 0xb641
movq 0xa0(%rsp), %rax
movl 0x68(%rax), %eax
movq %rax, 0x70(%rsp)
subq $0xe, %rax
ja 0xbd80
movq 0x70(%rsp), %rax
leaq 0x46a61(%rip), %rcx     # 0x520c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xa0(%rsp), %rax
movl $0x3, 0x10(%rax)
movq 0x58(%rax), %rax
cmpl $0x3, 0x10(%rax)
je 0xb711
leaq 0x62e44(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x47071(%rip), %rsi     # 0x52717
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x68(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62e16(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x68(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46feb(%rip), %rsi     # 0x526d5
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62dda(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb7a4
movq 0xa0(%rsp), %rax
movq 0x60(%rax), %rax
cmpl $0x3, 0x10(%rax)
je 0xb7a2
leaq 0x62dae(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46ff8(%rip), %rsi     # 0x52734
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq 0x60(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62d80(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x60(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46f55(%rip), %rsi     # 0x526d5
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62d44(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xb7a4
jmp 0xbd80
movq 0xa0(%rsp), %rcx
movq 0x58(%rcx), %rax
movl 0x10(%rax), %eax
movq 0x60(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jne 0xb893
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x3, 0x10(%rax)
je 0xb7e9
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x4, 0x10(%rax)
jne 0xb800
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0xb88e
leaq 0x62cd1(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46efe(%rip), %rsi     # 0x52717
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62ca3(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x58(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46e8a(%rip), %rsi     # 0x526e7
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62c67(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
movq 0xa0(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0xb965
leaq 0x62c3e(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46ea3(%rip), %rsi     # 0x5274f
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62c10(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x48(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46e82(%rip), %rsi     # 0x52772
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x50(%rsp)
movq 0x60(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62bcc(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x50(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x4735b(%rip), %rsi     # 0x52c8f
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62b90(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
movq 0xa0(%rsp), %rax
movl $0x1, 0x10(%rax)
jmp 0xbd80
movq 0xa0(%rsp), %rcx
movq 0x58(%rcx), %rax
movl 0x10(%rax), %eax
movq 0x60(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jne 0xba23
movq 0xa0(%rsp), %rax
movl $0x6, 0x10(%rax)
movq 0x58(%rax), %rax
cmpl $0x6, 0x10(%rax)
je 0xba1e
leaq 0x62b32(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46dc0(%rip), %rsi     # 0x52778
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62b04(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x40(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46d05(%rip), %rsi     # 0x52701
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62ac8(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbae6
leaq 0x62aae(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46d50(%rip), %rsi     # 0x5278c
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62a80(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46cf2(%rip), %rsi     # 0x52772
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x60(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62a3c(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46cdd(%rip), %rsi     # 0x527a1
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62a00(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbd80
movq 0xa0(%rsp), %rcx
movl $0x6, 0x10(%rcx)
movq 0x58(%rcx), %rax
movl 0x10(%rax), %eax
movq 0x60(%rcx), %rcx
cmpl 0x10(%rcx), %eax
je 0xbbd1
leaq 0x629c3(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46c8f(%rip), %rsi     # 0x527b6
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62995(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46c07(%rip), %rsi     # 0x52772
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x60(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x62951(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x470e0(%rip), %rsi     # 0x52c8f
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62915(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbd80
movq 0xa0(%rsp), %rcx
movl $0x6, 0x10(%rcx)
movq 0x58(%rcx), %rax
movl 0x10(%rax), %eax
movq 0x60(%rcx), %rcx
cmpl 0x10(%rcx), %eax
jne 0xbcbb
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x3, 0x10(%rax)
je 0xbcb6
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x4, 0x10(%rax)
je 0xbcb6
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rax
cmpl $0x5, 0x10(%rax)
je 0xbcb6
leaq 0x6289a(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46b3c(%rip), %rsi     # 0x5278c
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x6286c(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46b46(%rip), %rsi     # 0x527da
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62830(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbd7e
leaq 0x62816(%rip), %rax     # 0x6e4d8
movq (%rax), %rdi
addq $0x38, %rdi
addq $0x10, %rdi
leaq 0x46ae2(%rip), %rsi     # 0x527b6
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x58(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x627e8(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46a5a(%rip), %rsi     # 0x52772
callq 0x6370
movq %rax, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x60(%rax), %rax
movslq 0x10(%rax), %rsi
leaq 0x627a4(%rip), %rdi     # 0x6e4e0
callq 0x1fc90
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x6340
movq %rax, %rdi
leaq 0x46f33(%rip), %rsi     # 0x52c8f
callq 0x6370
movq 0xa0(%rsp), %rax
leaq 0x62768(%rip), %rcx     # 0x6e4d8
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0x2f440
jmp 0xbd80
addq $0xc8, %rsp
retq
nopl (%rax,%rax)