////////////////////////////////
//START: MISCELLANEOUS FUNCTIONS
////////////////////////////////
var isIE = (navigator.appName.indexOf("Microsoft") != -1) ? true : false;
var isNS = (navigator.appName == "Netscape") ? true : false;

function submitForm(isFormName, isOperation, ibValidate, bSubmitRequired) 
{
	var OForm = eval("document." + isFormName);
	var bQueryStringPresent
	var sAction
	
	sAction = OForm.action
	bQueryStringPresent = sAction.indexOf("?")
	if (bQueryStringPresent > 0)
	{
		if (isOperation != "")
		{
			OForm.action = sAction.substr(0,bQueryStringPresent)
		}
	}
	
	if (ibValidate) 
	{
		if (validateForm(OForm))
		{ 
			OForm.action = OForm.action + isOperation
			if (bSubmitRequired)
			{
				OForm.submit();
			}else{
				return true;
			}
		}
	}else{
		OForm.action = OForm.action + isOperation
		if (bSubmitRequired)
		{ 
			OForm.submit();
		}else{
			return true;
		}
	}
	return false;
}

function openURL(isURL, ibOpenNewWindow, isWindowName, isWindowAttrs)
{
	if (ibOpenNewWindow)
		window.open(isURL, isWindowName, isWindowAttrs);
	else
		window.location.href = isURL;
}

function closeWindow(isReturnTo) 
{
	if(window.parent.name=="")
	{
		if (arguments.length > 0)
			window.location.href=isReturnTo; 
	}
	else
		window.close(); 
}

function setHelp(p_strHelpText)
{
	var l_objHelp = (isIE) ? help : document.help
	writeInDiv(l_objHelp, p_strHelpText)
	return
}

function clearHelp()
{
	var l_objHelp = (isIE) ? help : document.help
	writeInDiv(l_objHelp, "")
}
//////////////////////////////
//END: MISCELLANEOUS FUNCTIONS
//////////////////////////////

//////////////////////////////////
//START: DATE VALIDATION FUNCTIONS
//////////////////////////////////
function CheckDate(sFieldValue)
{
	var bInvalidDate		= false;
	var lFirstAppearanceOf	= -1;
	var lLastAppearanceOf	= -1;
	var lDay, lMonth, lYear;

	// Check the format of the value
	if(isNumber(sFieldValue))
	{
		// This is a number date so check that the value is eight characters long
		if(parseInt(sFieldValue)!=0)
		{
			if(sFieldValue.length!=8)
				bInvalidDate = true;
			else
			{
				lDay = parseInt(sFieldValue.substring(0,2),10);
				lMonth = parseInt(sFieldValue.substring(2,4),10);
				lYear = parseInt(sFieldValue.substring(4),10);
				bInvalidDate = !isValid(lYear, lMonth, lDay);
			}
		}
	}
	else if(sFieldValue.length > 0)
	{
		lFirstAppearanceOf = sFieldValue.indexOf("/");
		lLastAppearanceOf = sFieldValue.lastIndexOf("/");

		if((lFirstAppearanceOf!=-1) && (lLastAppearanceOf!=-1) 
				&& (lFirstAppearanceOf!=lLastAppearanceOf) )
		{
			lDay	= parseInt(sFieldValue.substring(0,lFirstAppearanceOf),						10);
			lMonth	= parseInt(sFieldValue.substring(lFirstAppearanceOf + 1,lLastAppearanceOf),	10);
			lYear	= parseInt(sFieldValue.substring(lLastAppearanceOf	+ 1),					10);
			bInvalidDate = !isValid(lYear, lMonth, lDay);
		}else{
			bInvalidDate = true;
		}
	}else{
		bInvalidDate = true;
	}
	return !bInvalidDate;
}

function isDateChar(lKeyCode)
{
	if( ((lKeyCode< 48) || (lKeyCode > 57)) && (lKeyCode!=13))
	{
		if (lKeyCode == 47)
		{
			// Check to see if there any forward slashes in the string...only allow two
			var sInputValue = window.event.srcElement.value;
			var lFirstAppearanceOf = sInputValue.indexOf("/");
			var lLastAppearanceOf = sInputValue.lastIndexOf("/");

			if((lFirstAppearanceOf!=-1) && (lLastAppearanceOf!=-1) 
					&& (lFirstAppearanceOf!=lLastAppearanceOf) )
			{
				window.event.returnValue=false;
				return false;
			}
		}
		else
			return false;
	}
	return true;
}

