String.prototype.trim  =  _trim;
function _trim ( ){
	return this.replace(/^\s+|\s+$/g, "");
}

/* cria uma máscara de entrada de dados de acordo com o formato desejado */
function mask(obj, delim, loc){
	/*
		parâmetros:
			*obj: input a ser formatado
			*delim: caracter delimitador
			*loc: posição(ões) do caracater delimitador
	*/
	var locs = loc.split(',');
		for (i = 0; i <= locs.length; i++)
			for (k = 0; k <= obj.value.length; k++)
				// se a posição passada no parâmetro loc foi encontrada adicione à posição o caracter especificado no parâmetro delim  
				if (k == locs[i])	
					if (obj.value.substring(k, k + 1) != delim)	obj.value = obj.value.substring(0, k) + delim + obj.value.substring(k, obj.value.length)
}

// decodifica as urls passadas pelo popula na customTag 'listagem'
function decodificaUrl(coluna){
	/*
		parâmetros:
			coluna: vetor correspondente aos campos passados para o popula
	*/
	for (p=0;p<=coluna.length-1 ;p++){ 
		coluna[p]=unescape(coluna[p]);
	}
} 

/* ------------------------------------ utilizam a função mask para formatos específicos -------------------------------------- */

// máscara de cpf 
// ex: 999.999.999-99  
function maskCPF(obj){
	mask(obj, '-', '11');
	mask(obj, '.', '3,7');
}

// máscara de CNPJ
// ex: 999.999.999/9999-99 
function maskCNPJ(obj){
	mask(obj, '.', '2,6');
	mask(obj, '/', '10');
	mask(obj, '-', '15');
}

// mácara de CEP
// ex: 99999-999
function maskCEP(obj){ mask(obj, '-', '5'); }

// máscara de hora
// ex: 99:99:99
function maskTime(obj){ mask(obj,':','2,5'); }

// máscara de data
// ex: 99/99/9999
function maskDate(obj){ mask(obj,'/','2,5'); }

// máscara de telefone, com ou sem ddd
// ex: (99) 9999-9999 ou 9999-9999
function maskTel(obj,ddd){
	if(ddd){
		mask(obj,'(','0');
		mask(obj,')','3');
		mask(obj,' ','4');
		mask(obj,'-','9');
	}else	mask(obj,'-','4');
}

//	esta função recebe entrada numérica e converte em tipo moeda, 
//	com pontos a cada 3 casas e com vírgula separando as 2 casas decimais.
//	o parâmetro 'obj' deve ser sempre 'document.[nome_do_formulário].[nome_da_caixa_de_texto]'
//deve ser usada no objeto TEXT da seguinte forma (apenas um exemplo):
//	*onKeyPress="return somentenumeros(event.keyCode);"   //isto impede digitação de caracteres não numéricos
//	*onKeyUp="return pre_formataMoeda('document.FRM_proc.ValorTotal');"
function formataMoeda(obj) {
	var sinal=obj.value.substring(0,1);
	//Procura por vírgula...
	var re=/,/g
	//Procura por pontos ...
	var reP=/\./g
	//str passa a conter o valor do campo texto
	var str = obj.value  //ex:document.FormProc.VaEstimado.value

	//remove as virgulas e os pontos
	str=str.replace(re, "")

	str=str.replace(reP,"")

	//retira os zeros da esquerda, se houverem
	str=""+Math.abs(str);
	//armazena o tamanho da string numérica
	contchar=str.length;
	
	if (Math.abs(str) == 0 || contchar == 0)	{obj.value = "";return true;}

	else if (contchar<2)	{str="00"+str;contchar=3;}

	else if (contchar<3)	{str="0"+str;contchar=3;}

	contchar=str.length
	//Adiciona vírgula como separador de casas decimais
	str=str.substring(0,contchar-2)+','+str.charAt(contchar-2)+str.charAt(contchar-1)
	//Extrai os centavos
	centavos=str.substring(str.length,str.length-3)
	//Extrai o valor sem os centavos
	valor=str.substring(str.length-3,0)
	aux='';
	cont=1
	//coloca os pontos a cade tres casas decimais - 999.999.999
	for(i=valor.length-1;i>=0;i--)
	{
		aux=valor.charAt(i)+aux
		if(cont % 3==0)
			aux='.'+aux
		cont++
	}
	if(aux.charAt(0)=='.')
		aux=aux.substring(1,aux.length)
	if (sinal!='-'){
		var sinal='';	
	}
	obj.value = sinal+aux+centavos;
}
 
