//********************************************************************************
//******************  LIBRERIA DE FUNCIONES JAVASCRIPT ***************************
//********************************************************************************

//-----------------------------------------------------------------
// Descripción: Indica si la cadena pasada como primer argumento es vacia o null
// Autor: David Martinez Bermejo
// Fecha de creación: 27/03/2006
// Retorno:  BOOLEAN. Si la cadena vacia o null ->true, sino ->false
// Argumentos: STRING. Cadena a analizar
//-----------------------------------------------------------------
function vacio(cadena){
    if ( txt == null ) return true;
    else if ( trim(txt).length == 0 ) return true;
    else return false;
}

//-----------------------------------------------------------------
// Descripción: Indica si el caracter pasado como argumento es letra o no      
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: BOOLEAN. si el parametro es letra->true sino->false
// Argumentos: CHAR. caracter a analizar
//-----------------------------------------------------------------

function esLetra(caracter){
    var letras="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if(letras.indexOf(caracter)!=-1) return true;
    else return false;
}


//-----------------------------------------------------------------
// Descripción: Indica si el caracter pasado como argumento es numero o no      
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: BOOLEAN. si el parametro es numero->true  sino->false
// Argumentos: CHAR. caracter a analizar
//-----------------------------------------------------------------

function esNumero(caracter){
    var numeros="1234567890";
    if(numeros.indexOf(caracter)!=-1)return true;
    else return false;
}

//-----------------------------------------------------------------
// Descripción: Indica si la cadena pasada como argumento corresponde a un 
//  identificador de provincia correcto
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: BOOLEAN. si la cadena es un identificador correcto ->true sino-> false
// Argumentos: STRING. cadena de provincia a analizar
//-----------------------------------------------------------------

function matriculaProvinciaCorrecta(provincia){
    var validas=" VI AB AL AV BA IB BU CC CA CS CE CR CO CU GI GR GU SS HU LE LO LU MA MU NA OR GC PO SA TF SG SE SO TE TO VA BI ZA ML A B C H J L M O P S T V Z ";
    if(validas.indexOf(provincia)!=-1) return true;
    else return false;
}

//-----------------------------------------------------------------
// Descripción: Indica si la cadena de letras de la matricula de nuevo formato es válida      
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: BOOLEAN. si la cadena es valida->true  sino->false
// Argumentos: STRING. cadena de letras de matricula a analizar
//-----------------------------------------------------------------

function matriculaNuevaLetrasCorrectas(letras){
    if((letras.indexOf("A")!=-1)||(letras.indexOf("E")!=-1)||(letras.indexOf("I")!=-1)||(letras.indexOf("O")!=-1)||(letras.indexOf("U")!=-1)) return false;
    else return true;
}
//-----------------------------------------------------------------
// Descripción: Transforma una matricula pasada como parámetro en matricula válida
//  o devuelve un identificador de error
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: STRING. si la matricula es valida devuelve un string con formato (0000BBB,A0000BB)
//  sino devuelve cadena vacía
// Argumentos: STRING. Cadena con la matricual a validar, el formato de entrada 
//  es (0000-BBB,A-0000-BB)
//-----------------------------------------------------------------

