//----------------------------- FUNCIONES ------------------------------

/**
* Indica si un tramo de los intereses de un credito es simulable
*
* @param tramo		tramo que se va a comprobar
*/
function esTramoSimulable(tramo) {
  var resultado = true;

  if ((tramo.NumTramo == -1) || (tramo.DuracionMinima==-1) || (tramo.DuracionMaxima==-1) ||
     (tramo.InteresMinimo == -1) || (tramo.InteresMaximo ==-1)) {
		resultado = false;
  }

  if ((resultado==true) && (tramo.TipoReferencia!=-1)) {
    if ((tramo.Redondeo==-1)) {
      resultado = false;
    }
  }

  return resultado;
  
} // esTramoSimulable()




/**
* Indica si un credito es simulable
*
* @param credito	credito que se va a comprobar
*/
function esCreditoSimulable(credito){
  var resultado = true;
  var j;

  if (( credito.abertura==-1) || (credito.minAbertura==-1) || (credito.carenciaMaxAdq==-1) || 
    (credito.carenciaAdq==-1) || (credito.carenciaTrans==-1) || (credito.carenciaMaxTrans==-1) || 
    (credito.carenciaMaxAuto==-1) || (credito.carenciaAuto==-1) || (credito.maxFinanHabPropia==-1) || 
    (credito.minFinanHabPropia==-1) || (credito.maxFinanHabSec==-1) || (credito.minFinanHabSec==-1)) {

      resultado = false;
  }

  if (resultado == true) {
    j = 0;
    while ((resultado==true) && (j<credito.interesesHabPropia.length)) {
      resultado = esTramoSimulable(credito.interesesHabPropia[j]);
      j = j + 1;
    }
  }

  if (resultado == true) {
    j = 0;
    while ((resultado==true) && (j<credito.interesesHabSec.length)) {
      resultado = esTramoSimulable(credito.interesesHabSec[j]);
      j = j + 1;
    }
  }

  return resultado;
  
} // esCreditoSimulable()


/**
* Aplica un redondeo a un valor de intereses
*
* @param taxa			valor de los intereses
* @param redondeo		cantidad a la que redondear
*/
function Redondeo(taxa, redondeo){
	var resultado = -1
	if(redondeo > 0 &&  redondeo <= 1 ) {
		// Calculamos la division entera 
		var div = Math.floor(taxa / redondeo);
		// Tomamos el resto de la division entera
		var mod = redondeo * div - taxa;
		// Si el resto es distinto de cero, aproximamos al siguiente multiplo del redondeo
		resultado = mod != 0 ?  redondeo * (div + 1) : taxa;
	}else{
		if (redondeo==0){
			resultado = taxa;
		} else {
			alert('No se puede realizar el redondeo');
		}
	}
	return resultado;

} // Redondeo()

//------------------------ OBJETO TIPO DE REFERENCIA ----------------------------

/**
* Constructor de un tipo de referencia de un crédito
*
* @param nombreVisual nombre del tipo de referencia
* @param Valor				 valor % del tipo de referencia
*/
function TipoReferencia (NombreVisual, Valor) {
  this.NombreVisual = NombreVisual;
  this.Valor = Valor;
} // TipoReferencia()


//------------------------ OBJETO TRAMO ----------------------------


/**
* Constructor de un tramo de los intereses de un credito
*
* @param NumTramo
* @param DuracionMinima 
* @param DuracionMaxima
* @param DuracionUsuario
* @param TipoReferencia
* @param InteresMinimo
* @param InteresMaximo
* @param InteresUsuario
* @param SpreadMinimo
* @param SpreadMaximo
* @param SpreadUsuario
* @param Redondeo
*/
function TramoCredito(NumTramo,DuracionMinima,DuracionMaxima,DuracionUsuario,TipoReferencia,InteresMinimo,InteresMaximo,InteresUsuario,SpreadMinimo,SpreadMaximo,SpreadUsuario,Redondeo){

	this.NumTramo=NumTramo;
	this.DuracionMinima=DuracionMinima;
	this.DuracionMaxima=DuracionMaxima;
	this.DuracionUsuario=DuracionUsuario;
	this.TipoReferencia=TipoReferencia;
	this.InteresMinimo=InteresMinimo;
	this.InteresMaximo=InteresMaximo;
	this.InteresUsuario=InteresUsuario;
	this.SpreadMinimo=SpreadMinimo;
	this.SpreadMaximo=SpreadMaximo;
	this.SpreadUsuario=SpreadUsuario;
	this.Redondeo=Redondeo;

} // TramoCredito()


