function goForit() {
var location;
var password;
password=this.document.passwordform.inputbox.value;
location="database/" + password + ".html";
// alert("asdf");
if (password!="1sae"){
// window.href="loginFailed.html";

     alert("Sorry, that password is incorrect");
   
     theKeeper=window.close()
	      }
     else { 
     theKeeper=window.close()
     fetch(location)
	      }

}  

//document.write("asdf");

//###########################################################################

//var newEmailConverted2;
//			newEmailConverted2 = TestAndConvertEmail(Request.Form("eMail"));
//  function TestAndConvertEmail( String::mailStr )
// give me a mail address and I either return invalid, 1sae address "fixed" or the orig unaltered
function TestAndConvertEmail( mailStr )
{
	var newEmail = mailStr; // save off original as it may not need changed
	var origEmail = new String( String(mailStr));  // make a real string out of it
	var goodSoFar = false;  // flag for invalid findings

	if ( origEmail.length  <=0 ) // obviously this can't be..
		return ( "invalid" );
	// start dissecting the email address.  Find that @ sign..
	for ( var index = 0; index < origEmail.length; index++ )
	{	
		if ( origEmail.charAt(index) == "@" )
		{
			goodSoFar = true; 	// found it
			break; 				// escape loop
		}
	} // index now holds the length position of the named mailbox (or we didn't find it)
	if ( !goodSoFar ) // didn't find an @ sign -duh- invalid for mail 
		return ( "invalid" );

	newEmail =(origEmail).substring(0,index); 	// get box/humans name
	origEmail = origEmail.toUpperCase();  		// do all compares uppercase to avoid confusion
	if ( origEmail.indexOf("1SAE.COM") == -1 )
		return ( mailStr );  // ain't no stinking spaced out age. no mod required, return original
	newEmail += "@mail.1SAE.com"; 				// tack on the goods
	return ( newEmail ); 						// send it back
	//Response.Write(newEmail);
}



//###########################################################################################

//// eMail validator/////////////////////////////////////////////////////////////////////
//change the onblur value passed to match form field and form name (document.form1.eMail)....
//    <input name="eMail" type="text" size="40" onBlur="return emailCheck2(this.value,document.form1.eMail);">

function emailCheck2 (emailStr,docFormfld) {

	var documentFormField;
	documentFormField = docFormfld;

	/* The following variable tells the rest of the function whether or not

	to verify that the address ends in a two-letter country or well-known

	TLD.  1 means check it, 0 means don't. */



	var checkTLD=1;



	/* The following is the list of known TLDs that an e-mail address must end with. */



	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;



	/* The following pattern is used to check if the entered e-mail address

	fits the user@domain format.  It also is used to separate the username

	from the domain. */



	var emailPat=/^(.+)@(.+)$/;



	/* The following string represents the pattern for matching all special

	characters.  We don't want to allow special characters in the address. 

	These characters include ( ) < > @ , ; : \ " . [ ] */



	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";



	/* The following string represents the range of characters allowed in a 

	username or domainname.  It really states which chars aren't allowed.*/



	var validChars="\[^\\s" + specialChars + "\]";



	/* The following pattern applies if the "user" is a quoted string (in

	which case, there are no rules about which characters are allowed

	and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com

	is a legal e-mail address. */



	var quotedUser="(\"[^\"]*\")";



	/* The following pattern applies for domains that are IP addresses,

	rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal

	e-mail address. NOTE: The square brackets are required. */



	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;



	/* The following string represents an atom (basically a series of non-special characters.) */



	var atom=validChars + '+';



	/* The following string represents one word in the typical username.

	For example, in john.doe@somewhere.com, john and doe are words.

	Basically, a word is either an atom or quoted string. */



	var word="(" + atom + "|" + quotedUser + ")";



	// The following pattern describes the structure of the user



	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");



	/* The following pattern describes the structure of a normal symbolic

	domain, as opposed to ipDomainPat, shown above. */



	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");



	/* Finally, let's start trying to figure out if the supplied address is valid. */



	/* Begin with the coarse pattern to simply break up user@domain into

	different pieces that are easy to analyze. */



	var matchArray=emailStr.match(emailPat);



	if (matchArray==null) {



	/* Too many/few @'s or something; basically, this address doesn't

	even fit the general mould of a valid e-mail address. */

	documentFormField.value="";

	documentFormField.focus();

	alert("Incorrect e-mail address (check @ and .'s)");

	return false;

	}

	var user=matchArray[1];

	var domain=matchArray[2];



	// Start by checking that only basic ASCII characters are in the strings (0-127).



	for (i=0; i<user.length; i++) 
	{

		if (user.charCodeAt(i)>127) {

			documentFormField.value="";

			documentFormField.focus();

			alert("Ths username contains invalid characters.");

			return false;

		}

	}

	for (i=0; i<domain.length; i++) 
	{

			if (domain.charCodeAt(i)>127) 
			{

				documentFormField.value="";

				ddocumentFormField.focus();

				alert("The domain name contains invalid characters.");

				return false;

   			}

	}



	// See if "user" is valid 



	if (user.match(userPat)==null) 
	{



		// user is not valid

		documentFormField.value="";

		documentFormField.focus();

		alert("The username doesn't seem to be valid.");



		return false;

	}



	/* if the e-mail address is at an IP address (as opposed to a symbolic

	host name) make sure the IP address is valid. */



	var IPArray=domain.match(ipDomainPat);

	if (IPArray!=null) 
	{



	// this is an IP address



		for (var i=1;i<=4;i++) 
		{

			if (IPArray[i]>255) 
			{

				documentFormField.value="";

				documentFormField.focus();

				alert("Destination IP address is invalid!");

				return false;

   			}

		}

		return true;

	}



	// Domain is symbolic name.  Check if it's valid.

 

	var atomPat=new RegExp("^" + atom + "$");

	var domArr=domain.split(".");

	var len=domArr.length;

	for (i=0;i<len;i++) 
	{

		if (domArr[i].search(atomPat)==-1) 
			{

			documentFormField.value="";

			documentFormField.focus();

			alert("The domain name does not seem to be valid.");

			return false;

   			}

	}



	/* domain name seems valid, but now make sure that it ends in a

	known top-level domain (like com, edu, gov) or a two-letter word,

	representing country (uk, nl), and that there's a hostname preceding 

	the domain or country. */



	if (checkTLD && domArr[domArr.length-1].length!=2 && domArr[domArr.length-1].search(knownDomsPat)==-1) 
		{

			alert("The address must end in a well-known domain or two letter " + "country.");



			documentFormField.value="";

			documentFormField.focus();





			return false;

		}



	// Make sure there's a host name preceding the domain.



	if (len<2) 
	{

		documentFormField.value="";

		documentFormField.focus();

		alert("This address is missing a hostname!");



		return false;

	}



	// If we've gotten this far, e-mail seems  valid!

	//return false;
	//return TestAndConvertEmail(emailStr);
	return true;

}