function isValid(lYear, lMonth, lDay)
{
	var alLeapYear		= new Array(31,29,31,30,31,30,31,31,30,31,30,31);
	var alNonLeapYear	= new Array(31,28,31,30,31,30,31,31,30,31,30,31);

	// Firstly, check the year
	if((lYear < 1000) || (lYear > 9999) || (isNaN(lYear)))
		return false;
	else
	{
		// then check the month
		if( (lMonth<1) || (lMonth>12) || (isNaN(lMonth)) )
			return false;
		else
		{
			// Then check the day
			// Check to see if this is a leap year
			if( isLeapYear(lYear) )
				var lLastDay = alLeapYear[lMonth-1];
			else
				var lLastDay = alNonLeapYear[lMonth-1];

			if( (lDay < 1) || (lDay > lLastDay) || (isNaN(lDay)))
				return false;
		}
	}
	return true;
}

function isLeapYear(lYear)
{
	return( ((lYear % 400)==0) ||		// Divisible by four hundred  
			(((lYear % 100)!=0) &&		// Not divisible by 100
			 ((lYear %  4 )==0) ));		// Divisible by four
}

function isNumber(sValue)
{
	return (sValue==parseInt(sValue,10));
}

function CheckFutureDate(sStartDate,sEndDate)
{	
	// Takes two dates in format dd/mm/yyyy
	var dteStartDate, dteEndDate;
	
	dteStartDate = GetValidDate(sStartDate);
	dteEndDate   = GetValidDate(sEndDate);
	
	if(dteEndDate <= dteStartDate){return false;}
	return true;
}

function GetValidDate(sInputDate)
{
	var lFirstAppearanceOf;
	var lLastAppearanceOf;
	var lYear,lMonth,lDay;
	
	lFirstAppearanceOf = sInputDate.indexOf("/");
	lLastAppearanceOf  = sInputDate.lastIndexOf("/");

	if((lFirstAppearanceOf!=-1) && (lLastAppearanceOf!=-1) 
			&& (lFirstAppearanceOf!=lLastAppearanceOf) )
	{
		lDay	= parseInt(sInputDate.substring(0,lFirstAppearanceOf),						10);
		lMonth	= parseInt(sInputDate.substring(lFirstAppearanceOf + 1,lLastAppearanceOf),	10);
		lYear	= parseInt(sInputDate.substring(lLastAppearanceOf	+ 1),					10);
	}else{
		return false;
	}
	
	var dteNewDate = new Date(lYear,lMonth - 1,lDay);
	return dteNewDate;
}

function CheckFutureEqualDate(sStartDate,sEndDate)
{	
	// Takes two dates in format dd/mm/yyyy
	var dteStartDate, dteEndDate;
	
	dteStartDate = GetValidDateWithoutSlash(sStartDate);
	dteEndDate   = GetValidDateWithoutSlash(sEndDate);
	
	if(dteEndDate < dteStartDate){return false;}
	return true;
}

function GetValidDateWithoutSlash(sInputDate)
{
	var lFirstAppearanceOf;
	var lLastAppearanceOf;
	var lYear,lMonth,lDay;
	
	lFirstAppearanceOf = sInputDate.indexOf("/");
	lLastAppearanceOf  = sInputDate.lastIndexOf("/");

	if((lFirstAppearanceOf!=-1) && (lLastAppearanceOf!=-1) 
			&& (lFirstAppearanceOf!=lLastAppearanceOf) )
	{
		lDay	= parseInt(sInputDate.substring(0,lFirstAppearanceOf),				10);
		lMonth	= parseInt(sInputDate.substring(lFirstAppearanceOf + 1,lLastAppearanceOf),	10);
		lYear	= parseInt(sInputDate.substring(lLastAppearanceOf + 1),				10);
	}
	else
	{
		lDay = parseInt(sInputDate.substring(0,2),10);
		lMonth = parseInt(sInputDate.substring(2,4),10);
		lYear = parseInt(sInputDate.substring(4),10);
	}

	var dteNewDate = new Date(lYear,lMonth - 1,lDay);
	return dteNewDate;
}