//------------------------ OBJETO CREDITO HABITAÇAO ----------------------------

/**
* Constructor de un credito habitaçao
*
* @param abertura
* @param minAbertura
* @param carenciaMaxAdq
* @param carenciaAdq
* @param carenciaTrans
* @param carenciaMaxTrans
* @param carenciaMaxAuto
* @param carenciaAuto
* @param carenciaUsuario
* @param maxFinanHabPropia
* @param minFinanHabPropia
* @param interesesHabPropia
* @param maxFinanHabSec
* @param minFinanHabSec
* @param interesesHabSec
* @param plazoMax
*/
function CreditoHabitacao(abertura, minAbertura,  carenciaMaxAdq, carenciaAdq, carenciaTrans,carenciaMaxTrans, carenciaMaxAuto, carenciaAuto,carenciaUsuario, maxFinanHabPropia, minFinanHabPropia, interesesHabPropia, maxFinanHabSec, minFinanHabSec, interesesHabSec, plazoMax, id) {
  //propiedades
  this.abertura = abertura;
  this.minAbertura = minAbertura;
  this.carenciaMaxAdq = carenciaMaxAdq;
  this.carenciaAdq = carenciaAdq;
  this.carenciaMaxTrans = carenciaMaxTrans;
  this.carenciaTrans = carenciaTrans;
  this.carenciaMaxAuto = carenciaMaxAuto;
  this.carenciaAuto = carenciaAuto;
  this.carenciaUsuario = carenciaUsuario;
  this.maxFinanHabPropia = maxFinanHabPropia;
  this.minFinanHabPropia = minFinanHabPropia;
  this.maxFinanHabSec = maxFinanHabSec;
  this.minFinanHabSec = minFinanHabSec;
  this.plazoMax = plazoMax;
  this.id = id;

  //propiedades complejas
  this.interesesHabPropia = interesesHabPropia;// Array de Tramos
  this.interesesHabSec = interesesHabSec;// Array de Tramos.

  //metodos
  this.getInteresHabPropia = getInteresesHabPropia;
  this.getInteresHabSec = getInteresHabSec;

}//fin CreditoHabitacao


/**
* Devuelve los intereses para el destino "propia" para un mes y un 
* montante determinados
*
* @param NumMes		numero de mes
* @param m_fin			montante de financiacion
* @param m_aval		montante de avaliaçao
* @param matSpread matriz de spreads.
*/
function getInteresesHabPropia(NumMes, m_fin, m_aval, matSpread){
	return getInteres(this.interesesHabPropia,NumMes, m_fin, m_aval, matSpread);
} // getInteresHabPropia()

/**
* Devuelve los intereses para el destino "segunda vivienda" para un mes y un 
* montante determinados
*
* @param NumMes		numero de mes
* @param m_fin			montante de financiacion
* @param m_aval		montante de avaliaçao
* @param matSpread matriz de spreads.
*/
function getInteresHabSec(NumMes, m_fin, m_aval, matSpread){
	return getInteres(this.interesesHabSec,NumMes, m_fin, m_aval, matSpread);
} // getInteresHabSec()


/**
* Funcion de utilidad que calcula la duracion acumulada entre los tramos
* de los intereses de un credito
*
* @param Matriz matriz de intereses
* @param i			 posicion
*/
function Acumulado(Matriz,i){
	if (i >= 0) {	
		with(Matriz[i]){
			if (DuracionMinima < DuracionMaxima){
			//alert(Matriz.DuracionUsuario+'\n'+isNaN(Matriz.DuracionUsuario));
				LOG('************ DURACION DE USUARIO '+DuracionUsuario);

				if (DuracionUsuario >= 0){
					return (DuracionUsuario + Acumulado(Matriz,i-1));
				}else{
					return (DuracionMinima + Acumulado(Matriz,i-1));
				}
			}else{
				return (DuracionMinima + Acumulado(Matriz,i-1));
			}
		}
	}else{
		//return MatrizDuracionMinima;
		return 0;
	}
	
} // Acumulado()