function validarMatricula(matOrig){
    var matriculaFinal="";
    var provincia="";
    var numero="";
    var letras="";
    var matriculaOriginal=new String(matOrig);
    var cadena = "/*-.,_:;><¿?¡!)(&%$";
    
    //Se quitan todos los separadores contenidos en CADENA
    matriculaOriginal=matriculaOriginal.toUpperCase();
    
    for (c=0; c<cadena.length; c++){
        while(matriculaOriginal.indexOf(cadena.charAt(c))!=-1) matriculaOriginal=matriculaOriginal.replace(cadena.charAt(c),"");
    }
    
    //se parsea la cadena y se almacena su infirmacion en camps segun corresponda
    var caracter;
    var indice=0;
    var error=false;
    if(matriculaOriginal.length<6 || matriculaOriginal.length>9) error=true;
    while((indice<matriculaOriginal.length)&&(!error)){
        
        caracter=matriculaOriginal.charAt(indice);
        switch (indice) {
            case 0:
                if(esLetra(caracter))provincia=provincia+caracter;
                else if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 1:
                if(esLetra(caracter))provincia=provincia+caracter;
                else if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 2:
                if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 3:
                if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 4:
                if(esLetra(caracter))letras=letras+caracter;
                else if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 5:
                if(esLetra(caracter))letras=letras+caracter;
                else if(esNumero(caracter))numero=numero+caracter;
                else error=true;
                break;
            case 6:
                if(esLetra(caracter))letras=letras+caracter;
                else error=true;
                break;
            case 7:
                if(esLetra(caracter))letras=letras+caracter;
                else error=true;
                break;
        }
        indice=indice+1;   
    }
    //controlamos si el codigo de provincia y las letras de las matriculas nuevas
    //son validas
    if(provincia.length>0) error=!matriculaProvinciaCorrecta(provincia);
    if(letras.length>2)error=!matriculaNuevaLetrasCorrectas(letras);
    
    //si hay algun error se devuelve vacio
    if(!error)matriculaFinal=provincia+numero+letras;
    else alert("El formato de la matricula introducida no es correcto.\n Por favor, introduzca una matricula valida.")
    return matriculaFinal;
}
//-----------------------------------------------------------------
// Descripción: Valida la consistencia de la letra del DNI y lo devuelve con formato
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: STRING. si el NIF es valido devuelve un string con formato (00000000B)
//  sino devuelve cadena vacía
// Argumentos: STRING. Cadena con el NIF a validar, el formato de entrada 
//  es (00000000-B)
//-----------------------------------------------------------------

function validarNIF(NIF){
    var NIFFinal="";
    var cadena=new String(NIF);
    var error=false;
    //formateamos la cadena
    cadena=cadena.toUpperCase();
    cadena=cadena.replace("-","");
    cadena=cadena.replace(" ","");
    if(cadena.length>9) error=true;
    //separamos los campos
    var numero=new Number(cadena.substring(0,cadena.length-1));
    var letra=cadena.substring(cadena.length-1,cadena.length);
    //comprobamos la integridad de los campos
    if(!esLetra(letra))error=true;
    var auxNumero=new String(numero);
    var i=0;
    while((!error)&&(i<auxNumero.length)){
        if(!esNumero(auxNumero.charAt(i))) error=true;
        i=i+1;
    }
    //comprobamos la coherencia de la letra respecto al numero
    var cociente=numero/23;
    var cocienteEntero=Math.round(cociente-0.50)
    var resto=Math.round((cociente-cocienteEntero)*23);
    
    var letraCorrecta="";
    switch (resto) {
        case 0:
            letraCorrecta="T";
            break;
        case 1:
            letraCorrecta="R";
            break;
        case 2:
            letraCorrecta="W";
            break;
        case 3:
            letraCorrecta="A";
            break;
        case 4:
            letraCorrecta="G";
            break;
        case 5:
            letraCorrecta="M";
            break;
        case 6:
            letraCorrecta="Y";
            break;
        case 7:
            letraCorrecta="F";
            break;
        case 8:
            letraCorrecta="P";
            break;
        case 9:
            letraCorrecta="D";
            break;
        case 10:
            letraCorrecta="X";
            break;
        case 11:
            letraCorrecta="B";
            break;
        case 12:
            letraCorrecta="N";
            break;
        case 13:
            letraCorrecta="J";
            break;
        case 14:
            letraCorrecta="Z";
            break;
        case 15:
            letraCorrecta="S";
            break;
        case 16:
            letraCorrecta="Q";
            break;
        case 17:
            letraCorrecta="V";
            break;
        case 18:
            letraCorrecta="H";
            break;
        case 19:
            letraCorrecta="L";
            break;
        case 20:
            letraCorrecta="C";
            break;
        case 21:
            letraCorrecta="K";
            break;
        case 22:
            letraCorrecta="E";
            break;
    }
    if(letraCorrecta!=letra)error=true;
    
    if(!error) NIFFinal=numero+letra;
    return NIFFinal;
}    