////////////////////////////////
//END: DATE VALIDATION FUNCTIONS
////////////////////////////////

///////////////////////////////////
//START: INPUT VALIDATION FUNCTIONS
///////////////////////////////////
function trimString (isInputString)
{
	isInputString = this != window? this : isInputString;
	return isInputString.replace(/^\s+/g, '').replace(/\s+$/g, '');
}

function isDecimalNumber(ilDecimalNumber)
{
	var sTemplate = /^\s*\d+\.\d{2}\s*$/;
	if (!sTemplate.test(ilDecimalNumber)){return false;}
	return true;
}

function isDecimalOrNumber(ilNumber)
{
	var sTemplate = /(^\s*\d+\.\d{2}\s*$)|(^\s*\d\d*\s*$)/;
	if (!sTemplate.test(ilNumber)){return false;}
	return true;
}

function isNumberONLY(ilNumber)
{
	var sTemplate = /^\s*\d\d*\s*$/;
	if (!sTemplate.test(ilNumber)){return false;}
	return true;
}

function isNINO(ilNINO)
{
	var sTemplate = /^[A-Za-z]{2}\d{6}[A-Za-z]{1}$/g;
	if (!sTemplate.test(ilNINO)){return false;}
	return true;
}

function fieldValidate(control, caption, value, dataType)
{
	if (value=="") return true;
	var sDataType = dataType.toLowerCase();
	switch (sDataType)
	{
		case "emailaddress": return fieldValidateEMail(control, value, caption); break;
		case "username": return fieldValidateUsername(control, value, caption); break;
		case "password": return fieldValidatePassword(control, value, caption); break;
		case "postcode": return fieldValidatePostcode(control, value, caption); break;
		case "date": return fieldValidateDate(control, value, caption); break;
		default:  return true; break;
	}
}

function keyValidate(ev, dataType, control)
{
	if (dataType == "") return true; //anything goes
	// edit keys are okay
	if (isNS) { // Map event object
		event				= ev;
		event.keyCode		= ev.which;
		event.srcElement	= ev.target;
	}
	//since single text box forms submit on pressing 'enter' don't return true on keyCode 13
	if ((event.keyCode == 8) || (event.keyCode == 27)) return true;
	//rest depends on the type of field and its content
	var keyPressed = String.fromCharCode(event.keyCode);
	var sDataType = dataType.toLowerCase();
	switch (sDataType)
	{
		case ("alphanumeric"): return keyValidateAlphaNumeric(keyPressed); break;
		case ("strictalphanumeric"): return keyValidateStrictAlphaNumeric(keyPressed); break;
		case ("integer"): return keyValidateInteger(control, keyPressed); break;
		case ("date"): return keyValidateDate(control, keyPressed); break;
		case ("securityquestions"): return keyValidateSecurityQuestions(keyPressed); break;
		case ("emailaddress"): return keyValidateEmail(keyPressed); break;
		default: return true; break;
	}
}

function keyValidateInteger(control, keyPressed)
{
	if ("0123456789".indexOf(keyPressed) == -1){return false;}
	return true;
}

function keyValidateDate(control, keyPressed)
{
	if ("0123456789/".indexOf(keyPressed) == -1){return false;}
	return true;
}

function keyValidateEmail(keyPressed)
{
	if ("0123456789@.-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(keyPressed) == -1) {return false;}
	return true;
}

function keyValidateAlphaNumeric(keyPressed)
{
	if ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'- ()@/".indexOf(keyPressed) == -1) {return false;}
	return true;
}

function keyValidateSecurityQuestions(keyPressed)
{
	if ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'- ()@".indexOf(keyPressed) == -1) {return false;}
	return true;
}

function keyValidateStrictAlphaNumeric(keyPressed)
{
	if ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".indexOf(keyPressed) == -1) {return false;}
	return true;
}

function keyValidateAlpha(keyPressed)
{
	if ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(keyPressed) == -1) {return false;}
	return true;
}