function FormataMoedaParaUS(campo)
 {
   if(!eNulo(campo))
 	{	
	 str=new String(campo.value) 
	 re=/\./g
	 str=str.replace(re,"")
	 re=/,/
	 str=str.replace(re,".")
	 return isNaN(str)? "":str		
 	 //retorna "" caso nao seja numero e retona o valor ja em dolar caso o contrario 
	}		
 	return("")
	//caso seja nulo retorna ""
 }
 
function formataMoedaPopula(obj){
	if (obj.value.substring(obj.value.length-3,obj.value.length-2)=='.' || obj.value.substring(obj.value.length-2,obj.value.length-1)=='.'){
		if (obj.value.substring(obj.value.length-2,obj.value.length-1)=='.'){
			obj.value=obj.value+'0';
		}
	}else{
	   obj.value=obj.value+'00';
	}
	formataMoeda(obj);	
}



/* --------------------------------------------------------------------------------------------------------------------------- */

// relacionada à customTag 'listagem'. Responsável pelo preenchimento do spam com o resultado da lista de registros desejada.
function relatorio(values,delim,pag){
	/*
		parâmetros:
			values: valores de filtro dinâmico da query do listagem, se necessário
			delim: delimitador utilizado para separar values
			pag: caso 1 verifica que há um valor a ser filtrado, contido no campo hidden 'hidRegua'
	*/
	var pagina = window.location.pathname.split("/");
	if(!delim) var delim=',';
	var values=values.split(delim);
	// verifica se existe algum campo nulo
	for (j=0;j<=values.length-1 ;j++){ 
		if (values[j]=='') values[j]='0';
	}
	f = document.forms[0];
	// reseta o valor da regua quando não for enviado um filtro para a mesma
	if (f.hidRegua && pag!=1) f.hidRegua.value='';
	// retorna para o primeiro registro da régua, quando não for enviado um filtro para a mesma
	if (f.hidInicio && pag!=1) f.hidInicio.value=1;
	// chamada para função carregaConteudo e busca dos valores da lista mostrada no arquivo padrão 'ajaxListaNomeSistema.cfm'.
	carregaConteudo('spnRelatorio',values,'ajaxLista'+pagina[1]+'.cfm?hidRegua='+f.hidRegua.value+'&hidInicio='+f.hidInicio.value+'&pagina='+pagina[2])
}

function carregaEditor(params,where,template){
	
	var params = params?params:'txtTexto';
	var pagina= window.location.pathname.split("/");
	// página padrão de consulta sql dinâmica - '/nomeSistema/ajaxSqlNomeSistema.cfm', utilizada pela customTag 'carrega_combo' encontrada na url padrão de acesso 'ajaxCarregaCombo.cfm'
	if (!template) var template= '/'+pagina[1]+'/ajaxSql'+pagina[1]+'.cfm';
	// codifica a url para o parâmetro where
	where=escape(where);
	
	// parâmetros a serem passados para a url 
	var pars = 'params='+params+'&where='+where+'&template='+template;
	// acesso a url padrão da função		
	var myAjax = new Ajax.Request(
		'/includes/ajaxCarregaEditor.cfm', 
		{
			method: 'get', 
			parameters: pars, 
			onComplete: mostraResposta
		});		
	
	// acesso ao conteúdo contido na consulta da url	
	function mostraResposta(requisicaoOriginal){
		var oEditor = FCKeditorAPI.GetInstance(params) ;
		oEditor.SetHTML(requisicaoOriginal.responseText.trim()) ;
	}
}