//-----------------------------------------------------------------
// Descripción: Valida la consistencia de la letra del CIF y lo devuelve con formato
// Autor: David Martinez Bermejo
// Fecha de creación: 28/03/2006
// Retorno: STRING. si el CIF es valido devuelve un string con formato (X000000X)
//  sino devuelve cadena vacía
// Argumentos: STRING. Cadena con el CIF a validar, el formato de entrada 
//  es (X-0000000X)
//-----------------------------------------------------------------

function validarCIF(CIF){
    
    var CIFFinal="";
    var cadena=new String(CIF);
    var error=false;
    //formateamos la cadena
    cadena=cadena.toUpperCase();
    cadena=cadena.replace("-","");
    //error si la cadena tiene longitud distinta a 9
    if(cadena.length!=9) error=true;
    //sacamos los campos necesarios
    var letra=cadena.charAt(0);
    var caracterControl=cadena.charAt(cadena.length-1);
    var numero=new String(cadena.substring(1,cadena.length-1));
    //comprobamos que la letra esta dentro de las permitidas
    var letrasPermitidas="ABCDEFGHKLMNPQS";
    if(letrasPermitidas.indexOf(letra)==-1) error=true;
    //calculamos el caracter de control
    var pares=new Number(0);
    var numeroImpar1, numeroImpar2;
    var stringImpar;
    var impares=new Number(0);
    var i;
    for(i=1;i<numero.length+2;i=i+2){
        if(i<numero.length)pares=pares+new Number(numero.charAt(i));
        stringImpar=new String(new Number(numero.charAt(i-1))*2);
        numeroImpar1=new Number(stringImpar.charAt(0));
        if(stringImpar.length>0)numeroImpar2=new Number(stringImpar.charAt(1));
        else numeroImpar2=new Number(0);
        impares=impares+numeroImpar1+numeroImpar2;
    }
    var suma=new String(pares+impares);
    var unidad=suma.charAt(suma.length-1);
    var resta=new Number(10-new Number(unidad));
    var caracteresControlCorrectos=new String("ABCDEFGHIJ");
    //comprobamos que el caracter de control corresponde
    if((caracterControl!=resta)&&(caracterControl!=caracteresControlCorrectos.charAt(resta-1))) error=true;
    
    if(!error) CIFFinal=letra+numero+caracterControl;
    return CIFFinal;
}

//-----------------------------------------------------------------
// Descripción: Indica si un ano es bisiesto
// Autor: David Martinez Bermejo
// Fecha de creación: 29/03/2006
// Retorno: BOOLEAN. si el ano dado como parametro es bisiesto->true, sino ->false
// Argumentos: STRING. Cadena con el ano(aaaa)
//-----------------------------------------------------------------
function esBisiesto(ano) { 
    var bisiesto=false;
    if( ((ano % 4 == 0) && (ano % 100 != 0)) || (ano % 400 == 0) ) bisiesto=true;
    return bisiesto;
}
//-----------------------------------------------------------------
// Descripción: Valida la consistencia de la fecha. Las fechas estan limitadas al 
//  rango 01/01/1900---31/12/2200
// Autor: David Martinez Bermejo
// Fecha de creación: 29/03/2006
// Retorno: BOOLEAN. Si la fecha es valida->true, sino->false
// Argumentos: 
//      Entrada: 
//          -eDias:STRING. valor del dia a validar
//          -eMes:STRING. valor del mes a validar
//          -eAno:STRING. valor del ano a validar
//      Salida: El valos de los objetos de la salida corresponde con el valor de la
//  fecha correcta si se ha validado, y si no la cadena vacia.
//          -sDias:STRING. valor del ano validado
//          -sMes:STRING. valor del ano validado
//          -sAno:STRING. valor del ano validado
//-----------------------------------------------------------------