function fieldValidateUsername(control, value, caption)
{
	// checks a username is >= 6 characters long, must start with a letter, can only include letters or numbers (no spaces, punctuation etc).
	var AcceptChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	var strTempValue;
	var charValue;
	var ch;
	var i;
	
	if (value.length < 8){return false;}
	
	strTempValue = value;
	strTempValue = strTempValue.toUpperCase();
			
	//first character must be alphanumeric
	charValue = strTempValue.charCodeAt(0);
	
	//invalid first character
	if (charValue<65 || charValue>90){return false;}
	
	//loop through and check that each character is either numeric or alphanumeric
	for (i=0;i<strTempValue.length;i++)
	{
		ch = strTempValue.charAt(i)
		if (AcceptChars.indexOf(ch) < 0){return false;}
	}
	return true;
}

function fieldValidatePassword(control, value, caption)
{
	// checks a password is >= 8 characters long, contains both letters and numbers (and no spaces, punctuation etc).
	var strNumbers = "0123456789";
	var strLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	var strTempValue;
	var ch;
	var i;
	var bContainsNumber = false;
	var bContainsLetter = false;

	if (value.length < 8){return false}

	strTempValue = value;
	strTempValue = strTempValue.toUpperCase();

	//loop through and check that each character is either numeric or alphanumeric
	for (i=0;i<strTempValue.length;i++)
	{
		ch = strTempValue.charAt(i)
		if (strNumbers.indexOf(ch) >= 0)
		{
			bContainsNumber = true;
		}
		else if (strLetters.indexOf(ch) >= 0)
		{
			bContainsLetter = true;
		}
		else
		{
			return false;
		}
	}
	return (bContainsNumber && bContainsLetter);
}

function fieldValidatePostcode(control, value, caption)
{ 
	//check postcode format is valid
	var strTempValue
	var test
	
	strTempValue = value;
	
	size = strTempValue.length;
	strTempValue = strTempValue.toUpperCase(); //Change to uppercase;
	while (strTempValue.slice(0,1) == " ") //Strip leading spaces;
  
	{
		strTempValue = strTempValue.substr(1,size-1);size = strTempValue.length;
  	}
 
	while(strTempValue.slice(size-1,size)== " ") //Strip trailing spaces
  	{
		strTempValue = strTempValue.substr(0,size-1);size = strTempValue.length;
  	}
 
	value = test; //write back to form field
 	if (size < 6 || size > 8)
	{ 
		//Not a valid postcode - wrong length
  		return false;
  	}
 
	if (!(isNaN(strTempValue.charAt(0))))
	{ 
		//Not a valid postcode - cannot start with a number
   		return false;
  	}

 	if (isNaN(strTempValue.charAt(size-3)))
	{ 
		//Not a valid postcode - alpha character in wrong position
   		return false;
  	}

 	if (!(isNaN(strTempValue.charAt(size-2))))
	{ 
		//Not a valid postcode - number in wrong position
   		return false;
  	}
 
	if (!(isNaN(strTempValue.charAt(size-1))))
	{ 
		//third character of inward code must be alpha rule
   		return false;
  	}

	 if (!(strTempValue.charAt(size-4) == " "))
	{
		//space in position length-3 rule
   		return false;
   	}

 	count1 = strTempValue.indexOf(" ");count2 = strTempValue.lastIndexOf(" ");
 	if (count1 != count2)
	{
		//only one space rule
   		return false;
  	}

	//Postcode Format OK
	return true;
}

function fieldValidateDate(control, value, caption)
{ 
	//check date format is valid (i.e. dd/mm/yyyy)
	var strNumbers = "0123456789";
	var charDateSeparator = "/";
	var strTempValue;
	var i;
	var ch;
	var size;
	
	strTempValue = value;
	size = strTempValue.length;

	while (strTempValue.slice(0,1) == " ") //Strip leading spaces;
	{
		strTempValue = strTempValue.substr(1,size-1);
		size = strTempValue.length;
  	}
 
	while(strTempValue.slice(size-1,size)== " ") //Strip trailing spaces
  	{
		strTempValue = strTempValue.substr(0,size-1);
		size = strTempValue.length;
  	}
 
 	
 	if (size != 10)
	{ 
		//not a valid date - should be dd/mm/yyyy
  		return false;
  	}
  
	//loop through and check that each character is either numeric or date separator
	for (i=0;i<strTempValue.length;i++)
	{

		ch = strTempValue.charAt(i)

		if (i == 2 || i ==5)
		{

			//char should be date separator
			if (ch != charDateSeparator)
			{
				return false;
			}
		}
		else
		{

			//char should be numeric
			if (strNumbers.indexOf(ch) == -1)
			{
				return false;
			}
		}
	}

	//date ok
	return true;
}