/**
*
*/
function Interes(Matriz, m_aval, m_fin, matSpread){
	var resultado = -1;
	//alert("Periodo -> " + Matriz.NumTramo + "\nDuracion min -> " + Matriz.DuracionMinima + "\nDuracion Maxima -> " + Matriz.DuracionMaxima + "\nDuracion Usr -> " + Matriz.DuracionUsuario + "\nInteres Min -> " + Matriz.InteresMinimo + "\nInteres Max -> " + Matriz.InteresMaximo + "\nInteres Usr -> " + Matriz.InteresUsuario + "\nTipo Ref -> " + Matriz.TipoReferencia);
	if ((Matriz.TipoReferencia>0)){						
	// Tipo Variable
		//alert("Tramo de tipo variable = " + Matriz.TipoReferencia);
		
		if (!isNaN(Matriz.SpreadUsuario) && (Matriz.SpreadMinimo < Matriz.SpreadMaximo) && (Matriz.SpreadUsuario > 0)){
			resultado = Matriz.TipoReferencia + Matriz.SpreadUsuario;
		} else if(Matriz.SpreadMinimo == -1 && Matriz.SpreadMaximo == -1) {
			//alert("Cogemos el spread de la tabla: " + Matriz.TipoReferencia + " + " + matSpread.getSpread(m_fin * 100 / m_aval, m_fin));
			resultado = Matriz.TipoReferencia + matSpread.getSpread(m_fin * 100 / m_aval, m_fin);
		} else {
			resultado = Matriz.TipoReferencia+Matriz.SpreadMinimo;
		}
		
		
		if(resultado < Matriz.InteresMinimo) {
			resultado = Matriz.InteresMinimo;
		}
		
		if(resultado > Matriz.InteresMaximo) {
			resultado = Matriz.InteresMaximo;
		}
			
	} else {
		//alert("Tramo de tipo fijo: entre " + Matriz.InteresMinimo + " y " + Matriz.InteresMaximo);
	// Tipo fijo
		if ((Matriz.InteresMinimo < Matriz.InteresMaximo) && !isNaN(Matriz.InteresUsuario) && (Matriz.InteresUsuario >= 0)){
			resultado = Matriz.InteresUsuario;
		}else{
			resultado = Matriz.InteresMinimo;
		}
	}
	
	return resultado;
}



function OrdenaMatriz(Matriz){
	var check=true;
	while (check){
		check = false;
		var aux;
		for (i = 0; i < Matriz.length -1 ;i++){
			if (Matriz[i].NumTramo > Matriz[i+1].NumTramo){
				aux = Matriz[i];
				Matriz[i]= Matriz[i+1];
				Matriz[i+1]=aux;
				check = true;
			}
		}// ciclos
	}
}



function getTramo(NumMes, Matriz){
		for (i = 0; i < Matriz.length ; i++){
				LOG('---> INFERIOR '+(Acumulado(Matriz,i-1)));
				LOG('---> MES '+NumMes);
				LOG('---> SUPERIOR'+(Acumulado(Matriz,i)));
				if ((Acumulado(Matriz,i-1) < NumMes) & NumMes <= (Acumulado(Matriz,i))){
						//alert(' Tramo nº '+i+' \n'+NumMes);
						return i;
				}
		}
		return -1; // si es que no está en ninguno.
}




function getInteres(NumMes,Matriz, m_fin, m_aval, matSpread){
	LOG(Matriz.length);
	var tramo;
	var resultado = 0;
	if (Matriz){
		// paso 1: Ordenamos
	

		OrdenaMatriz(Matriz);
		// paso 2: Buscamos.
	  tramo = getTramo(NumMes,Matriz);
	  LOG(' MES '+NumMes+'\n tramo '+tramo);
	  if (tramo >= 0 ){
	  LOG(' Duración usuario tramo '+Matriz[tramo].DuracionUsuario);
	  LOG(' Interés bruto '+ Interes(Matriz[tramo], m_aval, m_fin, matSpread));
		  	return Redondeo(Interes(Matriz[tramo], m_aval, m_fin, matSpread),Matriz[tramo].Redondeo);
	  }

	}else{
		LOG("<b>Sin resultados<(b>");
		return 0;
	}
	return resultado;
}


//===================================================

