var sUserID = "Member ID";
	var sIDNo = "ID Number";
	var defaultEmptyOK = false
	
	var whitespace = " \t\n\r";
	
	// isInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if all characters in string s are numbers.
	//
	// Accepts non-signed integers only. Does not accept floating 
	// point, exponential notation, etc.
	//
	// We don't use parseInt because that would accept a string
	// with trailing non-numeric characters.
	//
	// By default, returns defaultEmptyOK if s is empty.
	// There is an optional second argument called emptyOK.
	// emptyOK is used to override for a single function call
	//      the default behavior which is specified globally by
	//      defaultEmptyOK.
	// If emptyOK is false (or any value other than true), 
	//      the function will return false if s is empty.
	// If emptyOK is true, the function will return true if s is empty.
	//
	// EXAMPLE FUNCTION CALL:     RESULT:
	// isInteger ("5")            true 
	// isInteger ("")             defaultEmptyOK
	// isInteger ("-5")           false
	// isInteger ("", true)       true
	// isInteger ("", false)      false
	// isInteger ("5", false)     true

	function isInteger (s)

	{   var i;

		if (isEmpty(s)) 
		   if (isInteger.arguments.length == 1) return defaultEmptyOK;
		   else return (isInteger.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-numeric character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is number.
			var c = s.charAt(i);

			if (!isDigit(c)) return false;
		}

		// All characters are numbers.
		return true;
	}
	// isAlphanumeric (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is English letters 
	// (A .. Z, a..z) and numbers only.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isAlphanumeric (s)

	{   var i;

		if (isEmpty(s)) 
		   if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK;
		   else return (isAlphanumeric.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-alphanumeric character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is number or letter.
			var c = s.charAt(i);

			if (! (isLetter(c) || isDigit(c) ) )
			return false;
		}

		// All characters are numbers or letters.
		return true;
	}
	function isEmpty(s)
	{   return ((s == null) || (s.length == 0))
	}
	// Returns true if character c is a digit 
	// (0 .. 9).

	function isDigit (c)
	{   return ((c >= "0") && (c <= "9"))
	}
	// isAlphabetic (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is English letters 
	// (A .. Z, a..z) only.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isAlphabetic (s)

	{   var i;
		if (isEmpty(s)) 
		   if (isAlphabetic.arguments.length == 1) return defaultEmptyOK;
		   else return (isAlphabetic.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-alphabetic character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is letter.
			var c = s.charAt(i);

			if (!isLetter(c))
			return false;
		}

		// All characters are letters.
		return true;
	}
	// Returns true if character c is an English letter 
	// (A .. Z, a..z).
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isLetter (c)
	{   return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) )
	}
	function checkUID (theField, s, emptyOK)
	{
	  //check alphabetics
	  // isAlphabetic (s [,eok])             True if string s is English letters 
	  if (isAlphanumeric(theField.value, false) == false) {
		alert("Use only letters and numbers for 'Member ID'. Do not use blank spaces.");
		return false; }
	  else
		{	var number_flag = true;
			for (i = 0; i < theField.value.length; i++)
			{	// Check that current character is number or letter.
				var c = theField.value.charAt(i);
				if (! (isDigit(c)) )
					number_flag = false;
			}
			if (number_flag == true) {
				alert("Use letters and numbers for 'Member ID'.");
				return false; }
	  		return (checkString(theField, s, emptyOK));
	  	}
	}
	function checkString (theField, s, emptyOK)
	{   // Next line is needed on NN3 to avoid "undefined is not a number" error
		// in equality comparison below.
		if (checkString.arguments.length == 2) emptyOK = defaultEmptyOK;
		if ((emptyOK == true) && (isEmpty(theField.value))) return true;
		if (isWhitespace(theField.value)) 
		   return false;
		else return true;
	}
	// Returns true if string s is empty or 
	// whitespace characters only.

	function isWhitespace (s)

	{   var i;

		// Is s empty?
		if (isEmpty(s)) return true;

		// Search through string's characters one by one
		// until we find a non-whitespace character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character isn't whitespace.
			var c = s.charAt(i);

			if (whitespace.indexOf(c) == -1) return false;
		}

		// All characters are whitespace.
		return true;
	}
	// checkEmail (TEXTFIELD theField [, BOOLEAN emptyOK==false])
	//
	// Check that string theField.value is a valid Email.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function checkEmail (theField, emptyOK)
	{   if (checkEmail.arguments.length == 1) emptyOK = defaultEmptyOK;
		if ((emptyOK == true) && (isEmpty(theField.value))) return true;
		else if (!isEmail(theField.value, false)) {
			alert("Invalid Email format");
			return false;}
		else return true;
	}
	// isEmail (STRING s [, BOOLEAN emptyOK])
	// 
	// Email address must be of form a@b.c -- in other words:
	// * there must be at least one character before the @
	// * there must be at least one character before and after the .
	// * the characters @ and . are both required
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isEmail (s)
	{   if (isEmpty(s)) 
		   if (isEmail.arguments.length == 1) return defaultEmptyOK;
		   else return (isEmail.arguments[1] == true);
   
		// is s whitespace?
		if (isWhitespace(s)) return false;
    
		// there must be >= 1 character before @, so we
		// start looking at character position 1 
		// (i.e. second character)
		var i = 1;
		var sLength = s.length;

		// look for @
		while ((i < sLength) && (s.charAt(i) != "@"))
		{ i++;
		}

		if ((i >= sLength) || (s.charAt(i) != "@")) return false;
		else i += 2;

		// look for .
		while ((i < sLength) && (s.charAt(i) != "."))
		{ i++;
		}

		// there must be at least one character after the .
		if ((i >= sLength - 1) || (s.charAt(i) != ".")){
			return false;
		}
		else{
		// all characters must be a-z, A-Z, 0-9 or _ or - or % or @ or ! or .
			i=0;
			while (i<sLength){
				if  ( (s.charAt(i)>="0"&&s.charAt(i)<="9")
					||(s.charAt(i)>="A"&&s.charAt(i)<="Z")
					||(s.charAt(i)>="a"&&s.charAt(i)<="z")
					||s.charAt(i)=="_"
					||s.charAt(i)=="-"
					||s.charAt(i)=="%"
					||s.charAt(i)=="@"
					||s.charAt(i)=="!"
					||s.charAt(i)=="."
				){	
					i++;
				}
				else{
					return false;
				}
				
			}
			return true;
		}

	}
	function checkIDNo (theField, s, emptyOK, country, IDType)
	{
	 var NRIC_CHKD = "ABCDEFGHIZJ"
	 var start_no, ws_first_nric, Ilength, nric_sum, IDNo
	 
	 IDNo = theField.value;
	 IDNo=IDNo.toUpperCase();
	 country=country.toUpperCase();
	 IDType=IDType.toUpperCase();
	 theField.value = IDNo;

	 if ((country=="SG")&&(IDType=="N"))
	  {	    
	    Ilength = IDNo.length;
	    
	    if ((IDNo.charAt(0)!="S") && (IDNo.charAt(0)!="T") && !(isInteger(IDNo.charAt(0)))) {
			alert ("'NRIC' must begin with 'S', 'T' or a number.");
			return false;
		};

	    if (isInteger(IDNo.charAt(0)))
		{	IDNo = "S" + IDNo;
			theField.value = IDNo;
			Ilength = IDNo.length;
		}

		if ((IDNo.charAt(Ilength-1)!="A") &&
			(IDNo.charAt(Ilength-1)!="B")&&
			(IDNo.charAt(Ilength-1)!="C") &&
			(IDNo.charAt(Ilength-1)!="D") &&
			(IDNo.charAt(Ilength-1)!="E") &&
			(IDNo.charAt(Ilength-1)!="F") &&
			(IDNo.charAt(Ilength-1)!="G") &&
			(IDNo.charAt(Ilength-1)!="H") &&
			(IDNo.charAt(Ilength-1)!="I") &&
			(IDNo.charAt(Ilength-1)!="Z") &&
			(IDNo.charAt(Ilength-1)!="J")) {
			alert("'NRIC' must end with NRIC reference 'A', 'B', 'C', 'D', 'E', 'F', G', 'H', 'I', 'J' or 'Z'");
			return false; }
		
		if ((!(isInteger(IDNo.charAt(0))) && (IDNo.length!=9)) ||
			((isInteger(IDNo.charAt(0))) && (IDNo.length!=8)) ||
			 (!(isInteger(IDNo.substring(1,Ilength-2))))) {
			alert("An invalid 'NRIC' was entered. 'NRIC' must begin with 'S', 'T' or a number, and end with NRIC reference 'A', 'B', 'C', 'D','E', 'F', 'G', 'H', 'I', 'J', or 'Z'");
			return false; }
		
		if (isInteger(IDNo.charAt(0)))
			{	start_no = 0;
				ws_first_nric = "S" ;	}
		else
			{	start_no = 1;
				ws_first_nric = IDNo.charAt(0);	}
				
		nric_sum = IDNo.charAt(start_no) * 2 + 
				   IDNo.charAt(start_no + 1) * 7 +
				   IDNo.charAt(start_no + 2) * 6 +
				   IDNo.charAt(start_no + 3) * 5 +
				   IDNo.charAt(start_no + 4) * 4 +
				   IDNo.charAt(start_no + 5) * 3 +
				   IDNo.charAt(start_no + 6) * 2;

		if (ws_first_nric == "T")
			nric_sum = nric_sum + 4;

		nric_sum = nric_sum % 11;
		nric_sum = 11 - nric_sum;

		if (IDNo.charAt(Ilength-1)!=NRIC_CHKD.charAt(nric_sum-1)) {
			alert("An invalid 'NRIC' was entered. 'NRIC' must begin with 'S', 'T' or a number, and end with NRIC reference 'A', 'B', 'C', 'D','E', 'F', 'G', 'H', 'I', 'J', or 'Z'");
			return false; }
		
		return true;
		}
	return true
	}
	