// responsável pelo preenchimento de um determinado conteúdo contido em uma url e atribuído a um campo específico
// por padrão, os conteúdos de referência estão no arquivo 'ajaxNomeSistema.cfm'
// utiliza tecnologia ajax para acesso dinâmico ao conteúdo desejado
function carregaConteudo(campo,values,url){
	/*
		parâmetros:
			*campo: nome do campo a ser atribuído o conteúdo retornado na consulta
			 values: valores de utilização dinâmica na query da url passada 
			 url: local onde o conteúdo será buscado
	*/
	var pagina= window.location.pathname.split("/");
	// se a url não for definida, a padrão será ajaxNomeSistema.cfm
	if (!url) var url = 'ajax'+pagina[1]+'.cfm';
	// parâmetros a serem passados para a url 
	var pars = 'campo='+campo+'&values='+values;		
	// acesso a url
	var myAjax = new Ajax.Request(
		url, 
		{
			method: 'get', 
			parameters: pars, 
			onComplete: mostraResposta
		});		
	
	// acesso ao conteúdo contido na consulta da url	
	function mostraResposta(requisicaoOriginal){
		$(campo).innerHTML = requisicaoOriginal.responseText.trim();
	}
}

// responsável pelo preenchimento dos campos de um formulário de acordo com um registro selecionado
// preenche vários registros de acordo com a execução de uma query apenas
// os valores dos wheres do parâmetro 'whereCarregaCombo' só suportam uma condicional por where, ou seja, o where n poderá ter 'and' nem 'or'
// os parâmetros do 'whereCarregaCombo' devem ser passados obrigatoriamente desta forma: campoDoBD = $('valorDoCampoNoForm')
// utiliza tecnologia ajax para acesso dinâmico ao conteúdo desejado
function carregaFormulario(campos,where,camposCarregaCombo,whereCarregaCombo){
	/*
		parâmetros:
			*campo: nome do(s) campo(s) a ser(em) atribuído(s) o(s) conteúdo(s) retornado(s) na consulta
			*where: condição utilizada no where da query a ser executada
			 camposCarregaCombo: lista de campos que irão executar a função carregaCombo. Quando houver pelo menos uma chamada a esta função os outros parâmetros da lista devem conter o valor 0. ex: 0,cboPessoa,0,0,cboUsuario  
			 whereCarregaCombo: segue a mesma regra citada no exemplo de camposCarregaCombo porém ao invés do nome do campo deve conter o valor da condicional a ser executada na query da função carregaCombo. ex: 0,pes_codigo=13,0,0,555555
	*/
	var pagina = window.location.pathname.split("/");
	// página padrão de consulta sql dinâmica - '/nomeSistema/ajaxSqlNomeSistema.cfm', utilizada pela customTag 'carrega_formulario' encontrada na url padrão de acesso 'ajaxCarregaFormulario.cfm'
	var template = '/'+pagina[1]+'/ajaxSql'+pagina[1]+'.cfm';
	// parâmetros a serem passados para a url 
	var pars = 'where='+where+'&template='+template;
	
	// acesso a url padrão da função		
	var myAjax = new Ajax.Request(
		'/includes/ajaxCarregaFormulario.cfm', 
		{
			method: 'get', 
			parameters: pars, 
			onComplete: mostraResposta
		});		
	
	// acesso ao conteúdo contido na consulta da url	
	function mostraResposta(requisicaoOriginal){		
		var lista = campos.split(",");
		if (whereCarregaCombo) var listaWheresCombo = whereCarregaCombo.split(",");
		if (camposCarregaCombo) var listaCamposCombo = camposCarregaCombo.split(",");
		// trata o retorno como um vetor para atribuir seu valor aos seus respectivos campos
		var retorno = requisicaoOriginal.responseText.trim().split("%%");
		// atribuição dos valores retornados para os campos
		for (j=0;j<=lista.length-1 ;j++){ 
			// caso o campo seja span ou um div
			if ((lista[j].substr(0,3).toUpperCase() == "SPN")||(lista[j].substr(0,3).toUpperCase() == "DIV")){
				$(lista[j]).innerHTML = retorno[j].trim();
			}else{
				// caso seja um combo e possui a função carregaCombo relacionada executa a mesma
				if (listaCamposCombo && listaCamposCombo[j] != 0){
					// separa o valor do where numa lista, o primeiro registro corresponde à condicional do where e o segundo ao valor desta condicional
					var listaWheresComboValue= listaWheresCombo[j].split("$");
					listaWheresComboValue[1]='$'+listaWheresComboValue[1];
					carregaCombo(listaCamposCombo[j],listaWheresComboValue[0]+'\''+eval(listaWheresComboValue[1])+'\'',$(lista[j]).value = retorno[j].trim());
				}else{
					$(lista[j]).value = retorno[j].trim();
				}
			}
		}
	}
}