/*
  Objeto costes y metodos.
*/
function Costes(regProvisorioHipoteca, regProvisorioAdq, outrosEncargos, avaliacao, 
		escriturasCompraVenda, escriturasConfDivida, escriturasHipoteca, 
		seguroCredHip, seguroCredHipSecundaria, vistorias){
  //propiedades
  this.regProvisorioHipoteca = regProvisorioHipoteca;
  this.regProvisorioAdq = regProvisorioAdq;
  this.outrosEncargos = outrosEncargos;
  //  debe ser un array de vectores, cada vector contiene 3 elementos (mínimo, media y tasa))
  this.avaliacao = avaliacao.sort(sortTramosCoste);
  this.escriturasCompraVenda = escriturasCompraVenda.sort(sortTramosCoste);
  this.escriturasConfDivida = escriturasConfDivida.sort(sortTramosCoste);
  this.escriturasHipoteca = escriturasHipoteca.sort(sortTramosCoste);
  this.seguroCredHip = seguroCredHip.sort(sortTramosCoste);
  this.seguroCredHipSecundaria = seguroCredHipSecundaria.sort(sortTramosCoste);
  this.vistorias = vistorias;
  // Devuelve la avaliaçao dependiendo del montante
  this.getAvaliacao = getAvaliacao;
  this.getEscriturasCompraVenda = getEscriturasCompraVenda;
  this.getEscriturasConfDivida = getEscriturasConfDivida;
  this.getEscriturasHipoteca = getEscriturasHipoteca;
  this.getSeguroCredHip = getSeguroCredHip;
  this.getSeguroCredHipSecundaria = getSeguroCredHipSecundaria;
  
}//fin Costes

/**
* Funcion de comparacion para ordenar un array de tramos de costes
*/
function sortTramosCoste(a, b){
	return a[0] - b[0];
}




function getCostePorTramos(coste, montante){

	//  Los tramos están marcados por un mínimo.	
		
	var resultado = 0;
	i = 1;
	
	while (i < coste.length){
		if (montante >= coste[i-1][0] && montante < coste[i][0]){
		  //alert(montante + " >= " + coste[i-1][0] + " && " + montante + " < " + coste[i][0] );
			//alert("coste[" + i + "] = " + coste[i-1][1])
			resultado = coste[i-1][1];
			break;
		}			
		i++;
	}

	if (montante > coste[coste.length-1][0]){
		//alert(montante + " > " + coste[coste.length-1][0]);	
		resultado =  coste[coste.length-1][1]
	}
	
	//alert("RESULTADO -> " + resultado);
	return resultado;

} // getCostePorTramos()



function getAvaliacao(montante) {
	return getCostePorTramos(this.avaliacao, montante);
}


function getEscriturasCompraVenda(montante) {
	return getCostePorTramos(this.escriturasCompraVenda, montante);
}


function getEscriturasConfDivida(montante) {
	return getCostePorTramos(this.escriturasConfDivida, montante);
}


function getEscriturasHipoteca(montante) {
	return getCostePorTramos(this.escriturasHipoteca, montante);
}

function getSeguroCredHip(mfin, maval) {
	//alert("getSeguroCredHip mfin="+mfin+" maval="+maval);
	return getCostePorTramos(this.seguroCredHip, mfin / maval * 100) * mfin / 100;
}

function getSeguroCredHipSecundaria(mfin, maval) {
	//alert("getSeguroCredHipSecundaria mfin="+mfin+" maval="+maval);
	return getCostePorTramos(this.seguroCredHipSecundaria, mfin / maval * 100) * mfin / 100;
}


//===================================================
/*
  Objeto Impuestos y metodos
  */

function Impuestos(iva, imtPropia, imtSecund, iSeloAdq, iSeloHipotecaAdq,iSeloHipotecaAuto, iSeloJuros, iSeloAbertura, taxaISP){
  //propiedades
  this.iva = iva;
  this.imtPropia = imtPropia.sort(sortTramosImpuesto);
  this.imtSecund = imtSecund.sort(sortTramosImpuesto);
  this.iSeloAdq = iSeloAdq;
  this.iSeloHipotecaAdq = iSeloHipotecaAdq;
  this.iSeloHipotecaAuto = iSeloHipotecaAuto.sort(sortTramosImpuesto);
  this.iSeloJuros = iSeloJuros;
  this.iSeloAbertura = iSeloAbertura.sort(sortTramosImpuesto);
  this.taxaISP = taxaISP;

  //metodos
  this.getIMTPropia=getIMTPropia;
  this.getIMTSecund=getIMTSecund;
  this.getISeloHipotecaAuto=getISeloHipotecaAuto;
  this.getISeloApertura=getISeloApertura;
}//fin Impuestos