function validarFechaValida(eDias,eMes,eAno,sDias,sMes,sAno){
    var error=false;
    var dia=new Number(eDias);
    var mes=new Number(eMes);
    var ano=new Number(eAno);
    //comprobamos la consistencia de los campos
    if(isNaN(dia) ||isNaN(mes) ||isNaN(ano) )error=true;
    if((ano<1900)||(ano>2200))error=true;
    if((mes<1)||(mes>12))error=true;
    if((dia<1)||(dia>31))error=true;
    if((dia==31)&&( (mes==4)||(mes==6)||(mes==9)||(mes==11) )) error=true;
    if(esBisiesto(ano)&&(dia>29)&&(mes==2)) error=true;
    if(!esBisiesto(ano)&&(dia>28)&&(mes==2)) error=true;
    
    if(!error){
        if(dia<10)sDias=new String('0'+dia);
        else sDias=dia;
        if(mes<10)sMes='0'+mes;
        else sMes=mes;
        sAno=ano;
    }
    else{
        sDias="";
        sMes="";
        sAno="";
    }
    return !error;
}
function formatear(dia){

var eDias;
        if(dia.length==1){
	        eDias=new String('0'+dia);
    	    //dia=eDias;
        }else
        	eDias=dia;

       return eDias;
       //return eMes;

}
function validarFechaValida2(eDias,eMes,eAno,sDias,sMes,sAno){
    var error=false;
    var dia=new Number(eDias);
    var mes=new Number(eMes);
    var ano=new Number(eAno);
        
    
    //comprobamos la consistencia de los campos
    if(isNaN(dia) ||isNaN(mes) ||isNaN(ano) )error=true;
    if((ano<1900)||(ano>2200))error=true;
    if((mes<1)||(mes>12))error=true;
    if((dia<1)||(dia>31))error=true;
    if((dia==31)&&( (mes==4)||(mes==6)||(mes==9)||(mes==11) )) error=true;
    if(esBisiesto(ano)&&(dia>29)&&(mes==2)) error=true;
    if(!esBisiesto(ano)&&(dia>28)&&(mes==2)) error=true;
    
    if(!error){
        if(dia<10)sDias=new String('0'+dia);
        else sDias=dia;
        if(mes<10)sMes='0'+mes;
        else sMes=mes;
        sAno=ano;
    }
    return !error;
}
//-----------------------------------------------------------------
// Descripción: Valida la consistencia de un entero
// Autor: David Martinez Bermejo
// Fecha de creación: 29/03/2006
// Retorno: BOOLEAN. si el entero es valido->true, sino ->false
// Argumentos: STRING. Cadena con el entero a validar
//-----------------------------------------------------------------

function validarEnteros(numero){
    var entero = parseInt(numero) 
    var error=false;
    if(isNaN(entero)||(entero!=numero)) error=true;
    
    return !error;
}
//-----------------------------------------------------------------
// Descripción: Valida la consistencia de un float
// Autor: David Martinez Bermejo
// Fecha de creación: 29/03/2006
// Retorno: BOOLEAN. si el float es valido->true, sino ->false
// Argumentos: STRING. Cadena con el float a validar
//-----------------------------------------------------------------

function validarFloat(numero){
    var decimal = parseFloat(numero) 
    var error=false;
    if(isNaN(decimal)||(decimal!=numero)) error=true;
    
    return !error;
}

//-----------------------------------------------------------------
// Descripción: Indica la cantidad de dias del mes dado por el parámetro
//  si el parámetro del año es vacio, se dara por hecho que el año no es bisiesto
// Autor: David Martinez Bermejo
// Fecha de creación: 29/03/2006
// Retorno: STRING. numero de dias del mes (31,30,29,28)
// Argumentos: 
//      -mes:STRING. Cadena con el mes, puede ser el valor numerico (1-12) o el 
//  nombre del mes (ENERO-DICIEMBRE)
//      -ano:STRING. Cadena con el ano correspondiente al mes. Si este argumento 
//  es vacio se tomara por defecto como ano no bisiesto.
//-----------------------------------------------------------------

function getDiasDelMes(mes,ano){
    
    mes=mes.toUpperCase();
    
    var dias='31';
    var bisiesto=false;
    if(ano==""||!esBisiesto(ano))bisiesto=false;
    
    if((mes=='2')||(mes=='FEBRERO')){
        if(bisiesto)dias='29';
        else dias='28';    
    }
    if((mes=='4')||(mes=='ABRIL')||(mes=='6')||(mes=='JUNIO')||(mes=='9')||(mes=='SEPTIEMBRE')||(mes=='11')||(mes=='NOVIEMBRE'))
        dias='30';
    
    return dias;
}