// responsável pelo preenchimento dos combos de um formulário de acordo com um registro selecionado
// pode preencher mais de um combo, porém cada um deve executar querys diferentes
// utiliza tecnologia ajax para acesso dinâmico ao conteúdo desejado
function carregaCombo(params,where,selected,oneQuery,def,template){
	/*
		parâmetros:
			*params: nome do(s) combo(s) a ser(em) atribuído(s) o(s) conteúdo(s) retornado(s) na consulta
			*where: condição(ões) utilizada(s) no where da(s) query(s) a ser(em) executada(s)
			 selected: valor do combo
			 oneQuery: cerifica se a customTag irá rodar uma única query ou mais
			 def: verifica se o primeiro registro em branco pertence ou não ao combo
			 template: verifica o template que contém a consulta sql da base de dados
	*/
	// verifica se existe algum campo nulo
	if (!oneQuery) var oneQuery='no';
	if (!def) var def='yes';
	if (!selected) var selected='no';
	var pagina= window.location.pathname.split("/");
	// página padrão de consulta sql dinâmica - '/nomeSistema/ajaxSqlNomeSistema.cfm', utilizada pela customTag 'carrega_combo' encontrada na url padrão de acesso 'ajaxCarregaCombo.cfm'
	if (!template) var template= '/'+pagina[1]+'/ajaxSql'+pagina[1]+'.cfm';
	var campo=params.split(',');
	// codifica a url para o parâmetro where
	where=escape(where);
	// parâmetros a serem passados para a url 
	var pars = 'params='+params+'&oneQuery='+oneQuery+'&def='+def+'&where='+where+'&template='+template+'&selected='+selected;
	// acesso a url padrão da função		
	var myAjax = new Ajax.Updater(
		campo[0], 
		'/includes/ajaxCarregaCombo.cfm', 
		{
			method: 'get', 
			evalScripts: true,
			parameters: pars
		});
}

// responsável pelo preenchimento dos campos(inputs, divs, spans) de um formulário de acordo com um registro selecionado
// pode preencher mais de um campo, porém cada um deve executar querys diferentes
// utiliza tecnologia ajax para acesso dinâmico ao conteúdo desejado
function carregaCampo(params,where,template){
	/*
		parâmetros:
			*params: nome do(s) campo(s) a ser(em) atribuído(s) o(s) conteúdo(s) retornado(s) na consulta
			*where: condição(ões) utilizada(s) no where da(s) query(s) a ser(em) executada(s)
			 template: verifica o template que contém a consulta sql da base de dados
	*/		
	//alert(where)
	var where=where.split(',');
	var where2='';
	for (j=0;j<=where.length-1 ;j++){ 
		if (where[j]=='') where[j]='0';
		else {
			where[j]=where[j].split('$');
			if (where[j].length != 1){
				for (l=0;l<=where[j].length-1 ;l++){ 
					if (where[j][l]=='') where[j][l]='0';
					where2=where2+'$'+where[j][l];
				}
				where[j]=where2;
			}
		}
	}
	//alert(where)
	var pagina = window.location.pathname.split("/");
	// página padrão de consulta sql dinâmica - '/nomeSistema/ajaxSqlNomeSistema.cfm', utilizada pela customTag 'carrega_campo' encontrada na url padrão de acesso 'ajaxCarregaCampo.cfm'
	if (!template) var template= '/'+pagina[1]+'/ajaxSql'+pagina[1]+'.cfm';
	// parâmetros a serem passados para a url 
	var pars = 'params='+params+'&where='+where+'&template='+template;
	// acesso a url padrão da função		
	var myAjax = new Ajax.Request(
		'/includes/ajaxCarregaCampo.cfm', 
		{
			method: 'get', 
			parameters: pars, 
			onComplete: mostraResposta
		});		
	
	// acesso ao conteúdo contido na consulta da url	
	// faz a verificação se o campo passado era um div, span ou input
	function mostraResposta(requisicaoOriginal){
		var lista= params.split(",");
		var retorno= requisicaoOriginal.responseText.trim().split("%%");
		for (j=0;j<=lista.length-1 ;j++){ 
			if ((lista[j].substr(0,3).toUpperCase() == "SPN")||(lista[j].substr(0,3).toUpperCase() == "DIV")){
				$(lista[j]).innerHTML = retorno[j].trim();
			}else{
				$(lista[j]).value = retorno[j].trim();
			}
		}
	}
}