function Impuestos2(iva, imts, iSeloAdq, iSeloHipotecaAdq,iSeloHipotecaAuto, iSeloJuros, iSeloAbertura, taxaISP){
  //propiedades
  this.iva = iva;
  this.imts = imts.sort(sortTramosImpuesto);
  this.iSeloAdq = iSeloAdq;
  this.iSeloHipotecaAdq = iSeloHipotecaAdq;
  this.iSeloHipotecaAuto = iSeloHipotecaAuto.sort(sortTramosImpuesto);
  this.iSeloJuros = iSeloJuros;
  this.iSeloAbertura = iSeloAbertura.sort(sortTramosImpuesto);
  this.taxaISP = taxaISP;

  //metodos
  this.getIMT=getIMT;
  this.getISeloHipotecaAuto=getISeloHipotecaAuto;
  this.getISeloApertura=getISeloApertura;
}//fin Impuestos2

/**
* Función de comparación de tramos de un impuesto. Se empleara para llamar
* a la función sort() del array de tramos de un impuesto
*/
function sortTramosImpuesto(a, b) {
	return a[0] - b[0];
}

function getISeloHipotecaAuto(mes){
	// Encaja en el intervalo y devuelve el valor de la matriz para dicho intervalo.
	// encajamos el valor de mes en la matriz
	
	var algo = -1;
	for (i = 1; i < this.iSeloHipotecaAuto.length; i++){
		if ((mes < this.iSeloHipotecaAuto[i][0]) && (mes >= this.iSeloHipotecaAuto[i-1][0])){
			algo = this.iSeloHipotecaAuto[i-1][1];
			break;
		}
	}
	if (mes > this.iSeloHipotecaAuto[this.iSeloHipotecaAuto.length-1][0]){	
		algo =  this.iSeloHipotecaAuto[this.iSeloHipotecaAuto.length-1][1]
	}
	//alert("iSeloHipotecaAuto(" + mes + ") = " + algo);
	return algo;
}

function getIMT(montante){

      // Devuelve el coste de evaluación 
      /*
      	str = "";
	for(zzzz = 1; zzzz < this.imts.length; zzzz++) {
		str += this.imts[zzzz][0] + ", ";
	}
	
	alert(str);      
      */
      
      with (this){
            var i = 1;
            // encajamos el elemento
            while (i < imts.length){
                  if (montante >= imts[i-1][0] && montante < imts[i][0]){
                    aux1 = (montante - (imts[i-1][0]-0.0001))*imts[i-1][1]/100;
                    aux2 = 0;
                    if (i >= 2) {
                      aux2 = (imts[i-1][0]*imts[i-2][2]/100);
                    }
                    return ( aux1 + aux2);
                  }
                  i++;
            }
            if (montante > imts[imts.length-1][0]){
                    aux1 = montante * imts[imts.length-1][1]/100;
                    aux2 = 0;
                    return (aux1 + aux2);
            }
            return 0;
      }
}

function getIMTPropia(montante){

      // Devuelve el coste de evaluación 
      /*
      	str = "";
	for(zzzz = 1; zzzz < this.imtPropia.length; zzzz++) {
		str += this.imtPropia[zzzz][0] + ", ";
	}
	
	alert(str);      
      */
      
      with (this){
            var i = 1;
            // encajamos el elemento
            while (i < imtPropia.length){
                  if (montante >= imtPropia[i-1][0] && montante < imtPropia[i][0]){
                    aux1 = (montante - (imtPropia[i-1][0]-0.0001))*imtPropia[i-1][1]/100;
                    aux2 = 0;
                    if (i >= 2) {
                      aux2 = (imtPropia[i-1][0]*imtPropia[i-2][2]/100);
                    }
                    return ( aux1 + aux2);
                  }
                  i++;
            }
            if (montante > imtPropia[imtPropia.length-1][0]){
                    aux1 = montante * imtPropia[imtPropia.length-1][1]/100;
                    aux2 = 0;
                    return (aux1 + aux2);
            }
            return 0;
      }
}

