<!--
var sColorLink = '#FF0000';
function fSetLink(el, bFlag)
{
	if (bFlag)
		el.style.color = sColorLink;
	else
		el.style.color = '';
}
//-->

function _fchecksep(sDate)
{ // restituisce il separatore presente in sDate
	var sep;
	if (sDate == '')
		return false;
	
	if (sDate.indexOf("/") > 0)
		return "/";
	else if (sDate.indexOf("-") > 0)
		return "-";
	else if (sDate.indexOf(".") > 0)
		return ".";
	else if (sDate.length == 8)
		return "NO_SEP";
	else
		return false;
}

function fCheckDate(sDate, sMode)
{ // Verifica che il valore di sDate sia una data corretta
	var sep;
	var d, m, yy
	if (sDate == '')
		return true;

	sep = _fchecksep(sDate)
	if (sep == false)
	{
		if (sMode == 'DEBUG')
			alert('data non corretta');
		return false;
	}
	if (sep == 'NO_SEP')
	{
		d = sDate.substr(0,2);
		m = sDate.substr(2,2);
		yy = sDate.substr(4,4);
	}
	else
	{
		var aDate = sDate.split(sep);
		d = aDate[0];
		m = aDate[1];
		yy = aDate[2];
	}
	if (d.length < 2 || parseInt(d) > 31 || isNaN(d))
	{
		if (sMode == 'DEBUG')
			alert('giorno non corretto');
		return false;
	}
	if (m.length < 2 || parseInt(m) > 12 || isNaN(m))
	{
		if (sMode == 'DEBUG')
			alert('mese non corretto');
		return false;
	}
	if (yy.length < 4 || parseInt(yy) > 2050 || isNaN(yy))
	{
		if (sMode == 'DEBUG')
			alert('anno non corretto');
		return false;
	}

	switch (parseInt(parseFloat(m)))
	{
		case	4:
		case	6:
		case	9:
		case 11:
			if (parseInt(parseFloat(d)) == 0 || parseInt(d) > 30)
			{
				if (sMode == 'DEBUG')
					alert('giorno non corretto');
				return false;
			}
			break;
		case	1:
		case	3:
		case	5:
		case	7:
		case	8:
		case 10:
		case 12:
			if (parseInt(parseFloat(d)) == 0 || parseInt(d) > 31)
			{
				if (sMode == 'DEBUG')
					alert('giorno non corretto');
				return false;
			}
			break;
		case	2: // febbraio con verifica dell'anno bisestile
			var nTmp = 28;
			if (parseInt(yy) % 4 == 0)
				nTmp = 29;
			if (parseInt(parseFloat(d)) == 0 || parseInt(d) > nTmp)
			{
				if (sMode == 'DEBUG')
					alert("l'anno non è bisestile");
				return false;
			}
			break;
	}
	return true;			
}

function fCompareDate(sDate1, sDate2)
{ // confronta due date e ritorna true se sDate1 < sDate2 
	var sep1, sep2;
	var aDate1, aDate2;
	var nTmp1, nTmp2;
	if (sDate1 == '' || sDate2 == '')
		return false;
	
	if (!fCheckDate(sDate1) || !fCheckDate(sDate2))
		return false;
	
	sep1 = _fchecksep(sDate1);
	sep2 = _fchecksep(sDate2);
	if (sep1 == 'NO_SEP')
		aDate1 = Array(sDate1.substr(0,2),sDate1.substr(2,2),sDate1.substr(4,4));
	else
		aDate1 = sDate1.split(sep1);	
	if (sep2 == 'NO_SEP')
		aDate2 = Array(sDate2.substr(0,2),sDate2.substr(2,2),sDate2.substr(4,4));
	else
		aDate2 = sDate2.split(sep2);
	
	nTmp1 = parseInt(aDate1[2].toString() + aDate1[1].toString() + aDate1[0].toString());
	nTmp2 = parseInt(aDate2[2].toString() + aDate2[1].toString() + aDate2[0].toString());
	if (nTmp1 <= nTmp2)
		return true;
	else
		return false;
}

function fFormatDate(sDate, newSep)
{ // formatta una data nel formato ggmmaaaa sulla base del separatore inserito 
	var sep;
	var d, m, yy
	if (sDate == '')
		return true;
	sep = _fchecksep(sDate)
	if (sep == false)
		return false;
	if (sep == 'NO_SEP')
	{
		d = sDate.substr(0,2);
		m = sDate.substr(2,2);
		yy = sDate.substr(4,4);
	}
	else
	{
		var aDate = sDate.split(sep);
		d = aDate[0];
		m = aDate[1];
		yy = aDate[2];
	}
	return d + newSep + m + newSep + yy;
}