function commitForm(userForm,status)
{
//  To Trim the Leading spaces 
		///TrimSpace(userForm.elements["cn"]);
		///TrimSpace(userForm.elements["st"]);
		//TrimSpace(userForm.elements["age"]);
		TrimSpace(userForm.elements["telephoneNumber"]);
		TrimSpace(userForm.elements["givenName"]);
		////TrimSpace(userForm.elements["IDNo"]);
		TrimSpace(userForm.elements["street"]);
		TrimSpace(userForm.elements["postalCode"]);
		////TrimSpace(userForm.elements["handphone"]);
		////TrimSpace(userForm.elements["l"]);
		////upddte(userForm);
		
//*** Change S/N: 1
		//userForm.elements["userPassword"].value=stripWhitespace (userForm.elements["userPassword"].value);
		//userForm.elements["userPasswordVerify"].value=stripWhitespace (userForm.elements["userPasswordVerify"].value);
		//if (!isSame(userForm.elements["userPassword"].value, userForm.elements["userPasswordVerify"].value))
		//		warnInvalid(userForm.elements["userPassword"], "Passwords are not identical.");
		//else
		//{
		if (
		//checkLength(userForm.elements["cn"], "Enter 3 to 14 characters for 'Member ID'.", 3, 14) &&
			//checkUID(userForm.elements["cn"], sUserID, false) && 
			//checkLength(userForm.elements["userPassword"], "Enter 6 to 14 characters for 'password'.", 6, 14)&&
			//checkString(userForm.elements["userPassword"], sPassword, false) &&
			//checkString(userForm.elements["userPasswordVerify"], sVPassword, false) && 
			checkSName(userForm.elements["surname"]) && 
			checkGName(userForm.elements["givenName"]) && 
			//checkIDTypeLength(userForm.elements["IDType"].options[userForm.elements["IDType"].selectedIndex].value,userForm.elements["IDNo"]) &&
			//checkIDNo(userForm.elements["IDNo"], sIDNo, false, userForm.elements["c"].options[userForm.elements["c"].selectedIndex].value, userForm.elements["IDType"].options[userForm.elements["IDType"].selectedIndex].value) &&
			checkstreet(userForm.elements["street"]) && 
			//checkSState(userForm.elements["st"]) && 
			checkSZip(userForm.elements["postalCode"]) && 
			checkEmail(userForm.elements["mail"], false) && 
			chkemtyphone(userForm.elements["telephoneNumber"]) &&
			checkDigit(userForm.elements["telephoneNumber"],userForm.elements["c"]) 
			//&&		  
			//checkDate(userForm.elements["bdate"])
			)
 				{var beIE = document.all?true:false

					if (beIE){
						userForm.elements["buttonsub"].disabled=true;
						//** removed due to access denied error for IE >5 openFrameless();
					}
						alert('Submitting your request, Please click on \'OK \' and wait for the acknowledgement\!');
						userForm.submit();
				}
	  }
	  //}
	
	
	
	
	/////////////////////////////// functions /////////////////////////////////
	
		//KCWU version
	// VARIABLE DECLARATIONS

	var digits = "0123456789";

	var lowercaseLetters = "abcdefghijklmnopqrstuvwxyz"

	var uppercaseLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"


	// decimal point character differs by language and culture
	var decimalPointDelimiter = "."


	// non-digit characters which are allowed in phone numbers
	var phoneNumberDelimiters = "()- ";


	// non-digit characters which are allowed in 
	// Social Security Numbers
	var SSNDelimiters = "- ";



	// characters which are allowed in Social Security Numbers
	var validSSNChars = digits + SSNDelimiters;

	// U.S. Social Security Numbers have 9 digits.
	// They are formatted as 123-45-6789.
	var digitsInSocialSecurityNumber = 9;



	// U.S. phone numbers have 10 digits.
	// They are formatted as 123 456 7890 or (123) 456-7890.
	var digitsInUSPhoneNumber = 10;



	// non-digit characters which are allowed in ZIP Codes
	var ZIPCodeDelimiters = "-";



	// our preferred delimiter for reformatting ZIP Codes
	var ZIPCodeDelimeter = "-"


	// characters which are allowed in Social Security Numbers
	var validZIPCodeChars = digits + ZIPCodeDelimiters



	// U.S. ZIP codes have 5 or 9 digits.
	// They are formatted as 12345 or 12345-6789.
	var digitsInZIPCode1 = 5
	var digitsInZIPCode2 = 9


	// non-digit characters which are allowed in credit card numbers
	var creditCardDelimiters = " "


	// CONSTANT STRING DECLARATIONS
	// (grouped for ease of translation and localization)

	// m is an abbreviation for "missing"

	var mPrefix = "You did not enter a value into the "
	var mSuffix = " field. This is a required field. Please enter it now."

	// s is an abbreviation for "string"

	var sUSLastName = "Last Name"
	var sUSFirstName = "First Name"
	var sWorldLastName = "Family Name"
	var sWorldFirstName = "Given Name"
	var sTitle = "Title"
	var sCompanyName = "Company Name"
	var sUSAddress = "Street Address"
	var sWorldAddress = "Address"
	var sCity = "City"
	var sStateCode = "State Code"
	var sWorldState = "State, Province, or Prefecture"
	var sCountry = "Country"
	var sZIPCode = "ZIP Code"
	var sWorldPostalCode = "Postal Code"
	var sPhone = "Phone Number"
	var sFax = "Fax Number"
	var sDateOfBirth = "Date of Birth"
	var sExpirationDate = "Expiration Date"
	var sEmail = "Email"
	var sSSN = "Social Security Number"
	var sCreditCardNumber = "Credit Card Number"
	var sOtherInfo = "Other Information"
	var sUserID = "Member ID"
	var sPassword = "Password"
	var sVPassword = "Verify Password"
	var sIDNo = "ID Number"


	// i is an abbreviation for "invalid"

	var iStateCode = "This field must be a valid two character U.S. state abbreviation (like CA for California). Please reenter it now."
	var iZIPCode = "This field must be a 5 or 9 digit U.S. ZIP Code (like 94043). Please reenter it now."
	var iUSPhone = "This field must be a 10 digit U.S. phone number (like 415 555 1212). Please reenter it now."
	var iWorldPhone = "This field must be a valid international phone number. Please reenter it now."
	var iSSN = "This field must be a 9 digit U.S. social security number (like 123 45 6789). Please reenter it now."
	var iEmail = "Enter a valid email address e.g. name@company.com."
	var iCreditCardPrefix = "This is not a valid "
	var iCreditCardSuffix = " credit card number. (Click the link on this form to see a list of sample numbers.) Please reenter it now."
	var iDay = "'Day' must be entered. 'Day' cannot be left blank."
	var iMonth = "'Month' must be entered. 'Month' cannot be left blank."
	var iYear = "'Year' must be entered. 'Year' cannot be left blank."
	var iDatePrefix = "The Day, Month, and Year for "
	var iDateSuffix = " is not a valid date.  Please re-enter."
	var ibdate = "Date field must be more than 1800.  Please re-enter it now."


	// p is an abbreviation for "prompt"

	var pEntryPrompt = "Please enter a "
	var pStateCode = "2 character code (like CA)."
	var pZIPCode = "5 or 9 digit U.S. ZIP Code (like 94043)."
	var pUSPhone = "10 digit U.S. phone number (like 415 555 1212)."
	var pWorldPhone = "international phone number."
	var pSSN = "9 digit U.S. social security number (like 123 45 6789)."
	var pEmail = "valid email address (like name@company.com)."
	var pCreditCard = "valid credit card number."
	var pDay = "day number between 1 and 31."
	var pMonth = "month number between 1 and 12."
	var pYear = "2 or 4 digit year number."


	// Global variable defaultEmptyOK defines default return value 
	// for many functions when they are passed the empty string. 
	// By default, they will return defaultEmptyOK.
	//
	// defaultEmptyOK is false, which means that by default, 
	// these functions will do "strict" validation.  Function
	// isInteger, for example, will only return true if it is
	// passed a string containing an integer; if it is passed
	// the empty string, it will return false.
	//
	// You can change this default behavior globally (for all 
	// functions which use defaultEmptyOK) by changing the value
	// of defaultEmptyOK.
	//
	// Most of these functions have an optional argument emptyOK
	// which allows you to override the default behavior for 
	// the duration of a function call.
	//
	// This functionality is useful because it is possible to
	// say "if the user puts anything in this field, it must
	// be an integer (or a phone number, or a string, etc.), 
	// but it's OK to leave the field empty too."
	// This is the case for fields which are optional but which
	// must have a certain kind of content if filled in.

	var defaultEmptyOK = false




	// Attempting to make this library run on Navigator 2.0,
	// so I'm supplying this array creation routine as per
	// JavaScript 1.0 documentation.  If you're using 
	// Navigator 3.0 or later, you don't need to do this;
	// you can use the Array constructor instead.

	function makeArray(n) {
	//*** BUG: If I put this line in, I get two error messages:
	//(1) Window.length can't be set by assignment
	//(2) daysInMonth has no property indexed by 4
	//If I leave it out, the code works fine.
	//   this.length = n;
	   for (var i = 1; i <= n; i++) {
		  this[i] = 0
	   } 
	   return this
	}



	var daysInMonth = makeArray(12);
	daysInMonth[1] = 31;
	daysInMonth[2] = 29;   // must programmatically check this
	daysInMonth[3] = 31;
	daysInMonth[4] = 30;
	daysInMonth[5] = 31;
	daysInMonth[6] = 30;
	daysInMonth[7] = 31;
	daysInMonth[8] = 31;
	daysInMonth[9] = 30;
	daysInMonth[10] = 31;
	daysInMonth[11] = 30;
	daysInMonth[12] = 31;




	// Valid U.S. Postal Codes for states, territories, armed forces, etc.
	// See http://www.usps.gov/ncsc/lookups/abbr_state.txt.

	var USStateCodeDelimiter = "|";
	var USStateCodes = "AL|AK|AS|AZ|AR|CA|CO|CT|DE|DC|FM|FL|GA|GU|HI|ID|IL|IN|IA|KS|KY|LA|ME|MH|MD|MA|MI|MN|MS|MO|MT|NE|NV|NH|NJ|NM|NY|NC|ND|MP|OH|OK|OR|PW|PA|PR|RI|SC|SD|TN|TX|UT|VT|VI|VA|WA|WV|WI|WY|AE|AA|AE|AE|AP"




	// Check whether string s is empty.

	function isEmpty(s)
	{   return ((s == null) || (s.length == 0))
	}



	// Returns true if string s is empty or 
	// whitespace characters only.

	function isWhitespace (s)

	{   var i;

		// Is s empty?
		if (isEmpty(s)) return true;

		// Search through string's characters one by one
		// until we find a non-whitespace character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character isn't whitespace.
			var c = s.charAt(i);

			if (whitespace.indexOf(c) == -1) return false;
		}

		// All characters are whitespace.
		return true;
	}



	// Removes all characters which appear in string bag from string s.

	function stripCharsInBag (s, bag)

	{   var i;
		var returnString = "";

		// Search through string's characters one by one.
		// If character is not in bag, append to returnString.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character isn't whitespace.
			var c = s.charAt(i);
			if (bag.indexOf(c) == -1) returnString += c;
		}

		return returnString;
	}



	// Removes all characters which do NOT appear in string bag 
	// from string s.

	function stripCharsNotInBag (s, bag)

	{   var i;
		var returnString = "";

		// Search through string's characters one by one.
		// If character is in bag, append to returnString.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character isn't whitespace.
			var c = s.charAt(i);
			if (bag.indexOf(c) != -1) returnString += c;
		}

		return returnString;
	}



	// Removes all whitespace characters from s.
	// Global variable whitespace (see above)
	// defines which characters are considered whitespace.

	function stripWhitespace (s)

	{   return stripCharsInBag (s, whitespace)
	}




	// WORKAROUND FUNCTION FOR NAVIGATOR 2.0.2 COMPATIBILITY.
	//
	// The below function *should* be unnecessary.  In general,
	// avoid using it.  Use the standard method indexOf instead.
	//
	// However, because of an apparent bug in indexOf on 
	// Navigator 2.0.2, the below loop does not work as the
	// body of stripInitialWhitespace:
	//
	// while ((i < s.length) && (whitespace.indexOf(s.charAt(i)) != -1))
	//   i++;
	//
	// ... so we provide this workaround function charInString
	// instead.
	//
	// charInString (CHARACTER c, STRING s)
	//
	// Returns true if single character c (actually a string)
	// is contained within string s.

	function charInString (c, s)
	{   for (i = 0; i < s.length; i++)
		{   if (s.charAt(i) == c) return true;
		}
		return false
	}



	// Removes initial (leading) whitespace characters from s.
	// Global variable whitespace (see above)
	// defines which characters are considered whitespace.

	function stripInitialWhitespace (s)

	{   var i = 0;

		while ((i < s.length) && charInString (s.charAt(i), whitespace))
		   i++;
    
		return s.substring (i, s.length);
	}







	// Returns true if character c is an English letter 
	// (A .. Z, a..z).
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isLetter (c)
	{   return ( ((c >= "a") && (c <= "z")) || ((c >= "A") && (c <= "Z")) )
	}



	// Returns true if character c is a digit 
	// (0 .. 9).

	function isDigit (c)
	{   return ((c >= "0") && (c <= "9"))
	}



	// Returns true if character c is a letter or digit.

	function isLetterOrDigit (c)
	{   return (isLetter(c) || isDigit(c))
	}



	// isInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if all characters in string s are numbers.
	//
	// Accepts non-signed integers only. Does not accept floating 
	// point, exponential notation, etc.
	//
	// We don't use parseInt because that would accept a string
	// with trailing non-numeric characters.
	//
	// By default, returns defaultEmptyOK if s is empty.
	// There is an optional second argument called emptyOK.
	// emptyOK is used to override for a single function call
	//      the default behavior which is specified globally by
	//      defaultEmptyOK.
	// If emptyOK is false (or any value other than true), 
	//      the function will return false if s is empty.
	// If emptyOK is true, the function will return true if s is empty.
	//
	// EXAMPLE FUNCTION CALL:     RESULT:
	// isInteger ("5")            true 
	// isInteger ("")             defaultEmptyOK
	// isInteger ("-5")           false
	// isInteger ("", true)       true
	// isInteger ("", false)      false
	// isInteger ("5", false)     true

	function isInteger (s)

	{   var i;

		if (isEmpty(s)) 
		   if (isInteger.arguments.length == 1) return defaultEmptyOK;
		   else return (isInteger.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-numeric character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is number.
			var c = s.charAt(i);

			if (!isDigit(c)) return false;
		}

		// All characters are numbers.
		return true;
	}







	// isSignedInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if all characters are numbers; 
	// first character is allowed to be + or - as well.
	//
	// Does not accept floating point, exponential notation, etc.
	//
	// We don't use parseInt because that would accept a string
	// with trailing non-numeric characters.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	//
	// EXAMPLE FUNCTION CALL:          RESULT:
	// isSignedInteger ("5")           true 
	// isSignedInteger ("")            defaultEmptyOK
	// isSignedInteger ("-5")          true
	// isSignedInteger ("+5")          true
	// isSignedInteger ("", false)     false
	// isSignedInteger ("", true)      true

	function isSignedInteger (s)

	{   if (isEmpty(s)) 
		   if (isSignedInteger.arguments.length == 1) return defaultEmptyOK;
		   else return (isSignedInteger.arguments[1] == true);

		else {
			var startPos = 0;
			var secondArg = defaultEmptyOK;

			if (isSignedInteger.arguments.length > 1)
				secondArg = isSignedInteger.arguments[1];

			// skip leading + or -
			if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
			   startPos = 1;    
			return (isInteger(s.substring(startPos, s.length), secondArg))
		}
	}




	// isPositiveInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is an integer > 0.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isPositiveInteger (s)
	{   var secondArg = defaultEmptyOK;

		if (isPositiveInteger.arguments.length > 1)
			secondArg = isPositiveInteger.arguments[1];

		// The next line is a bit byzantine.  What it means is:
		// a) s must be a signed integer, AND
		// b) one of the following must be true:
		//    i)  s is empty and we are supposed to return true for
		//        empty strings
		//    ii) this is a positive, not negative, number

		return (isSignedInteger(s, secondArg)
			 && ( (isEmpty(s) && secondArg)  || (parseInt (s) > 0) ) );
	}






	// isNonnegativeInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is an integer >= 0.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isNonnegativeInteger (s)
	{   var secondArg = defaultEmptyOK;

		if (isNonnegativeInteger.arguments.length > 1)
			secondArg = isNonnegativeInteger.arguments[1];

		// The next line is a bit byzantine.  What it means is:
		// a) s must be a signed integer, AND
		// b) one of the following must be true:
		//    i)  s is empty and we are supposed to return true for
		//        empty strings
		//    ii) this is a number >= 0

		return (isSignedInteger(s, secondArg)
			 && ( (isEmpty(s) && secondArg)  || (parseInt (s) >= 0) ) );
	}






	// isNegativeInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is an integer < 0.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isNegativeInteger (s)
	{   var secondArg = defaultEmptyOK;

		if (isNegativeInteger.arguments.length > 1)
			secondArg = isNegativeInteger.arguments[1];

		// The next line is a bit byzantine.  What it means is:
		// a) s must be a signed integer, AND
		// b) one of the following must be true:
		//    i)  s is empty and we are supposed to return true for
		//        empty strings
		//    ii) this is a negative, not positive, number

		return (isSignedInteger(s, secondArg)
			 && ( (isEmpty(s) && secondArg)  || (parseInt (s) < 0) ) );
	}






	// isNonpositiveInteger (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is an integer <= 0.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isNonpositiveInteger (s)
	{   var secondArg = defaultEmptyOK;

		if (isNonpositiveInteger.arguments.length > 1)
			secondArg = isNonpositiveInteger.arguments[1];

		// The next line is a bit byzantine.  What it means is:
		// a) s must be a signed integer, AND
		// b) one of the following must be true:
		//    i)  s is empty and we are supposed to return true for
		//        empty strings
		//    ii) this is a number <= 0

		return (isSignedInteger(s, secondArg)
			 && ( (isEmpty(s) && secondArg)  || (parseInt (s) <= 0) ) );
	}





	// isFloat (STRING s [, BOOLEAN emptyOK])
	// 
	// True if string s is an unsigned floating point (real) number. 
	//
	// Also returns true for unsigned integers. If you wish
	// to distinguish between integers and floating point numbers,
	// first call isInteger, then call isFloat.
	//
	// Does not accept exponential notation.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isFloat (s)

	{   var i;
		var seenDecimalPoint = false;

		if (isEmpty(s)) 
		   if (isFloat.arguments.length == 1) return defaultEmptyOK;
		   else return (isFloat.arguments[1] == true);

		if (s == decimalPointDelimiter) return false;

		// Search through string's characters one by one
		// until we find a non-numeric character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is number.
			var c = s.charAt(i);

			if ((c == decimalPointDelimiter) && !seenDecimalPoint) seenDecimalPoint = true;
			else if (!isDigit(c)) return false;
		}

		// All characters are numbers.
		return true;
	}







	// isSignedFloat (STRING s [, BOOLEAN emptyOK])
	// 
	// True if string s is a signed or unsigned floating point 
	// (real) number. First character is allowed to be + or -.
	//
	// Also returns true for unsigned integers. If you wish
	// to distinguish between integers and floating point numbers,
	// first call isSignedInteger, then call isSignedFloat.
	//
	// Does not accept exponential notation.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isSignedFloat (s)

	{   if (isEmpty(s)) 
		   if (isSignedFloat.arguments.length == 1) return defaultEmptyOK;
		   else return (isSignedFloat.arguments[1] == true);

		else {
			var startPos = 0;
			var secondArg = defaultEmptyOK;

			if (isSignedFloat.arguments.length > 1)
				secondArg = isSignedFloat.arguments[1];

			// skip leading + or -
			if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
			   startPos = 1;    
			return (isFloat(s.substring(startPos, s.length), secondArg))
		}
	}




	// isAlphabetic (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is English letters 
	// (A .. Z, a..z) only.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isAlphabetic (s)

	{   var i;
		if (isEmpty(s)) 
		   if (isAlphabetic.arguments.length == 1) return defaultEmptyOK;
		   else return (isAlphabetic.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-alphabetic character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is letter.
			var c = s.charAt(i);

			if (!isLetter(c))
			return false;
		}

		// All characters are letters.
		return true;
	}




	// isAlphanumeric (STRING s [, BOOLEAN emptyOK])
	// 
	// Returns true if string s is English letters 
	// (A .. Z, a..z) and numbers only.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	//
	// NOTE: Need i18n version to support European characters.
	// This could be tricky due to different character
	// sets and orderings for various languages and platforms.

	function isAlphanumeric (s)

	{   var i;

		if (isEmpty(s)) 
		   if (isAlphanumeric.arguments.length == 1) return defaultEmptyOK;
		   else return (isAlphanumeric.arguments[1] == true);

		// Search through string's characters one by one
		// until we find a non-alphanumeric character.
		// When we do, return false; if we don't, return true.

		for (i = 0; i < s.length; i++)
		{   
			// Check that current character is number or letter.
			var c = s.charAt(i);

			if (! (isLetter(c) || isDigit(c) ) )
			return false;
		}

		// All characters are numbers or letters.
		return true;
	}




	// reformat (TARGETSTRING, STRING, INTEGER, STRING, INTEGER ... )       
	//
	// Handy function for arbitrarily inserting formatting characters
	// or delimiters of various kinds within TARGETSTRING.
	//
	// reformat takes one named argument, a string s, and any number
	// of other arguments.  The other arguments must be integers or
	// strings.  These other arguments specify how string s is to be
	// reformatted and how and where other strings are to be inserted
	// into it.
	//
	// reformat processes the other arguments in order one by one.
	// * If the argument is an integer, reformat appends that number 
	//   of sequential characters from s to the resultString.
	// * If the argument is a string, reformat appends the string
	//   to the resultString.
	//
	// NOTE: The first argument after TARGETSTRING must be a string.
	// (It can be empty.)  The second argument must be an integer.
	// Thereafter, integers and strings must alternate.  This is to
	// provide backward compatibility to Navigator 2.0.2 JavaScript
	// by avoiding use of the typeof operator.
	//
	// It is the caller's responsibility to make sure that we do not
	// try to copy more characters from s than s.length.
	//
	// EXAMPLES:
	//
	// * To reformat a 10-digit U.S. phone number from "1234567890"
	//   to "(123) 456-7890" make this function call:
	//   reformat("1234567890", "(", 3, ") ", 3, "-", 4)
	//
	// * To reformat a 9-digit U.S. Social Security number from
	//   "123456789" to "123-45-6789" make this function call:
	//   reformat("123456789", "", 3, "-", 2, "-", 4)
	//
	// HINT:
	//
	// If you have a string which is already delimited in one way
	// (example: a phone number delimited with spaces as "123 456 7890")
	// and you want to delimit it in another way using function reformat,
	// call function stripCharsNotInBag to remove the unwanted 
	// characters, THEN call function reformat to delimit as desired.
	//
	// EXAMPLE:
	//
	// reformat (stripCharsNotInBag ("123 456 7890", digits),
	//           "(", 3, ") ", 3, "-", 4)

	function reformat (s)

	{   var arg;
		var sPos = 0;
		var resultString = "";

		for (var i = 1; i < reformat.arguments.length; i++) {
		   arg = reformat.arguments[i];
		   if (i % 2 == 1) resultString += arg;
		   else {
			   resultString += s.substring(sPos, sPos + arg);
			   sPos += arg;
		   }
		}
		return resultString;
	}




	// isSSN (STRING s [, BOOLEAN emptyOK])
	// 
	// isSSN returns true if string s is a valid U.S. Social
	// Security Number.  Must be 9 digits.
	//
	// NOTE: Strip out any delimiters (spaces, hyphens, etc.)
	// from string s before calling this function.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isSSN (s)
	{   if (isEmpty(s)) 
		   if (isSSN.arguments.length == 1) return defaultEmptyOK;
		   else return (isSSN.arguments[1] == true);
		return (isInteger(s) && s.length == digitsInSocialSecurityNumber)
	}




	// isUSPhoneNumber (STRING s [, BOOLEAN emptyOK])
	// 
	// isUSPhoneNumber returns true if string s is a valid U.S. Phone
	// Number.  Must be 10 digits.
	//
	// NOTE: Strip out any delimiters (spaces, hyphens, parentheses, etc.)
	// from string s before calling this function.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isUSPhoneNumber (s)
	{   if (isEmpty(s)) 
		   if (isUSPhoneNumber.arguments.length == 1) return defaultEmptyOK;
		   else return (isUSPhoneNumber.arguments[1] == true);
		return (isInteger(s) && s.length == digitsInUSPhoneNumber)
	}




	// isInternationalPhoneNumber (STRING s [, BOOLEAN emptyOK])
	// 
	// isInternationalPhoneNumber returns true if string s is a valid 
	// international phone number.  Must be digits only; any length OK.
	// May be prefixed by + character.
	//
	// NOTE: A phone number of all zeros would not be accepted.
	// I don't think that is a valid phone number anyway.
	//
	// NOTE: Strip out any delimiters (spaces, hyphens, parentheses, etc.)
	// from string s before calling this function.  You may leave in 
	// leading + character if you wish.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isInternationalPhoneNumber (s)
	{   if (isEmpty(s)) 
		   if (isInternationalPhoneNumber.arguments.length == 1) return defaultEmptyOK;
		   else return (isInternationalPhoneNumber.arguments[1] == true);
		return (isPositiveInteger(s))
	}




	// isZIPCode (STRING s [, BOOLEAN emptyOK])
	// 
	// isZIPCode returns true if string s is a valid 
	// U.S. ZIP code.  Must be 5 or 9 digits only.
	//
	// NOTE: Strip out any delimiters (spaces, hyphens, etc.)
	// from string s before calling this function.  
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isZIPCode (s)
	{  if (isEmpty(s)) 
		   if (isZIPCode.arguments.length == 1) return defaultEmptyOK;
		   else return (isZIPCode.arguments[1] == true);
	   return (isInteger(s) && 
				((s.length == digitsInZIPCode1) ||
				 (s.length == digitsInZIPCode2)))
	}





	// isStateCode (STRING s [, BOOLEAN emptyOK])
	// 
	// Return true if s is a valid U.S. Postal Code 
	// (abbreviation for state).
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isStateCode(s)
	{   if (isEmpty(s)) 
		   if (isStateCode.arguments.length == 1) return defaultEmptyOK;
		   else return (isStateCode.arguments[1] == true);
		return ( (USStateCodes.indexOf(s) != -1) &&
				 (s.indexOf(USStateCodeDelimiter) == -1) )
	}
	// isEmail (STRING s [, BOOLEAN emptyOK])
	// 
	// Email address must be of form a@b.c -- in other words:
	// * there must be at least one character before the @
	// * there must be at least one character before and after the .
	// * the characters @ and . are both required
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isEmail (s)
	{   if (isEmpty(s)) 
		   if (isEmail.arguments.length == 1) return defaultEmptyOK;
		   else return (isEmail.arguments[1] == true);
   
		// is s whitespace?
		if (isWhitespace(s)) return false;
    
		// there must be >= 1 character before @, so we
		// start looking at character position 1 
		// (i.e. second character)
		var i = 1;
		var sLength = s.length;

		// look for @
		while ((i < sLength) && (s.charAt(i) != "@"))
		{ i++;
		}

		if ((i >= sLength) || (s.charAt(i) != "@")) return false;
		else i += 2;

		// look for .
		while ((i < sLength) && (s.charAt(i) != "."))
		{ i++;
		}

		// there must be at least one character after the .
		if ((i >= sLength - 1) || (s.charAt(i) != ".")){
			return false;
		}
		else{
		// all characters must be a-z, A-Z, 0-9 or _ or - or % or @ or ! or .
			i=0;
			while (i<sLength){
				if  ( (s.charAt(i)>="0"&&s.charAt(i)<="9")
					||(s.charAt(i)>="A"&&s.charAt(i)<="Z")
					||(s.charAt(i)>="a"&&s.charAt(i)<="z")
					||s.charAt(i)=="_"
					||s.charAt(i)=="-"
					||s.charAt(i)=="%"
					||s.charAt(i)=="@"
					||s.charAt(i)=="!"
					||s.charAt(i)=="/"
					||s.charAt(i)=="."
				){	
					i++;
				}
				else{
					return false;
				}
				
			}
			return true;
		}

	}

	// isYear (STRING s [, BOOLEAN emptyOK])
	// 
	// isYear returns true if string s is a valid 
	// Year number.  Must be 2 or 4 digits only.
	// 
	// For Year 2000 compliance, you are advised
	// to use 4-digit year numbers everywhere.
	//
	// And yes, this function is not Year 10000 compliant, but 
	// because I am giving you 8003 years of advance notice,
	// I don't feel very guilty about this ...
	//
	// For B.C. compliance, write your own function. ;->
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isYear (s)
	{   if (isEmpty(s)) 
		   if (isYear.arguments.length == 1) return defaultEmptyOK;
		   else return (isYear.arguments[1] == true);
		if (!isNonnegativeInteger(s)) return false;
		return ((s.length == 2) || (s.length == 4));
	}



	// isIntegerInRange (STRING s, INTEGER a, INTEGER b [, BOOLEAN emptyOK])
	// 
	// isIntegerInRange returns true if string s is an integer 
	// within the range of integer arguments a and b, inclusive.
	// 
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.


	function isIntegerInRange (s, a, b)
	{   if (isEmpty(s)) 
		   if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK;
		   else return (isIntegerInRange.arguments[1] == true);

		// Catch non-integer strings to avoid creating a NaN below,
		// which isn't available on JavaScript 1.0 for Windows.
		if (!isInteger(s, false)) return false;

		// Now, explicitly change the type to integer via parseInt
		// so that the comparison code below will work both on 
		// JavaScript 1.2 (which typechecks in equality comparisons)
		// and JavaScript 1.1 and before (which doesn't).
		if (s == "08") s = "8";
		if (s == "09") s = "9";
		var num = parseInt (s);
		return ((num >= a) && (num <= b));
	}



	// isMonth (STRING s [, BOOLEAN emptyOK])
	// 
	// isMonth returns true if string s is a valid 
	// month number between 1 and 12.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isMonth (s)
	{   if (isEmpty(s)) 
		   if (isMonth.arguments.length == 1) return defaultEmptyOK;
		   else return (isMonth.arguments[1] == true);
		return isIntegerInRange (s, 1, 12);
	}



	// isDay (STRING s [, BOOLEAN emptyOK])
	// 
	// isDay returns true if string s is a valid 
	// day number between 1 and 31.
	// 
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function isDay (s)
	{   if (isEmpty(s)) 
		   if (isDay.arguments.length == 1) return defaultEmptyOK;
		   else return (isDay.arguments[1] == true);   
		return isIntegerInRange (s, 1, 31);
	}



	// daysInFebruary (INTEGER year)
	// 
	// Given integer argument year,
	// returns number of days in February of that year.

	function daysInFebruary (year)
	{   // February has 29 days in any year evenly divisible by four,
		// EXCEPT for centurial years which are not also divisible by 400.
		return (  ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
	}



	// isDate (STRING year, STRING month, STRING day)
	//
	// isDate returns true if string arguments year, month, and day 
	// form a valid date.
	// 

	function isDate (year, month, day)
	{   // catch invalid years (not 2- or 4-digit) and invalid months and days.
		if (! (isYear(year, false) && isMonth(month, false) && isDay(day, false))) return false;

		// Explicitly change type to integer to make code work in both
		// JavaScript 1.1 and JavaScript 1.2.
		var intYear = parseInt(year);
		var intMonth = parseInt(month);
		var intDay = parseInt(day);

		// catch invalid days, except for February
		if (intDay > daysInMonth[intMonth]) return false; 

		if ((intMonth == 2) && (intDay > daysInFebruary(intYear))) return false;

		return true;
	}




	/* FUNCTIONS TO NOTIFY USER OF INPUT REQUIREMENTS OR MISTAKES. */


	// Display prompt string s in status bar.

	function prompt (s)
	{   window.status = s
	}



	// Display data entry prompt string s in status bar.

	function promptEntry (s)
	{   window.status = pEntryPrompt + s
	}




	// Notify user that required field theField is empty.
	// String s describes expected contents of theField.value.
	// Put focus in theField and return false.

	function warnEmpty (theField, s)
	{   theField.focus()
		alert(mPrefix + s + mSuffix)
		return false
	}



	// Notify user that contents of field theField are invalid.
	// String s describes expected contents of theField.value.
	// Put select theField, pu focus in it, and return false.

	function warnInvalid (theField, s)
	{ 
	  theField.focus()
      theField.select()
	  alert(s)
  	  return false
	}




	/* FUNCTIONS TO INTERACTIVELY CHECK VARIOUS FIELDS. */

	// checkString (TEXTFIELD theField, STRING s, [, BOOLEAN emptyOK==false])
	//
	// Check that string theField.value is not all whitespace.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.
	
	function checkPMP(theField1)
	{
		if((isEmpty(theField1.value)))
		{
	 	  theField1.focus()
 		  alert("Either Telephone number");
		  return false;
		}
		else
			return true;
		 
	}
	function checkString (theField, s, emptyOK)
	{   // Next line is needed on NN3 to avoid "undefined is not a number" error
		// in equality comparison below.
		if (checkString.arguments.length == 2) emptyOK = defaultEmptyOK;
		if ((emptyOK == true) && (isEmpty(theField.value))) return true;
		if (isWhitespace(theField.value)) 
		   return warnEmpty (theField, s);
		else return true;
	}

	function checkUID (theField, s, emptyOK)
	{
	  //check alphabetics
	  // isAlphabetic (s [,eok])             True if string s is English letters 
	  if (isAlphanumeric(theField.value, false) == false)
		return (warnInvalid(theField, "Use only (first 3) letters and numbers for 'Member ID'. Do not use blank spaces."));
	  else
		{	var number_flag = true;
			for (i = 0; i < theField.value.length; i++)
			{	// Check that current character is number or letter.
				var c = theField.value.charAt(i);
				if (! (isDigit(c)) )
					number_flag = false;
			}
			if (number_flag == true)
				return (warnInvalid(theField, "Use (first 3) only letters and numbers for 'Member ID'."));
	  		return (checkString(theField, s, emptyOK));
	  	}
	}

	function checkIDNo (theField, s, emptyOK, country, IDType)
	{
	 var NRIC_CHKD = "ABCDEFGHIZJ"
	 var start_no, ws_first_nric, Ilength, nric_sum, IDNo
	 
	 IDNo = theField.value;
	 IDNo=IDNo.toUpperCase();
	 country=country.toUpperCase();
	 IDType=IDType.toUpperCase();
	 theField.value = IDNo;

	 if ((country=="SG")&&(IDType=="N"))
	  {	    
	    Ilength = IDNo.length;
	    
	    if ((IDNo.charAt(0)!="S") && (IDNo.charAt(0)!="T") && !(isInteger(IDNo.charAt(0))))
			return (warnInvalid(theField, "'NRIC' must begin with 'S', 'T' or a number."));

	    if (isInteger(IDNo.charAt(0)))
		{	IDNo = "S" + IDNo;
			theField.value = IDNo;
			Ilength = IDNo.length;
		}

		if ((IDNo.charAt(Ilength-1)!="A") &&
			(IDNo.charAt(Ilength-1)!="B")&&
			(IDNo.charAt(Ilength-1)!="C") &&
			(IDNo.charAt(Ilength-1)!="D") &&
			(IDNo.charAt(Ilength-1)!="E") &&
			(IDNo.charAt(Ilength-1)!="F") &&
			(IDNo.charAt(Ilength-1)!="G") &&
			(IDNo.charAt(Ilength-1)!="H") &&
			(IDNo.charAt(Ilength-1)!="I") &&
			(IDNo.charAt(Ilength-1)!="Z") &&
			(IDNo.charAt(Ilength-1)!="J"))
			return (warnInvalid(theField, "'NRIC' must end with NRIC reference 'A', 'B', 'C', 'D', 'E', 'F', G', 'H', 'I', 'J' or 'Z'"));
		
		if ((!(isInteger(IDNo.charAt(0))) && (IDNo.length!=9)) ||
			((isInteger(IDNo.charAt(0))) && (IDNo.length!=8)) ||
			 (!(isInteger(IDNo.substring(1,Ilength-2)))))
			return (warnInvalid(theField, "An invalid 'NRIC' was entered. 'NRIC' must begin with 'S', 'T' or a number, and end with NRIC reference 'A', 'B', 'C', 'D','E', 'F', 'G', 'H', 'I', 'J', or 'Z'"));
		
		if (isInteger(IDNo.charAt(0)))
			{	start_no = 0;
				ws_first_nric = "S" ;	}
		else
			{	start_no = 1;
				ws_first_nric = IDNo.charAt(0);	}
				
		nric_sum = IDNo.charAt(start_no) * 2 + 
				   IDNo.charAt(start_no + 1) * 7 +
				   IDNo.charAt(start_no + 2) * 6 +
				   IDNo.charAt(start_no + 3) * 5 +
				   IDNo.charAt(start_no + 4) * 4 +
				   IDNo.charAt(start_no + 5) * 3 +
				   IDNo.charAt(start_no + 6) * 2;

		if (ws_first_nric == "T")
			nric_sum = nric_sum + 4;

		nric_sum = nric_sum % 11;
		nric_sum = 11 - nric_sum;

		if (IDNo.charAt(Ilength-1)!=NRIC_CHKD.charAt(nric_sum-1))
			return (warnInvalid(theField, "An invalid 'NRIC' was entered. 'NRIC' must begin with 'S', 'T' or a number, and end with NRIC reference 'A', 'B', 'C', 'D','E', 'F', 'G', 'H', 'I', 'J', or 'Z'"));
		
		return true;
		}
	return true
	}	   


	function checkLength(theField, s, min, max)
	{
	  //check the length of the Field
	  if (theField.value.length <min || theField.value.length >max)
		return warnInvalid(theField, s);
	  else return true;
	}

	function checkPhoneLength(theField, s, min, max)
	{
	  //check the length of the Field
	  if ((theField.value.length <min || theField.value.length >max)&&(theField.value.length>0))
		{return warnInvalid(theField, s);
		theField.focus();
		}
	  else return true;
	}

	function isSame(string1, string2)
	{
	  //string1 == strin2
	  if (string1== string2)
		return true;
		
	  else
		return false
	}

	function checkSState(theField)
	{
	  if (isAlphabetic(theField.value, true))
	  {
		 if (theField.value.length != 0)
		   return checkLength(theField, "Enter 2 to 10 characters for 'State/Province'.", 2, 10)
		 else
		   return true;
	  }
	  return warnInvalid(theField, "Use only letters for 'State/Province' Do not use numbers or dashes.");
	}

	function checkGName(theField)
	{
		return checkLength(theField, "'Last Name' must be entered. 'Last Name' cannot be left blank.", 1, 40)
	
	}
	function checkSName(theField)
	{
		return checkLength(theField, "'First Name' must be entered. 'First Name' cannot be left blank.", 1, 40)
	
	}

	function checkstreet(theField)
	{
		return checkLength(theField, "'Address' must be entered. 'Address' cannot be left blank.", 1, 100)
	}
	function checkblock(theField)
	{
		return checkLength(theField, "'Block' must be entered. 'Block' cannot be left blank.", 1, 10)
	}
	function checkunit(theField)
	{
		return checkLength(theField, "'Unit No' must be entered. 'Unit No' cannot be left blank.", 1, 10)
	}
	function checkSZip(theField)
	{
	  // if (isInteger(theField.value))
	  //{
		   return checkLength(theField, "Enter 4 to 10 characters  for 'Postal/Zip Code.", 4, 10)
	 // }
	 // return warnInvalid(theField, "Zip Code cannot contain non-numeric characters.");
	}


	function checkSPhone(theField, s, emptyOK)
	{
	  //check alphabetics
	  // isAlphabetic (s [,eok])             True if string s is English letters 
	  if (isAlphanumeric(theField.value, false) == false)
		return (warnInvalid(theField, "Use only numbers and dashes for 'Phone Number'. Do not use blank spaces."));
	  else
		return (checkString(theField, s, emptyOK));
	}

	function checkSFax(theField, s, emptyOK)
	{
	  //check alphabetics
	  // isAlphabetic (s [,eok])             True if string s is English letters 
	  if (isAlphanumeric(theField.value, true) == false)
		return (warnInvalid(theField, "Use only letters, numbers and dashes for 'Fax Number'. Do not use blank spaces."));
	  else
		if (theField.value.length!=0)
			if (!checkLength(theField, "Enter 7 to 16 characters for 'Fax Number'.", 7, 16))
				return false;
		return (checkString(theField, s, emptyOK));
		
	}
	

	// checkStateCode (TEXTFIELD theField [, BOOLEAN emptyOK==false])
	//
	// Check that string theField.value is a valid U.S. state code.
	//
	// For explanation of optional argument emptyOK,
	// see comments of function isInteger.

	function checkStateCode (theField, emptyOK)
	{   if (checkStateCode.arguments.length == 1) emptyOK = defaultEmptyOK;
		if ((emptyOK == true) && (isEmpty(theField.value))) return true;
		else
		{  theField.value = theField.value.toUpperCase();
		   if (!isStateCode(theField.value, false)) 
			  return warnInvalid (theField, iStateCode);
		   else return true;
		}
	}

	
function checkDate(field){
	var checkstr = "0123456789";
	var DateField = field;
	var Datevalue = "";
	var DateTemp = "";
	var seperator = "/";
	var day;
	var month;
	var year;
	var leap = 0;
	var err = 0;
	var i;
	   err = 0;
	   DateValue = DateField.value;
	   /* Delete all chars except 0..9 */
	   for (i = 0; i < DateValue.length; i++) {
		  if (checkstr.indexOf(DateValue.substr(i,1)) >= 0) {
		     DateTemp = DateTemp + DateValue.substr(i,1);
		  }
	   }
	   DateValue = DateTemp;
	   /* Always change date to 8 digits - string*/
	   /* if year is entered as 2-digit / always assume 20xx */
	   if (DateValue.length == 6) {
	      DateValue = DateValue.substr(0,4) + '20' + DateValue.substr(4,2); }
	   if (DateValue.length != 8) {
	      err = 19;}
	   /* year is wrong if year = 0000 */
	   year = DateValue.substr(4,4);
	   if (year == 0) {
	      err = 20;
	   }
	   /* Validation of month*/
	   month = DateValue.substr(2,2);
	   if ((month < 1) || (month > 12)) {
	      err = 21;
	   }
	   /* Validation of day*/
	   day = DateValue.substr(0,2);
	   if (day < 1) {
	     err = 22;
	   }
	   /* Validation leap-year / february / day */
	   if ((year % 4 == 0) || (year % 100 == 0) || (year % 400 == 0)) {
	      leap = 1;
	   }
	   if ((month == 2) && (leap == 1) && (day > 29)) {
	      err = 23;
	   }
	   if ((month == 2) && (leap != 1) && (day > 28)) {
	      err = 24;
	   }
	   /* Validation of other months */
	   if ((day > 31) && ((month == "01") || (month == "03") || (month == "05") || (month == "07") || (month == "08") || (month == "10") || (month == "12"))) {
	      err = 25;
	   }
	   if ((day > 30) && ((month == "04") || (month == "06") || (month == "09") || (month == "11"))) {
	      err = 26;
	   }
	   /* if 00 ist entered, no error, deleting the entry */
	   if ((day == 0) && (month == 0) && (year == 00)) {
	      err = 0; day = ""; month = ""; year = ""; seperator = "";
	   }
	   /* if no error, write the completed date to Input-Field (e.g. 13.12.2001) */
	   if (err == 0) {
	      DateField.value = day + seperator + month + seperator + year;
	   }
	   /* Error-message if err != 0 */
	   else {
	      alert("Date is incorrect!");
	      DateField.select();
		  DateField.focus();
		  return false;
	   }
	   
	   return true;
}

function upddte(userForm){
userForm.elements["bdate"].value=userForm.dayval.value+'/'+userForm.monval.value+'/'+userForm.yearval.value;
}


	// Get checked value from radio button.

	function getRadioButtonValue (radio)
	{   for (var i = 0; i < radio.length; i++)
		{   if (radio[i].checked) { break }
		}
		return radio[i].value
	}




	// Validate credit card info.

	function checkCreditCard (radio, theField)
	{   var cardType = getRadioButtonValue (radio)
		var normalizedCCN = stripCharsInBag(theField.value, creditCardDelimiters)
		if (!isCardMatch(cardType, normalizedCCN)) 
		   return warnInvalid (theField, iCreditCardPrefix + cardType + iCreditCardSuffix);
		else 
		{  theField.value = normalizedCCN
		   return true
		}
	}



	/*  ================================================================
		Credit card verification functions
		Originally included as Starter Application 1.0.0 in LivePayment.
		20 Feb 1997 modified by egk:
			   changed naming convention to initial lowercase
					  (isMasterCard instead of IsMasterCard, etc.)
			   changed isCC to isCreditCard
			   retained functions named with older conventions from
					  LivePayment as stub functions for backward 
					  compatibility only
			   added "AMERICANEXPRESS" as equivalent of "AMEX" 
					  for naming consistency 
		================================================================ */


	/*  ================================================================
		FUNCTION:  isCreditCard(st)
 
		INPUT:     st - a string representing a credit card number

		RETURNS:  true, if the credit card number passes the Luhn Mod-10
				test.
			  false, otherwise
		================================================================ */

	function isCreditCard(st) {
	  // Encoding only works on cards with less than 19 digits
	  if (st.length > 19)
		return (false);

	  sum = 0; mul = 1; l = st.length;
	  for (i = 0; i < l; i++) {
		digit = st.substring(l-i-1,l-i);
		tproduct = parseInt(digit ,10)*mul;
		if (tproduct >= 10)
		  sum += (tproduct % 10) + 1;
		else
		  sum += tproduct;
		if (mul == 1)
		  mul++;
		else
		  mul--;
	  }
	// Uncomment the following line to help create credit card numbers
	// 1. Create a dummy number with a 0 as the last digit
	// 2. Examine the sum written out
	// 3. Replace the last digit with the difference between the sum and
	//    the next multiple of 10.

	//  document.writeln("<BR>Sum      = ",sum,"<BR>");
	//  alert("Sum      = " + sum);

	  if ((sum % 10) == 0)
		return (true);
	  else
		return (false);

	} // END FUNCTION isCreditCard()



	/*  ================================================================
		FUNCTION:  isVisa()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid VISA number.
				
			  false, otherwise

		Sample number: 4111 1111 1111 1111 (16 digits)
		================================================================ */

	function isVisa(cc)
	{
	  if (((cc.length == 16) || (cc.length == 13)) &&
		  (cc.substring(0,1) == 4))
		return isCreditCard(cc);
	  return false;
	}  // END FUNCTION isVisa()




	/*  ================================================================
		FUNCTION:  isMasterCard()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid MasterCard
				number.
				
			  false, otherwise

		Sample number: 5500 0000 0000 0004 (16 digits)
		================================================================ */

	function isMasterCard(cc)
	{
	  firstdig = cc.substring(0,1);
	  seconddig = cc.substring(1,2);
	  if ((cc.length == 16) && (firstdig == 5) &&
		  ((seconddig >= 1) && (seconddig <= 5)))
		return isCreditCard(cc);
	  return false;

	} // END FUNCTION isMasterCard()





	/*  ================================================================
		FUNCTION:  isAmericanExpress()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid American
				Express number.
				
			  false, otherwise

		Sample number: 340000000000009 (15 digits)
		================================================================ */

	function isAmericanExpress(cc)
	{
	  firstdig = cc.substring(0,1);
	  seconddig = cc.substring(1,2);
	  if ((cc.length == 15) && (firstdig == 3) &&
		  ((seconddig == 4) || (seconddig == 7)))
		return isCreditCard(cc);
	  return false;

	} // END FUNCTION isAmericanExpress()




	/*  ================================================================
		FUNCTION:  isDinersClub()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid Diner's
				Club number.
				
			  false, otherwise

		Sample number: 30000000000004 (14 digits)
		================================================================ */

	function isDinersClub(cc)
	{
	  firstdig = cc.substring(0,1);
	  seconddig = cc.substring(1,2);
	  if ((cc.length == 14) && (firstdig == 3) &&
		  ((seconddig == 0) || (seconddig == 6) || (seconddig == 8)))
		return isCreditCard(cc);
	  return false;
	}



	/*  ================================================================
		FUNCTION:  isCarteBlanche()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid Carte
				Blanche number.
				
			  false, otherwise
		================================================================ */

	function isCarteBlanche(cc)
	{
	  return isDinersClub(cc);
	}




	/*  ================================================================
		FUNCTION:  isDiscover()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid Discover
				card number.
				
			  false, otherwise

		Sample number: 6011000000000004 (16 digits)
		================================================================ */

	function isDiscover(cc)
	{
	  first4digs = cc.substring(0,4);
	  if ((cc.length == 16) && (first4digs == "6011"))
		return isCreditCard(cc);
	  return false;

	} // END FUNCTION isDiscover()





	/*  ================================================================
		FUNCTION:  isEnRoute()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid enRoute
				card number.
				
			  false, otherwise

		Sample number: 201400000000009 (15 digits)
		================================================================ */

	function isEnRoute(cc)
	{
	  first4digs = cc.substring(0,4);
	  if ((cc.length == 15) &&
		  ((first4digs == "2014") ||
		   (first4digs == "2149")))
		return isCreditCard(cc);
	  return false;
	}



	/*  ================================================================
		FUNCTION:  isJCB()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is a valid JCB
				card number.
				
			  false, otherwise
		================================================================ */

	function isJCB(cc)
	{
	  first4digs = cc.substring(0,4);
	  if ((cc.length == 16) &&
		  ((first4digs == "3088") ||
		   (first4digs == "3096") ||
		   (first4digs == "3112") ||
		   (first4digs == "3158") ||
		   (first4digs == "3337") ||
		   (first4digs == "3528")))
		return isCreditCard(cc);
	  return false;

	} // END FUNCTION isJCB()



	/*  ================================================================
		FUNCTION:  isAnyCard()
 
		INPUT:     cc - a string representing a credit card number

		RETURNS:  true, if the credit card number is any valid credit
				card number for any of the accepted card types.
				
			  false, otherwise
		================================================================ */

	function isAnyCard(cc)
	{
	  if (!isCreditCard(cc))
		return false;
	  if (!isMasterCard(cc) && !isVisa(cc) && !isAmericanExpress(cc) && !isDinersClub(cc) &&
		  !isDiscover(cc) && !isEnRoute(cc) && !isJCB(cc)) {
		return false;
	  }
	  return true;

	} // END FUNCTION isAnyCard()



	/*  ================================================================
		FUNCTION:  isCardMatch()
 
		INPUT:    cardType - a string representing the credit card type
			  cardNumber - a string representing a credit card number

		RETURNS:  true, if the credit card number is valid for the particular
			  credit card type given in "cardType".
				
			  false, otherwise
		================================================================ */

	function isCardMatch (cardType, cardNumber)
	{

		cardType = cardType.toUpperCase();
		var doesMatch = true;

		if ((cardType == "VISA") && (!isVisa(cardNumber)))
			doesMatch = false;
		if ((cardType == "MASTERCARD") && (!isMasterCard(cardNumber)))
			doesMatch = false;
		if ( ( (cardType == "AMERICANEXPRESS") || (cardType == "AMEX") )
					&& (!isAmericanExpress(cardNumber))) doesMatch = false;
		if ((cardType == "DISCOVER") && (!isDiscover(cardNumber)))
			doesMatch = false;
		if ((cardType == "JCB") && (!isJCB(cardNumber)))
			doesMatch = false;
		if ((cardType == "DINERS") && (!isDinersClub(cardNumber)))
			doesMatch = false;
		if ((cardType == "CARTEBLANCHE") && (!isCarteBlanche(cardNumber)))
			doesMatch = false;
		if ((cardType == "ENROUTE") && (!isEnRoute(cardNumber)))
			doesMatch = false;
		return doesMatch;

	}  // END FUNCTION CardMatch()




	/*  ================================================================
		The below stub functions are retained for backward compatibility
		with the original LivePayment code so that it should be possible
		in principle to swap in this new module as a replacement for the  
		older module without breaking existing code.  (There are no
		guarantees, of course, but it should work.)

		When writing new code, do not use these stub functions; use the
		functions defined above.
		================================================================ */

	function IsCC (st) {
		return isCreditCard(st);
	}

	function IsVisa (cc)  {
	  return isVisa(cc);
	}

	function IsVISA (cc)  {
	  return isVisa(cc);
	}

	function IsMasterCard (cc)  {
	  return isMasterCard(cc);
	}

	function IsMastercard (cc)  {
	  return isMasterCard(cc);
	}

	function IsMC (cc)  {
	  return isMasterCard(cc);
	}

	function IsAmericanExpress (cc)  {
	  return isAmericanExpress(cc);
	}

	function IsAmEx (cc)  {
	  return isAmericanExpress(cc);
	}

	function IsDinersClub (cc)  {
	  return isDinersClub(cc);
	}

	function IsDC (cc)  {
	  return isDinersClub(cc);
	}

	function IsDiners (cc)  {
	  return isDinersClub(cc);
	}

	function IsCarteBlanche (cc)  {
	  return isCarteBlanche(cc);
	}

	function IsCB (cc)  {
	  return isCarteBlanche(cc);
	}

	function IsDiscover (cc)  {
	  return isDiscover(cc);
	}

	function IsEnRoute (cc)  {
	  return isEnRoute(cc);
	}

	function IsenRoute (cc)  {
	  return isEnRoute(cc);
	}

	function IsJCB (cc)  {
	  return isJCB(cc);
	}

	function IsAnyCard(cc)  {
	  return isAnyCard(cc);
	}

	function IsCardMatch (cardType, cardNumber)  {
	  return isCardMatch (cardType, cardNumber);
	}



function open_window(url) {
mywin = window.open(url,"win",'toolbar=0,location=0,directories=0,status=1,menubar=1,scrollbars=0,resizable=0,width=446,height=362');
}

function open_window1(url) {
mywin = window.open(url,"win",'toolbar=0,location=0,directories=0,status=1,menubar=1,scrollbars=1,resizable=1');
}

	function checkMandatoryCheckBox(theField, s,userForm)
	{
		if (userForm.elements[theField].value == "[none]")
		   alert(s);
		else
		   return true;
	}
///Function Created By : KKUM
///Date Created : 29/05/2001
/*  ================================================================
	FUNCTION:  CheckDigit()
 
	INPUT:     ph(Phone),hf(hand phone)

	RETURNS:  true, if the length of phone number is equal to 8
			  true, if the length of hand phone no is euqal 0/12
				
			  false, otherwise	
	================================================================ */
function checkDigit(ph,cnt)
{	if (cnt.options[cnt.selectedIndex].value=="SG")
		{return checkPhoneLength(ph, "Invalid Phone Number", 8, 8)}	
	else
		{return checkPhoneLength(ph, "Enter 7 to 16 characters for \'Phone Number\'.", 7, 16)}		
	return true;
	
}	
function checkDigitall(ph,hf,cnt,age)
{	if (cnt.options[cnt.selectedIndex].value=="SG")
		{return checkPhoneLength(ph, "Invalid Phone Number", 8, 8)}	
	else
		{return checkPhoneLength(ph, "Enter 7 to 16 characters for \'Phone Number\'.", 7, 16)}		
	if(hf.value.length > 0)
		{	if (cnt.value=="SG")
			{	return checkPhoneLength(hf, "Invalid Mobile Number",8, 8)
			}		
			else
			{return checkPhoneLength(hf, "Invalid Mobile Number",0, 8)
			}		      		
		}		

	if (age.value.length>0)
		{if(isNaN(age.value))
			{alert('Invalid Age');
				 age.focus()
			 return false;
			}
		}	
	return true;
	
}
///End of Function

///Function Created By : KKUM
///Date Created : 29/05/2001
/*  ================================================================
	FUNCTION:  chkemtyphone()
 
	INPUT:     ph(Phone)

	RETURNS:  false, if the phone number empty
	================================================================ */
function chkemtyphone(ph)
{
	if(ph.value.length == 0)
	{alert('Please Enter the Phone No.');
	 ph.focus();
	 return false;
	}
	return true;
}


function TrimSpace(myfield) 
{	while(''+myfield.value.charAt(myfield.value.length-1)==' ')
		myfield.value=myfield.value.substring(0,myfield.value.length-1);
}

// -->

function checkIDTypeLength(a,b)
{
	if (a == 'N')
	{return checkLength(b, "Enter 8 to 14 characters for 'NRIC/Passport. 'NRIC' must begin with 'S', 'T' or a number, and end with NRIC reference 'A', 'B', 'C', 'D','E', 'F', 'G', 'H', 'I', 'J', or 'Z'", 8, 14);}
	if (a =='P')
			{return checkLength(b, "Enter 3 to 14 characters for Passport.", 3, 14);}
	if (a =='C')
			{return checkLength(b, "Enter 3 to 14 characters for Co. Reg. No.", 3, 14);}		

}
//////////////////////////////////// end script.asp functions ////////////////////////////