function getIMTSecund(montante){

      // Devuelve el coste de evaluación 
      
      with (this){
            var i = 1;
            // encajamos el elemento
            while (i < imtSecund.length){
                  if (montante >= imtSecund[i-1][0] && montante < imtSecund[i][0]){
                    aux1 = (montante - (imtSecund[i-1][0]-0.0001))*imtSecund[i-1][1]/100;
                    aux2 = 0;
                    if (i >= 2) {
                      aux2 = (imtSecund[i-1][0]*imtSecund[i-2][2]/100);
                    }
                    return ( aux1 + aux2);
                  }
                  i++;
            }
            if (montante > imtSecund[imtSecund.length-1][0]){
                    aux1 = montante * imtSecund[imtSecund.length-1][1]/100;
                    aux2 = 0;
                    return (aux1 + aux2);
            }
            return 0;
      }
}

function getISeloApertura(duracion){
	var _result = 0;
	
	cont = 1;
	with (this){
		while (cont < iSeloAbertura.length){
			if (duracion >= iSeloAbertura[cont - 1][0] && duracion < iSeloAbertura[cont][0]) {
				_result = iSeloAbertura[cont - 1][1];
				break;
			}
			cont++;
		}
		
		// Si es el primer tramo, multiplicamos por la duracion en meses
		if(cont == 1) {
			_result = _result * duracion;
		}

		// Si es el ultimo tramo
		if (duracion >= iSeloAbertura[iSeloAbertura.length - 1][0]){	
			_result = iSeloAbertura[iSeloAbertura.length - 1][1]
		}
	}

	return _result;

}

//===================================================
/*
  Objeto Spread y metodos
	MATRIZ DE SPREAD
		- Almacena dos vectores, aval y montante, cada uno 
			contiene los valores mínimos de los intervalos,
		- valores matriz bidimensional que contiene los valores
			de la relación entre aval y montante.
	SPREAD	
		- Ademas de la matríz contiene los valores 
  */
  

function MatrizSpread(_aval, _montante, _valores){
	this.aval = _aval;
	this.montante = _montante;
	this.valores = _valores;
	this.getSpread = getSpread;
}



function getSpread(_aval, _montante){
	// PASO 1: ubicamos el aval 
	//LOG(_aval.length);
	var x = 0;
	var y = 0;
	with (this){
		if (_aval < aval[0] || _montante < montante[0]){
			return -1;
		}
		cont = 0;
		//alert(_aval + " < " + aval[cont + 1]);
		while (cont < aval.length && _aval >= aval[cont + 1]){
			LOG(cont+','+aval[cont]);
			//alert(_aval + " < " + aval[cont + 1]);
			cont++;
		}
		x = cont; // Donde nos quedamos nos paramos.

		cont = 0;
		//alert(_montante + " < " + montante[cont + 1]);
		while (cont < montante.length && _montante >= montante[cont + 1]){
			//alert(_montante + " < " + montante[cont + 1]);
			LOG(cont+','+montante[cont]);
			cont++;
			
		}
		y = cont; // Donde nos quedamos nos paramos.

	// PASO 2: ubicamos el montante
	// PASO 3: devolvemos elemento de la matriz si existe, si falla -1
		//alert("valores[" + x + "][" + y + "] = " + valores[x][y]);
		return valores[x][y]
	}

}

//===================================================
function OutroCredito(montanteMax,montanteMin,plazoMax,abertura,minAbertura,carencia,carenciaMax,intereses,carenciaUsuario,id){
	// Asignación de atributos
	this.montanteMax=montanteMax
	this.montanteMin=montanteMin
	this.plazoMax=plazoMax
	this.abertura=abertura
	this.minAbertura=minAbertura
	this.carencia=carencia
	this.carenciaMax=carenciaMax
	this.carenciaUsuario=carenciaUsuario
	this.intereses=intereses
	this.id = id
	// Asignación de métodos
	this.getInteres=getInteresOC	
}

function getInteresOC(NumMes, m_fin, m_aval, matSpread){
	return getInteres(NumMes,this.intereses, m_fin, m_aval, matSpread);
}


function formatNumber(numero, decimales) {
	
}

//===================================================
// Funciones adicionales
function LOG(str){/*
	document.writeln('<p>');
	document.writeln(str);
	document.writeln('</p>');*/
}
function PRINT(str){
	document.writeln('<p font-color="red">');
	document.writeln(str);
	document.writeln('</p>');

}