function fWinDialog(url, opt)
{
//	url = sPage + "?Id=" + id ;
//	Mod="dialogWidth: 800px; dialogHeight: 360px; center: 1; scroll: 1; help: 1; status: 0;";
	if (window.showModalDialog(URL,null,opt))
		return true;
	else
		return false;
}

function trimblanks( sx )
{
/*
  Elimina dalla stringa sx tutti gli eventuali blanks a destra e a sinistra
  restituendo la stringa ripulita.
*/
	sx = sx.replace( /^ */, "" );
	sx = sx.replace( / *$/, "" );
	return sx;
}

function fEncryptPwd(el)
{
	var A, B, C, D;
	var X = new Array(16);
	var filter32 = 0xFFffFFff; // Maschera usata per filtrare solo 32 bit

	function rot( num, nBits )
	{
		return ( ( num << nBits ) | ( num >>> ( 32 - nBits ) ) ) & filter32;
	}

	function ProcessBlock()
	// Step 4
	{
		var AA = A;
		var BB = B;
		var CC = C;
		var DD = D;
		
		A = ( B + rot(( A + ( B & C | ~B & D ) + X[ 0] + 0xd76aa478 ),  7 ) ) & filter32;
		D = ( A + rot(( D + ( A & B | ~A & C ) + X[ 1] + 0xe8c7b756 ), 12 ) ) & filter32;
		C = ( D + rot(( C + ( D & A | ~D & B ) + X[ 2] + 0x242070db ), 17 ) ) & filter32;
		B = ( C + rot(( B + ( C & D | ~C & A ) + X[ 3] + 0xc1bdceee ), 22 ) ) & filter32;
		A = ( B + rot(( A + ( B & C | ~B & D ) + X[ 4] + 0xf57c0faf ),  7 ) ) & filter32;
		D = ( A + rot(( D + ( A & B | ~A & C ) + X[ 5] + 0x4787c62a ), 12 ) ) & filter32;
		C = ( D + rot(( C + ( D & A | ~D & B ) + X[ 6] + 0xa8304613 ), 17 ) ) & filter32;
		B = ( C + rot(( B + ( C & D | ~C & A ) + X[ 7] + 0xfd469501 ), 22 ) ) & filter32;
		A = ( B + rot(( A + ( B & C | ~B & D ) + X[ 8] + 0x698098d8 ),  7 ) ) & filter32;
		D = ( A + rot(( D + ( A & B | ~A & C ) + X[ 9] + 0x8b44f7af ), 12 ) ) & filter32;
		C = ( D + rot(( C + ( D & A | ~D & B ) + X[10] + 0xffff5bb1 ), 17 ) ) & filter32;
		B = ( C + rot(( B + ( C & D | ~C & A ) + X[11] + 0x895cd7be ), 22 ) ) & filter32;
		A = ( B + rot(( A + ( B & C | ~B & D ) + X[12] + 0x6b901122 ),  7 ) ) & filter32;
		D = ( A + rot(( D + ( A & B | ~A & C ) + X[13] + 0xfd987193 ), 12 ) ) & filter32;
		C = ( D + rot(( C + ( D & A | ~D & B ) + X[14] + 0xa679438e ), 17 ) ) & filter32;
		B = ( C + rot(( B + ( C & D | ~C & A ) + X[15] + 0x49b40821 ), 22 ) ) & filter32;

	// Round 2
		A = ( B + rot(( A + ( B & D | C & ~D ) + X[ 1] + 0xf61e2562 ),  5 ) ) & filter32;
		D = ( A + rot(( D + ( A & C | B & ~C ) + X[ 6] + 0xc040b340 ),  9 ) ) & filter32;
		C = ( D + rot(( C + ( D & B | A & ~B ) + X[11] + 0x265e5a51 ), 14 ) ) & filter32;
		B = ( C + rot(( B + ( C & A | D & ~A ) + X[ 0] + 0xe9b6c7aa ), 20 ) ) & filter32;
		A = ( B + rot(( A + ( B & D | C & ~D ) + X[ 5] + 0xd62f105d ),  5 ) ) & filter32;
		D = ( A + rot(( D + ( A & C | B & ~C ) + X[10] + 0x02441453 ),  9 ) ) & filter32;
		C = ( D + rot(( C + ( D & B | A & ~B ) + X[15] + 0xd8a1e681 ), 14 ) ) & filter32;
		B = ( C + rot(( B + ( C & A | D & ~A ) + X[ 4] + 0xe7d3fbc8 ), 20 ) ) & filter32;
		A = ( B + rot(( A + ( B & D | C & ~D ) + X[ 9] + 0x21e1cde6 ),  5 ) ) & filter32;
		D = ( A + rot(( D + ( A & C | B & ~C ) + X[14] + 0xc33707d6 ),  9 ) ) & filter32;
		C = ( D + rot(( C + ( D & B | A & ~B ) + X[ 3] + 0xf4d50d87 ), 14 ) ) & filter32;
		B = ( C + rot(( B + ( C & A | D & ~A ) + X[ 8] + 0x455a14ed ), 20 ) ) & filter32;
		A = ( B + rot(( A + ( B & D | C & ~D ) + X[13] + 0xa9e3e905 ),  5 ) ) & filter32;
		D = ( A + rot(( D + ( A & C | B & ~C ) + X[ 2] + 0xfcefa3f8 ),  9 ) ) & filter32;
		C = ( D + rot(( C + ( D & B | A & ~B ) + X[ 7] + 0x676f02d9 ), 14 ) ) & filter32;
		B = ( C + rot(( B + ( C & A | D & ~A ) + X[12] + 0x8d2a4c8a ), 20 ) ) & filter32;
		
	// Round 3
		A = ( B + rot(( A + ( B ^ C ^ D ) + X[ 5] + 0xfffa3942 ),  4 ) ) & filter32;
		D = ( A + rot(( D + ( A ^ B ^ C ) + X[ 8] + 0x8771f681 ), 11 ) ) & filter32;
		C = ( D + rot(( C + ( D ^ A ^ B ) + X[11] + 0x6d9d6122 ), 16 ) ) & filter32;
		B = ( C + rot(( B + ( C ^ D ^ A ) + X[14] + 0xfde5380c ), 23 ) ) & filter32;
		A = ( B + rot(( A + ( B ^ C ^ D ) + X[ 1] + 0xa4beea44 ),  4 ) ) & filter32;
		D = ( A + rot(( D + ( A ^ B ^ C ) + X[ 4] + 0x4bdecfa9 ), 11 ) ) & filter32;
		C = ( D + rot(( C + ( D ^ A ^ B ) + X[ 7] + 0xf6bb4b60 ), 16 ) ) & filter32;
		B = ( C + rot(( B + ( C ^ D ^ A ) + X[10] + 0xbebfbc70 ), 23 ) ) & filter32;
		A = ( B + rot(( A + ( B ^ C ^ D ) + X[13] + 0x289b7ec6 ),  4 ) ) & filter32;
		D = ( A + rot(( D + ( A ^ B ^ C ) + X[ 0] + 0xeaa127fa ), 11 ) ) & filter32;
		C = ( D + rot(( C + ( D ^ A ^ B ) + X[ 3] + 0xd4ef3085 ), 16 ) ) & filter32;
		B = ( C + rot(( B + ( C ^ D ^ A ) + X[ 6] + 0x04881d05 ), 23 ) ) & filter32;
		A = ( B + rot(( A + ( B ^ C ^ D ) + X[ 9] + 0xd9d4d039 ),  4 ) ) & filter32;
		D = ( A + rot(( D + ( A ^ B ^ C ) + X[12] + 0xe6db99e5 ), 11 ) ) & filter32;
		C = ( D + rot(( C + ( D ^ A ^ B ) + X[15] + 0x1fa27cf8 ), 16 ) ) & filter32;
		B = ( C + rot(( B + ( C ^ D ^ A ) + X[ 2] + 0xc4ac5665 ), 23 ) ) & filter32;

	// Round 4
		A = ( B + rot(( A + ( C ^ ( B | ~D ) ) + X[ 0] + 0xf4292244 ),  6 ) ) & filter32;
		D = ( A + rot(( D + ( B ^ ( A | ~C ) ) + X[ 7] + 0x432aff97 ), 10 ) ) & filter32;
		C = ( D + rot(( C + ( A ^ ( D | ~B ) ) + X[14] + 0xab9423a7 ), 15 ) ) & filter32;
		B = ( C + rot(( B + ( D ^ ( C | ~A ) ) + X[ 5] + 0xfc93a039 ), 21 ) ) & filter32;
		A = ( B + rot(( A + ( C ^ ( B | ~D ) ) + X[12] + 0x655b59c3 ),  6 ) ) & filter32;
		D = ( A + rot(( D + ( B ^ ( A | ~C ) ) + X[ 3] + 0x8f0ccc92 ), 10 ) ) & filter32;
		C = ( D + rot(( C + ( A ^ ( D | ~B ) ) + X[10] + 0xffeff47d ), 15 ) ) & filter32;
		B = ( C + rot(( B + ( D ^ ( C | ~A ) ) + X[ 1] + 0x85845dd1 ), 21 ) ) & filter32;
		A = ( B + rot(( A + ( C ^ ( B | ~D ) ) + X[ 8] + 0x6fa87e4f ),  6 ) ) & filter32;
		D = ( A + rot(( D + ( B ^ ( A | ~C ) ) + X[15] + 0xfe2ce6e0 ), 10 ) ) & filter32;
		C = ( D + rot(( C + ( A ^ ( D | ~B ) ) + X[ 6] + 0xa3014314 ), 15 ) ) & filter32;
		B = ( C + rot(( B + ( D ^ ( C | ~A ) ) + X[13] + 0x4e0811a1 ), 21 ) ) & filter32;
		A = ( B + rot(( A + ( C ^ ( B | ~D ) ) + X[ 4] + 0xf7537e82 ),  6 ) ) & filter32;
		D = ( A + rot(( D + ( B ^ ( A | ~C ) ) + X[11] + 0xbd3af235 ), 10 ) ) & filter32;
		C = ( D + rot(( C + ( A ^ ( D | ~B ) ) + X[ 2] + 0x2ad7d2bb ), 15 ) ) & filter32;
		B = ( C + rot(( B + ( D ^ ( C | ~A ) ) + X[ 9] + 0xeb86d391 ), 21 ) ) & filter32;
		
		A = ( A + AA ) & filter32;
		B = ( B + BB ) & filter32;
		C = ( C + CC ) & filter32;
		D = ( D + DD ) & filter32;
	}

	function CodBlock( str )
	// Codifica un blocco normale di 16 word
	{
		for ( var i = 0; i < 16; i++ )
			X[i] = ( str.charCodeAt( i*4 + 3 ) << 24 )
					 + ( str.charCodeAt( i*4 + 2 ) << 16 )
					 + ( str.charCodeAt( i*4 + 1 ) <<  8 )
					 + str.charCodeAt( i*4 );
		ProcessBlock();
	}

	function CodLastBlock( str, length )
	// Codifica l'ultimo blocco, di 14 word + la lunghezza
	{
		for ( var i = 0; i < 14; i++ )
			X[i] = ( str.charCodeAt( i*4 + 3 ) << 24 )
					 + ( str.charCodeAt( i*4 + 2 ) << 16 )
					 + ( str.charCodeAt( i*4 + 1 ) <<  8 )
					 + str.charCodeAt( i*4 );
		X[14] = length & filter32;
		X[15] = ( ( length >>> 16 ) >>> 16 ) & filter32;
		ProcessBlock();
	}

	function int2Hex( n )
	// Converte un numero in esadecimale con sempre 8 cifre
	{
		var ret = ( n + 0x100000000 ).toString( 16 );
		ret = ( "00000000" + ret ).substr( ret.length, 8 );
		return ret;
	}

	function int2HexR( n )
	// Converte un numero in esadecimale mettendo prima i byte meno significativi
	{
		var ret = "";
		for ( var i = 0; i < 4; i++ )
		{
			ret += ( ( n & 0xf0 ) >>> 4 ).toString( 16 ) + ( n & 0x0f ).toString( 16 )
			n >>>= 8;
		}
		return ret;
	}

	function CodMd5( str )
	{
		// Inizializza il buffer
		A = 0x67452301;
		B = 0xefcdab89;
		C = 0x98badcfe;
		D = 0x10325476;

		// Append Padding Bits
		var origLen = str.length;
		var paddingLen = 64 - ( origLen + 8 ) % 64;
		str += "\x80";
		
		for ( var i = 1; i < paddingLen; i++ )
			str += "\x00";

		for ( var i = 0; i < ( str.length	/ 64 ) - 1; i++ )
			CodBlock( str.substr( i*64, 64 ) )
		// aggiungi la lunghezza in fondo all'ultimo blocco
		CodLastBlock( str.substr( i*64 ), origLen*8 );


		var output = int2HexR( A );
		output += int2HexR( B );
		output += int2HexR( C );
		output += int2HexR( D );
		return output;
	}

	function Codifica( str )
	{
		return str;
	}
	var str2encode = el.value;
	var strCodPwd = CodMd5( str2encode );
	el.value = strCodPwd;
//	el.value = "Ciao!Ciao!";
	return(strCodPwd);
}