//-----------------------------------------------------------------
// Descripción: Indica la diferencia de dias entre dos fechas
// Autor: David Martinez Bermejo
// Fecha de creación: 01/04/2006
// Retorno: STRING. numero de dias de diferencia entre dos fechas
//  si existe algun error en la entrada e las fechas se devuelve -1
// Argumentos:
//          -diaE1:STRING. dia correspondiente a la primera fecha
//          -mesE1:STRING. mes correspondiente a la primera fecha
//          -anoE1:STRING. ano correspondente a la primera fecha
//          -diaE2:STRING. dia correspondiente a la segunda fecha
//          -mesE2:STRING. mes correspondiente a la segunda fecha
//          -anoE2:STRING. ano correspondente a la segunda fecha
//-----------------------------------------------------------------

function validarDiferencia(dia1,mes1,ano1,dia2,mes2,ano2){
    var sumaDias=-1;
    //variables auxiliares, solo se utilizan para recoger los errores de la 
    //validacion de fecha
    var d1="";
    var m1="";
    var a1="";
    var d2="";
    var m2="";
    var a2="";
    
    //si el formato de las fechas es valido
    if((validarFechaValida(dia1,mes1,ano1,d1,m1,a1))&&(validarFechaValida(dia2,mes2,ano2,d2,m2,a2))){
        //si la segunda fecha es mayor o igual a la primera
        if(compararFechas(dia1,mes1,ano1,dia2,mes2,ano2)<1){
            sumadias=0;
            if((mes1.indexOf(mes2)!=-1)&&(ano1.indexOf(ano2)!=-1)) sumaDias=new Number(dia2)-new Number(dia1);
            else if(ano1.indexOf(ano2)!=-1){
                //sumamos los dias que faltan del mes1
                var diasFaltanMes1=new Number(getDiasDelMes(mes1,ano1))-new Number(dia1)+1;
                sumaDias=sumaDias+diasFaltanMes1;
                //sumamos los dias hasta terminar el mes2
                var diasFaltanAno1=new Number(0);
                var indiceMeses=new Number(mes1)+1;
                while(indiceMeses<(new Number(mes2))){
                    diasFaltanAno1=diasFaltanAno1+new Number(getDiasDelMes(new String(indiceMeses),ano1));
                    indiceMeses=indiceMeses+1;
                }
                sumaDias=sumaDias+diasFaltanAno1;
                //sumamos los dias que faltan hasta el dia 2
                sumaDias=sumaDias+new Number(dia2);
            }
            else{
                //sumamos los dias que faltan del mes1
                var diasFaltanMes1=new Number(getDiasDelMes(mes1,ano1))-new Number(dia1)+1;
                sumaDias=sumaDias+diasFaltanMes1;
                //sumamos los dias hasta terminar el ano1
                var diasFaltanAno1=0;
                var indiceMeses=new Number(mes1)+1;
                while(indiceMeses<13){
                    diasFaltanAno1=diasFaltanAno1+new Number(getDiasDelMes(new String(indiceMeses),ano1));
                    indiceMeses=indiceMeses+1;
                }
                sumaDias=sumaDias+diasFaltanAno1;
                //sumamos los dias hasta llegar a ano2
                var diasFaltanAno2=0;
                var indiceAnos=new Number(ano1)+1;
                while(indiceAnos<new Number(ano2)){
                    if(esBisiesto(indiceAnos))diasFaltanAno2=diasFaltanAno2+365;
                    else diasFaltanAno2=diasFaltanAno2+366;
                    indiceAnos=indiceAnos+1;
                }
                sumaDias=sumaDias+diasFaltanAno2;
                //sumamos los dias hasta llegar al mes2 desde el 1 de enero de ano2
                var diasFaltanMes2=0;
                var indiceMeses=1;
                while(indiceMeses<(new Number(mes2))){
                    diasFaltanMes2=diasFaltanMes2+new Number(getDiasDelMes(new String(indiceMeses),ano2));
                    indiceMeses=indiceMeses+1;
                }
                sumaDias=sumaDias+diasFaltanMes2;
                //sumamos los dias que faltan hasta el dia 2
                sumaDias=sumaDias+new Number(dia2);
                
            }
        }
        else alert("La primera fecha debe de ser inferior a la segunda");
    }
    return sumaDias;   
}