function fieldValidateEMail(control, email, caption)
{
	// checks an email address to see that it contains at least an @ and a period.
	atpos = email.indexOf("@")
	if (atpos<1){return false;}
	atstring =  email.substring(atpos, email.length);
	dotpos = atstring.indexOf(".");
	if (dotpos<1){return false;}
	return true;
}
/////////////////////////////////
//END: INPUT VALIDATION FUNCTIONS
/////////////////////////////////

//////////////////////////////
//START: IFA REWRITE FUNCTIONS
//////////////////////////////
function MM_openBrWindow(theURL,winName,features)
{
	window.open(theURL,winName,"menubar=0,toolbar=1,location=0,status=0,scrollbars=1,resizable=1,width=500,height=400,left=" + (screen.width - 500)/2 + ",top="+ (screen.height - 500)/2);
}

function MM_openFCwindow(theURL,winName,features)
{
	window.open(theURL,winName,"menubar=0,toolbar=1,location=0,status=0,scrollbars=1,resizable=1,width=750,height=370,left=" + (screen.width - 750)/2 + ",top="+ (screen.height - 470)/2);
}

function MM_findObj(n, d)
{
	var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
	d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
	if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
	for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
	if(!x && document.getElementById) x=document.getElementById(n); return x;
}

function MM_showHideLayers()
{
	var i,p,v,obj,args=MM_showHideLayers.arguments;
	for (i=0; i<(args.length-2); i+=3) if ((obj=MM_findObj(args[i]))!=null) { v=args[i+2];
	if (obj.style) {obj=obj.style; v=(v=='show')?'visible':(v='hide')?'hidden':v;}
	obj.visibility=v;}
}

function displayHiddenDiv(sTargetDiv, sSourceDiv) {
	document.getElementById(sTargetDiv).innerHTML = document.getElementById(sSourceDiv).innerHTML;
}
////////////////////////////
//END: IFA REWRITE FUNCTIONS
////////////////////////////

//////////////////////////////
// Contract Enquiry Functions
//////////////////////////////
function showHelp(sTargetObject, sHelpText) {
	window.status = sHelpText.replace('<b>', '').replace('</b>', ''); 
	document.getElementById(sTargetObject).innerHTML = sHelpText;
}

function hideHelp(sTargetObject) {
	window.status = '';
	document.getElementById(sTargetObject).innerHTML = '';
}

function setPolicyDetails(sPolicyNumber, lPolicyType) {
	document.PageForm.inpHiddenPolicyNumber.value = sPolicyNumber;
	document.PageForm.inpHiddenPolicyType.value = lPolicyType;
}

function setNextPage(lPageNumber) {
	document.PageForm.inpHiddenPageNumber.value = lPageNumber;
}

function setBulkReferenceNumber(lReferenceNumber) {
	document.PageForm.inpHiddenBulkReferenceNumber.value = lReferenceNumber;
	return submitForm('PageForm', '?PageAction=0', false, true);
}

function setBulkDescription(lReferenceNumber) {
	document.PageForm.inpHiddenBulkReferenceNumber.value = lReferenceNumber;
	return submitForm('PageForm', '?PageAction=20', false, true);
}

function downloadBulkExtract(lReferenceNumber) {
	document.PageForm.inpHiddenBulkDownloadReferenceNumber.value = lReferenceNumber;
	return submitForm('PageForm', '?PageAction=24', false, true);
}

function viewBulkExtract(lReferenceNumber) {
	document.PageForm.inpHiddenBulkViewReferenceNumber.value = lReferenceNumber;
	return submitForm('PageForm', '?PageAction=23', false, true);
}

//////////////////////////////////
// Contract Enquiry Functions End
//////////////////////////////////