//necessária quando se deseja chamar alguma função dando 'enter' no campo de foco
function enterSubmete(funcao,e) {
	/*
		parâmetros:
			*funcao: função a ser executada
			*e: palavra 'event', obrigatorio para o ideal funcionamento da função
	*/	
	// trata o valor teclado para os diversos tipos de browser
	var key = (window.event)?event.keyCode:e.which;
	if (key==13) eval(funcao);
}

// função específica para a customTag 'paginação'
// responsável pela mudança do valor do primeiro registro exibido no listagem 
function mudaContador(num,pos){
	/*
		parâmetros:
			*num: quantidade de registros para cáculo
			*pos: botão clicado, responsável pela mudança do sinal no cáculo do primeiro registro exibido no listagem
	*/	
	var op = (pos=='btnProximo')?'+':'-';
	document.getElementById('hidInicio').value = eval(parseInt(document.getElementById('hidInicio').value)+op+num);
}

//função específica para a customTag 'regua'
// responsável pelo filtro dos registros de acordo com o valor selecionado na régua
function mudaRegua(letra){
	/*
		parâmetros:
			*letra: valor a ser filtrado pela régua
	*/	
	// starta a lista de registros para o primeiro liberado pela query
	document.forms[0].hidInicio.value=1;
	if(document.forms[0].txtBusca) document.forms[0].txtBusca.value='';
	document.forms[0].hidRegua.value=letra;	
}

// função responsável pela alteração dinâmica de botões
// trata com precisão a modificação do botão 'Incluir' para 'Alterar','Excluir','Incluir'
function alteraBotao(tipo,nome,nomeId,botao){
	/*
		parâmetros:
			*tipo: valor novo do botão: 'A'-ALTERAR, 'E'-EXCLUIR, 'I'-INCLUIR
			 nome: valor do botão
			 nomeId: id do botão
			 botao: objeto
	*/	
	if (!botao) botao=document.forms[0].btnIncluir;
	if (!nome) nome='Incluir';
	if (tipo.toUpperCase()=="A"){
		nomeId='btnAlterar';
		nome='Alterar';
	}else if (tipo.toUpperCase()=="E"){
		nomeId='btnExcluir';
		nome='Confirmar Exclusão';	
	}else if (tipo.toUpperCase()=="I"){
		nomeId='btnIncluir';
		nome='Incluir';	
	}
		botao.id=nomeId;
		botao.name=nomeId;
		botao.value=nome;	
}

// verifica a integridade dos dados em um período (datas válidas e período válido)
function dataPeriodo(obj1,obj2,msg){
	/*
		parâmetros:
			*obj1: input da data inicial
			*obj2: input da data final
	*/	
	// verifica se os valores dos inputs são válidos, caso positivo, verifica se a data inicial é menor do que a data final 
	if(!msg) msg='Data Inicial maior que Data Final.';
	if (!dataValida($(obj1))||!dataValida($(obj2))){
			return false;
	}else if(!eNulo($(obj1)) && !eNulo($(obj2))){
		 if (dataComp($(obj1).value,$(obj2).value) == true){ 
			alert(msg);
			$(obj1).value='';
			$(obj2).value='';
			return false;
		}
	}
}

// verifica se os campos obrigatórios do formulário foram preenchidos
function obrigatorio(campos,desc){
	/*
		parâmetros:
			*campos: campos do formulário que são obrigatórios
			*desc: palavra que identifica o campo no alerta dado ao usuário
	*/	
	 for (i = 0; i < campos.length; i++) {
		if (eNulo($(campos[i])) || $(campos[i]).value==0) { 
		  alert(desc[i].toUpperCase() + " deve ser preenchido.");
		  $(campos[i]).focus();
		  return false;
		}
	  }
	  return true;
}

// atribui valores já conhecidos aos seus respectivos campos 
function atribuiValores(campos,coluna){	
	/*
		parâmetros:
			*campos: campos a serem preenchidos
			*coluna: vetor de colunas para preenchimento doa campos
	*/	
	for (i = 0; i < campos.length; i++) {
		if ($(campos[i]).id.substr(0,3) == "spn" || $(campos[i]).id.substr(0,3) == "SPN")				
			$(campos[i]).innerHTML=coluna[i];
		else	
			$(campos[i]).value=coluna[i];
	}		
}