//-----------------------------------------------------------------
// Descripción: Compara dos fechas y devuelve si la primera es menor,mayor o
//  igual a la segunda (-1,1,0)
// Autor: David Martinez Bermejo
// Fecha de creación: 30/03/2006
// Retorno: STRING. 
//      - -1:si la primera fecha es menor que la segunda
//      -  0:si las dos fechas son iguales
//      -  1:si la primera fecha es mayor que la segunda
// Argumentos:
//          -dia1:STRING. dia correspondiente a la primera fecha
//          -mes1:STRING. mes correspondiente a la primera fecha
//          -ano1:STRING. ano correspondente a la primera fecha
//          -dia2:STRING. dia correspondiente a la segunda fecha
//          -mes2:STRING. mes correspondiente a la segunda fecha
//          -ano2:STRING. ano correspondente a la segunda fecha
//-----------------------------------------------------------------

function compararFechas(dia1,mes1,ano1,dia2,mes2,ano2) {
    var suma1=(new Number(dia1))+((new Number(mes1)-1)*30)+((new Number(ano1)-1901)*365);
    var suma2=(new Number(dia2))+((new Number(mes2)-1)*30)+((new Number(ano2)-1901)*365);
    var resultado='-1';
    if(suma1<suma2)resultado='-1';
    else if(suma1==suma2)resultado='0';
    else if(suma1>suma2)resultado='1';
    
    return resultado;
}
// esta funcion comprueba la veracidad del email controlando tanto el contenido de la arroba como
// que contiene un punto.

/*
 function ChequearMail(txt) {
   if (txt.value.indexOf("@")<3){
    txt.value="";
    }
    if ((txt.value.indexOf(".com")<5)&&(txt.value.indexOf(".org")<5)
    &&(txt.value.indexOf(".gov")<5)&&(txt.value.indexOf(".net")<5)
    &&(txt.value.indexOf(".mil")<5)&&(txt.value.indexOf(".es")<5)
    &&(txt.value.indexOf(".")<5)){
    txt.value="";
    }
 }
*/

function ChequearMail(txt) {
  if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(txt.value)){
   } else {
   txt.value="";
  }
 }
//-----------------------------------------------------------------
// Descripción: Indica si la diferencia entre la fecha dada como parametro y la
//  fecha actual es superior a 18 años
// Autor: Alberto Oller Peña
// Fecha de creación: 20/04/2006
// Retorno:BOOLEAN. si es mayor 18 años->true sino-> false
// Argumentos:
//          -dia:STRING. dia correspondiente a la fecha
//          -mes:STRING. mes correspondiente a la fecha
//          -ano:STRING. ano correspondente a la fecha
//-----------------------------------------------------------------

function validarMayor18(dia,mes,ano) {
    
    valida = validarFechaValida(dia,mes,ano,dia,mes,ano);
    mayor18 = false;
    
    var hoy = new Date();
    anyoActual= Number(hoy.getFullYear());
    
    if (valida){
        if (Number(ano) + 18 < anyoActual){ //Ha nacido hace más de 18 años
            mayor18 = true;         
        }
        else{
            if (Number(ano) + 18 == anyoActual){// Ha nacido hace 18 años exactos...
                mesActual = Number(hoy.getMonth()) + 1;
                if (Number(mes) < mesActual){//... pero ha nacido antes del mes actual
                    mayor18 = true;
                }
                else{
                    if (Number(mes) == mesActual){//Ha nacido en el mes actual...
                        diaActual = Number(hoy.getDate());
                        if (Number(dia) < diaActual){//... pero ha nacido antes del día actual
                            mayor18 = true;
                        }                  
                    }
                }
            }
        }        
    }
    return mayor18;
}