///////////////////////////////////
//START: CONSUMER REWRITE FUNCTIONS
///////////////////////////////////
function showDiv(activeDiv, totalDivs, divBaseName)
{
	var lCount;
	//1. set display='none' for all divs
	for (lCount=1; lCount<totalDivs+1; lCount++){document.getElementById(divBaseName + lCount).style.display='none';}
	//2. set display='' for the activeDiv
	document.getElementById(activeDiv).style.display='';
}

function MM_openMapWindow(theURL,winName,features)
{
	window.open(theURL,winName,"menubar=0,toolbar=1,location=0,status=0,scrollbars=1,resizable=1,width=640,height=500,left=" + (screen.width - 620)/2 + ",top="+ (screen.height - 620)/2);
}
/////////////////////////////////
//END: CONSUMER REWRITE FUNCTIONS
/////////////////////////////////

/////////////////////////////////
// New date manipulation functions
/////////////////////////////////

function FormatConvertDate(ilEndDate)
{
	var sDate="";
	var lLen;
	sDate =sDate + ilEndDate;		
	lLen= sDate.length
	return sDate.substring(6,8) + "/" + sDate.substring(4,6) + "/" + sDate.substring(0,4)
}
function AddYearsMonths(ilStartYear, ilStartMonth, ilStartDay, ilYears, ilMonths)
{
  var lYears = 0;
  var lMonths = 0;
  var lDays = 0;
  var lDate = 0;
  
  lMonths = parseInt(ilStartMonth,10) + parseInt(ilMonths,10) 
  if(lMonths>12)
  {
    lMonths =lMonths - 12;
	lYears = lYears + 1;
  }
  lYears = lYears + parseInt(ilYears,10) + parseInt(ilStartYear,10);
  
  lDays = CheckLastDayofMonth(lYears, lMonths, parseInt(ilStartDay,10));
  
  lDate = lYears * 10000 + lMonths * 100 + lDays
  return lDate
  
}
function DeductYearsMonths(ilStartYear,ilStartMonth,ilStartDay, ilYears, ilMonths)
{
  var lYears = 0;
  var lMonths = 0;
  var lDays = 0;
  var lDate = 0;
  
  
  lMonths = eval(parseInt(ilStartMonth,10) - parseInt(ilMonths,10))
  if(lMonths<1)
  {
    lMonths =lMonths + 12;
	lYears = lYears - 1;
  }
  lYears = parseInt(ilStartYear,10) + lYears - parseInt(ilYears,10)
  lDays = parseInt(ilStartDay,10)
 
  if(lDays==0) lDays=1;
  lDate = lYears * 10000 + lMonths * 100 + lDays
  return lDate
  
}

function BetweenTwoDates(ilStartDate,ilEndDate,ilYears,ilMonths,ilDays)
{
  var lDate = 0;
  lDate = parseInt(ilYears,10) * 10000 + parseInt(ilMonths,10) * 100 + parseInt(ilDays,10);
  if(lDate<ilStartDate)
  {
	return false;
  }
  else{
    if(lDate>ilEndDate) 
    {
      return false 
    }else{
      return true;
    }
    
  }
}

function CheckLastDayofMonth (ilYear, ilMonth, ilDay)
{
	var alLeapYear		= new Array(31,29,31,30,31,30,31,31,30,31,30,31);
	var alNonLeapYear	= new Array(31,28,31,30,31,30,31,31,30,31,30,31);
	
	if( isLeapYear(ilYear) )
	  var lLastDay = alLeapYear[ilMonth-1];
	else
	  var lLastDay = alNonLeapYear[ilMonth-1];
	
	if(ilDay==0)
	{
	  return lLastDay;
	}
	else{
	  if(ilDay>lLastDay)
	    return lLastDay;
	  else
	    return ilDay;
	}
}
/////////////////////////////////
// New date manipulation functions end
/////////////////////////////////



/////////////////////////////////
// New brand functions start
/////////////////////////////////
function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}
/////////////////////////////////
// New brand functions end
/////////////////////////////////



function productTypeChangeEventHandler(lValue)
{
	if(lValue!=0)
	{
		location.href = 'GlobalInvestorChargeOptions.aspx?id=' + lValue;
	}
}