// verifica se a data digitada em um input é válida
function dataValida(obj){
	/*
		parâmetros:
			*obj: input da data
	*/	
	if (eNulo(obj)){
		return false;
	}else{
		date=obj.value.split('/');
		d=new Date(date[2],date[1]-1,date[0]);
		if ((1*date[0]==d.getDate() && 1*date[1]==(d.getMonth()+1) && 1*date[2]==d.getFullYear())) return true;
		alert("Data inválida.");
		Field.clear(obj);
		Field.focus(obj);
		return false;
	}
}

// habilita e desabilita campos de um formulario, pode também torná-los somente leitura
function desHabilita(aCampos,status){
	/*
		parâmetros:
			*aCampos: campo(s) a ser(em) habilitado(s) ou desabilitado(s)
			*status: valor(es) que informa(m) se o(s) campo(s) será(ão) habilitado(s) 'H', desabilitado(s) 'D', somente leitura 'DR' ou normal(is) 'HR'
	*/	
	if (status.toUpperCase()=="D" || status.toUpperCase()=="DR"){
		for (zzz = 0; zzz < aCampos.length; zzz++) {
			if (status.toUpperCase()=="DR"){
				$(aCampos[zzz]).readOnly=true;
			}else{
				$(aCampos[zzz]).disabled=true;
			}
		}
	 }else if (status.toUpperCase()=="H" || status.toUpperCase()=="HR"){
		for (zzz = 0; zzz < aCampos.length; zzz++) {
			if (status.toUpperCase()=="HR"){
				$(aCampos[zzz]).readOnly=false;
			}else{
				$(aCampos[zzz]).disabled=false;
			}
		}
	 }	
}

// verifica se o valor digitado é um caracter numérico
function soNum(e) {
	
	// trata o valor teclado para os diversos tipos de browser
	var key = (window.event)?event.keyCode:e.which;
	return key>=48&&key<=57?true:false;
}

// retorna positivo caso o campo esteja em branco ou nulo
function eNulo(campo) {
	/*
		parâmetros:
			*campo: objeto a ser verificado
	*/	
	//Procura por espaços em branco
	re = /\s/g;
	
	semNulos = campo.value.replace(re, "");
	if (semNulos == '') {
		campo.value = semNulos;
		return (true);
	}
	
	//Substitui espaços em branco por nulos
	re = /^\s+/g;
	campo.value = campo.value.replace(re, "");
	re = /\s+$/g;
	campo.value = campo.value.replace(re, "");
	
	return (false);
}

// compara duas datas e retorna a maior
function dataComp(data1, data2) {
	/*
		parâmetros:
			*data1: primero obejto data
			*data2: segundo objeto data
	*/	

	//Separa os elementos da data: dia, mês e ano
	elementosData1 = data1.split("/")
	elementosData2 = data2.split("/")
	
	//Pega o tempo passado desde 1/1/1970 em milissegundos
	tempoData1 = new Date(elementosData1[2], elementosData1[1]-1, elementosData1[0]).getTime()
	tempoData2 = new Date(elementosData2[2], elementosData2[1]-1, elementosData2[0]).getTime()
	
	//Retorna quem é maior
	return(tempoData1 > tempoData2)
}

//para utilização na função buscaDiaSemana, formata dd/mm/yyyy uma data para yyy/mm/dd
function formataDataJS(data){
	/*
		parâmetros:
			data: valor da data a ser formatada
	*/
	elementosData = data.split("/")
	dataJS = new Date(elementosData[2], elementosData[1]-1, elementosData[0])
	return dataJS;
}

// retorna o dia da semana de acordo com a data passada
function buscaDiaSemana(data){
	/*
		parâmetros:
			*data: valor da data a ser verificada
	*/	
	var retorno;
	switch (formataDataJS(data).getDay()){
		case 0:
			retorno='Domingo';
			break;
		case 1:
			retorno='Segunda-feira';
			break;
		case 2:
			retorno='Terça-feira';
			break;
		case 3:
			retorno='Quarta-feira';
			break;
		case 4:
			retorno='Quinta-feira';
			break;
		case 5:
			retorno='Sexta-feira';
			break;
		case 6:
			retorno='Sábado';
			break;
	}
	return retorno;
}