var iDateIndex
var iMonthIndex
var iYearIndex
var iDateIdxF
var iMonthIdxF
var iYearIdxF

var sCentury=(((new Date()).getFullYear()).toString()).substr(0,2)

function ParseDate(sDate,nFmt){
	/*	returns an array of date components
		sDate - Date String in server format
		nFmt - Optional (either fmtMMYYYY or fmtMMDD)
	*/

	var nComp=new Array(3)
	var sTemp=new String()
	var ptr
	var numItems=0
	var sRegExp=new RegExp('[^0-9]+', 'g')

	sDate=sDate.replace(sRegExp, sServerDateSep)

	if(sDate.indexOf(sServerDateSep) == -1){
		nComp=IntepretDate(sDate)
	}else{
		sTemp=sDate+sServerDateSep

		for (var i=0; i < 3; i++){
			ptr=sTemp.indexOf(sServerDateSep)

			if(ptr!=-1){
				nComp[i]=1 * sTemp.substring(0,ptr)
				numItems++
				sTemp=sTemp.substring(ptr+1)
			}else{
				break;
			}
		}

		DateIndexes()

		if(numItems < 3){
			//assume the missing component is the year (unless nFmt is fmtMMYYYY)
			switch (sServerDateFormat){
				case 'dmy':
					nComp[iYearIndex]=CurrentYear()
					break
				case 'mdy':
					nComp[iYearIndex]=CurrentYear()
					break
				case 'ymd':
					if(nFmt!=fmtMMYYYY){
						nComp[iDateIndex]=nComp[iMonthIndex]
						nComp[iMonthIndex]=nComp[iYearIndex]
						nComp[iYearIndex]=CurrentYear()
					}else{
						nComp[iDateIndex]=1
					}
					break
			}
		}
	}

	return nComp
}

function IntepretDate(sDate){
	// attempts to format a date
	var oDate=new Date()
	var nComp=new Array(3)
	var nTemp=0
	var sDay=''
	var sYear=''
	var sMonth=''

	DateIndexes()

	switch (sDate.length){
		case 1:		//treat as a day
			nTemp=1 * rawnum(sDate)
			if(nTemp > 0){
				sMonth=oDate.getMonth()+1
				sDay=sDate
				sYear=oDate.getFullYear()
			}
			break;
		case 2:		//either a day or a year
			nTemp=1 * rawnum(sDate)
			if(nTemp > LastDayOfMonth(oDate)){
				sMonth=0
				sDay=0
				sYear=sDate
			}else{
				sMonth=oDate.getMonth()+1
				sDay=nTemp
				sYear=oDate.getFullYear()
			}
			break;
		case 3:	 // month/year
			break;
		case 4:	 //	or year (if 19xx or 20xx) - commented out
			// changed 14 September 2000 (PBW)
			// shouldn't format dates with only 4 digits
			break;
			var i=1
			if(sDate.length == 4){i=2}
				sMonth=sDate.substr(0,i)
				sDay=1
				sYear=Adjust2kYear(sDate.substr(i))
				if(((1 * sMonth) < 1) || ((1 * sMonth) > 12)){
					sMonth=1
				}
			break;

		case 5:	 // month/day/year
		case 6:
		case 7:
		case 8:
			var iStart=0
			var iLen=2
			if(isodd(sDate.length)){iLen=1}

			switch (iMonthIndex){
				case 1:
					iStart=2
					if((sDate.length > 6) && (iDateIndex == 2)){iStart=4}
					break;
			}
			sMonth=sDate.substr(iStart,iLen)

			iLen=2
			switch (iDateIndex){
				case 0:
					iStart=0
					break;
				case 1:
					iStart=2
					if(isodd(sDate.length)){iStart=1}
					break;
				case 2:
					iStart=sDate.length - 2
					break;
			}
			sDay=sDate.substr(iStart,iLen)

			iLen=2
			if(sDate.length > 6){iLen=4}
			switch (iYearIndex){
				case 0:
					iStart=0
					break;
				case 2:
					iStart=4
					if(isodd(sDate.length)){iStart=3}
					break;
			}

			sYear=sDate.substr(iStart,iLen)
			if(sYear.length < 4){ sYear=Adjust2kYear(sYear)}
			break;

	}

	nComp[iDateIndex]=sDay
	nComp[iMonthIndex]=sMonth
	nComp[iYearIndex]=sYear

	return nComp
}

function LastDayOfMonth(oDate){
	var oTempDate=new Date(oDate.getFullYear(), oDate.getMonth()+1, 1)
	var o=new Date(oTempDate.getFullYear(), oTempDate.getMonth(), oTempDate.getDate()-1)
	return o.getDate()
}

function DateStringToObject(sDate){
	/* returns a date object
		sDate - Date String in server format
	*/
	var nFmt=0
	if(DateStringToObject.arguments.length > 1){ nFmt=DateStringToObject.arguments[1] }

	var nComp=new Array(3)
	var oDate

	var iYidx
	var iMidx
	var iDidx

	if(nFmt == fmtDATE_FUZZY){
		nComp=ParseFuzzyDate(sDate)
		iYidx=iYearIdxF
		iMidx=iMonthIdxF
		iDidx=iDateIdxF
		if(nComp[iMonthIdxF] == -1){ nComp[iMonthIdxF]=1 }
		if(nComp[iDateIdxF] == -1){ nComp[iDateIdxF]=1 }
	}else{
		nComp=ParseDate(sDate)
		iYidx=iYearIndex
		iMidx=iMonthIndex
		iDidx=iDateIndex
	}

	nComp[iYidx]=Adjust2kYear(nComp[iYidx])

	if(sDate == ''){
		oDate=new Date()
	}else{
		oDate=new Date(nComp[iYidx], nComp[iMidx] - 1, nComp[iDidx])
	}

	return oDate
}

function DateObjectToString(oDate){
	/* returns a local date in the Server format
		oDate - Date Object
	*/

	var nComp=new Array(3)
	var ntmp

	DateIndexes()

	nComp[iDateIndex]=oDate.getDate()
	nComp[iMonthIndex]=oDate.getMonth()+1
	nComp[iYearIndex]=oDate.getFullYear()

	var sDateFmt=sServerDateFormat.toLowerCase()
	var sShortDateFmt=sServerShortDate.toLowerCase()
	ntmp=1 * nComp[iDateIndex]
	if((ntmp > 0) && (ntmp < 10)){
		if(sShortDateFmt.search('dd')!=-1){
			nComp[iDateIndex]='0'+ntmp
		}
	}

	ntmp=1 * nComp[iMonthIndex]
	if((ntmp > 0) && (ntmp < 10)){
		if(sShortDateFmt.search('mm')!=-1){
			nComp[iMonthIndex]='0'+ntmp
		}
	}

	if((!bServerFullYear) && ThisWindowingCentury(nComp[iYearIndex])){
		var sYear=(nComp[iYearIndex]).toString()
		nComp[iYearIndex]=1 * sYear.substr(2)
	}

	ntmp=1 * nComp[iYearIndex]
	if((ntmp >= 0) && (ntmp < 10)){nComp[iYearIndex]='0'+ntmp}

	return(nComp[0]+sServerDateSep+nComp[1]+sServerDateSep+nComp[2])
}

function CurrentYear(){
	var oCurDate=new Date()
	return (oCurDate.getFullYear())
}

function ThisWindowingCentury(nYear){
	// returns true if nYear is in this century and outside the window (>29)

	var sCurYear=(CurrentYear()).toString()
	var sYear=(nYear).toString()
	var nCurrentCentury=1 * sCurYear.substr(0,2)
	var nCentury=1 * sYear.substr(0,2)
	var currentX=1 * sCurYear.substr(2,2)
	if(0<=currentX && currentX<=29){
		startCentury=((nCurrentCentury-1)+''+'30')-0
		endCentury=(nCurrentCentury+''+'29')-0
	}else{
		startCentury=(nCurrentCentury+''+'30')-0
		endCentury=((nCurrentCentury+1)+''+'29')-0
	}
	return (startCentury<=nYear && nYear<=endCentury)
}

function NormalizeDate(sDate){
	/* returns a date string in mm/dd/yyyy format
		sDate - Date String in server format
	*/

	var nComp=new Array(3)

	nComp=ParseDate(sDate)

	nComp[iYearIndex]=Adjust2kYear(nComp[iYearIndex])

	if((nComp[iMonthIndex].toString()).length == 1){ nComp[iMonthIndex]='0'+nComp[iMonthIndex]}
	if((nComp[iDateIndex].toString()).length == 1){ nComp[iDateIndex]='0'+nComp[iDateIndex]}

	return(nComp[iMonthIndex]+sServerDateSep+nComp[iDateIndex]+sServerDateSep+nComp[iYearIndex])
}

function Adjust2kYear(sYear){
	var nTmp=1 * sYear

	if((nTmp >= 0) && (nTmp <= 29)){
		nTmp += 2000
	}else{
		if((nTmp >= 30) && (nTmp < 100)){
			nTmp += 1900
		}else{
			nTmp=sYear
		}
	}

	return nTmp
}

function ValidDate(sDate, nFmt){
	//sDate - Date String in server format
	var sNormDate
	var oDate
	var sNewDate
	var sTemp=''
	var nComp=new Array(3)

	switch (nFmt){
		case fmtMMYYYY:
			var temp=ParseDate(sDate, nFmt)
			if(iMonthIndex < iYearIndex){
				nComp[iMonthIndex]=temp[0]
				nComp[iYearIndex]=temp[1]
			}else{
				nComp[iMonthIndex]=temp[1]
				nComp[iYearIndex]=temp[0]
			}
			nComp[iDateIndex]=1

			sTemp=nComp[0]+sServerDateSep+nComp[1]+sServerDateSep+nComp[2]
			break

		case fmtDATEMDY:
			sTemp=sDate
			nComp=ParseDate(sDate)
			break

		case fmtMMDD:
			var temp=ParseDate(sDate)
			nComp[iMonthIndex]=temp[iMonthIndex]
			nComp[iDateIndex]=temp[iDateIndex]
			nComp[iYearIndex]=1996 //leap Year chosen
			sTemp=nComp[0]+sServerDateSep+nComp[1]+sServerDateSep+nComp[2]
			break

		case fmtCLASS_OF:
			if(isNaN(sDate) || (Adjust2kYear(sDate) < 1900)){
				return false
			}else{
				return true
			}

		case fmtDATE_FUZZY:
			var aComp=ParseFuzzyDate(sDate)
			break
	}

	if(nFmt == fmtDATE_FUZZY){
		//if none of the date parts are filled in, then Invalid
		return !((aComp[0] == -1) && (aComp[1] == -1) && (aComp[2] == -1))
	}else{
		if((nComp[iYearIndex].toString()).length > 4){return false}

		if(!ValidNumber(nComp[0],0) || !ValidNumber(nComp[1],0) || !ValidNumber(nComp[2],0)){
				return false
		}

		sNormDate=NormalizeDate(sTemp)

		if(!DateIsValidviaParse(sNormDate)){ return false }
		oDate=DateStringToObject(sTemp)
		sNewDate=NormalizeDate(DateObjectToString(oDate))

		if(sNewDate!=sNormDate){return false}

		return true
	}
}

function DateIsValidviaParse(sNormDate){
	var sTestDate=sNormDate

	//CR320176-060109 ~ GPB Jun-08-2009 ~ Javascript's Date doesn't work with periods ( . ).
	//If a client has a local whose date separator is a period, then we are done to...
	//So change if there are any periods to slashes.
	if (sServerDateSep != "/") 
	{
	    if (sTestDate.indexOf(sServerDateSep) != -1) 
	    {
	        sTestDate = replaceAll(sTestDate, sServerDateSep, "/")
	    }
	}
	
	var iParse=Date.parse(sTestDate)
	if(isNaN(iParse)||(iParse<0)){
		return false
	}else{
		return true
	}

	// abw revisit for FF
	// In FF, Date.parse on a date with "-" seps fails, but succeeds with "/"	
//	var oRegExp=new RegExp('\\'+sServerDateSep,'g');
//	sTestDate=(sNormDate).toString().replace(oRegExp,'-');
//	var iParse=Date.parse(sTestDate)
//	if(isNaN(iParse)||(iParse<0)){
//		return false
//	}else{
//		return true
//	}

}
//CR320176-060109 ~ GPB Jun-08-2009 ~ Javascript's replace method replacement !!!
//The default replace replaces only the first instance of a find. doh...
function replaceAll(text, strA, strB) 
{
    while ( text.indexOf(strA) != -1)
    {
        text = text.replace(strA,strB);
    }
    return text;
}



function ValidDateRange(vDateFrom, vDateTo){
	var sFromValue=new String
	var sToValue=new String

	if(typeof(vDateFrom) == 'object'){
		sFromValue=vDateFrom.value
	}else{
		sFromValue=vDateFrom
	}

	if(typeof(vDateTo) == 'object'){
		sToValue=vDateTo.value
	}else{
		sToValue=vDateTo
	}

	if(sFromValue.length > 0 && sToValue.length > 0){
		if(DateDiff(sFromValue, sToValue) > 0){
			return false;
		}
	}
	return true;
}

function FormatDate(sDate,nFmt){
	if(FormatDate.arguments.length==2){
		switch (nFmt){
			case fmtMMYYYY:
				return FormatMMYYYYDate(sDate)
			case fmtMMDD:
				return FormatMMDDDate(sDate)
			case fmtCLASS_OF:
				if(!isNaN(sDate)){
					return FormatClassOf(sDate)
				}
				return sDate
			case fmtDATE_FUZZY:
				return FormatFuzzyDate(sDate)
			case fmtYYYY:
				return FormatYear(sDate)
		}
	}else{
		nFmt=fmtDATEMDY //default
	}

	if(!ValidDate(sDate, nFmt)){
		return sDate
	}else{
			return DateObjectToString(DateStringToObject(sDate))
	}
}
function FormatMMDDDate(sDate){

	var tempDate=new Date()
	tempDate.setFullYear(1996)	 //Leap Year
	var nComp=new Array(3)

	var nDate=1
	var nMonth=tempDate.getMonth()+1
	var nsDate
	var sRetVal=''
	var iStart=0
	var iLen=0

	DateIndexes()

	if(sDate.indexOf(sServerDateSep) > -1){
		var temp=ParseDate(sDate)
		if(!ValidNumber(temp[iDateIndex],0) || !ValidNumber(temp[iMonthIndex],0)){
			return sDate
		}
		temp[iDateIndex]
		nDate=temp[iDateIndex]
		nMonth=temp[iMonthIndex]
	}else{
		if(!ValidNumber(sDate,0)){
			return sDate
		}else{
			switch (sDate.length){
				case 1: //D
				case 2: //DD
					nDate=1 * rawnum(sDate)
					break

				case 3: //DDM or MDD
					if(iDateIndex < iMonthIndex){
						nDate=1 * rawnum(sDate.substr(0,2))
						nMonth=1 * rawnum(sDate.substr(2,1))
					}else{
						nMonth=1 * rawnum(sDate.substr(0,1))
						nDate=1 * rawnum(sDate.substr(1,2))
					}

					break

				case 4: //DDMM or MMDD
					if(iDateIndex < iMonthIndex){
						nDate=1 * rawnum(sDate.substr(0,2))
						nMonth=1 * rawnum(sDate.substr(2,2))
					}else{
						nMonth=1 * rawnum(sDate.substr(0,2))
						nDate=1 * rawnum(sDate.substr(2,2))
					}

					break
				default:
					return(sDate)
			}
		}
	}


	if(((nMonth.toString()).length == 0) || (nMonth == 0) ||
			((nDate.toString()).length == 0) || (nDate == 0) ){return ''}


	if(nMonth > 12){nMonth=12}

	tempDate.setMonth(nMonth-1)
	if(nDate > LastDayOfMonth(tempDate)){ nDate=1}

	nComp[iDateIndex]=nDate
	nComp[iMonthIndex]=nMonth
	nComp[iYearIndex]=''

	var sDatePart
	var sShortDateFmt=sServerShortDate.toLowerCase()
	var sPreFix
	for (var i=0; i< nComp.length; i++){
		if((nComp[i].toString()).length > 0){
			//sDatePart='00'+nComp[i]
			sPreFix='0'
			if((i == iDateIndex) && (sShortDateFmt.search('dd')!=-1)){
				sPreFix='00'	
			}
			
			if((i == iMonthIndex) && (sShortDateFmt.search('mm')!=-1)){
				sPreFix='00'	
			}
			sDatePart=sPreFix+nComp[i]
			sDatePart=sDatePart.substr(sDatePart.length - 2)
			sRetVal += ((sRetVal.length > 0)?sServerDateSep:'')+sDatePart
		}
	}

	return sRetVal
}

function FormatYear(sDate){
	
	if(ValidDate(sDate, fmtDATEMDY)){
		
		DateIndexes()
		var oDate=DateStringToObject(sDate)
		return oDate.getFullYear()
	}else{
		return sDate
	}

}

function FormatMMYYYYDate(sDate){

	var tempDate=new Date()
	var nYear=tempDate.getFullYear()
	var nComp=new Array(3)

	var nMonth=12
	var nsDate
	var sRetVal=''
	var iStart=0
	var iLen=0

	DateIndexes()


	if(sDate.indexOf(sServerDateSep) > -1){
		var temp=ParseDate(sDate, fmtMMYYYY)
		if(!ValidNumber(temp[0],0) || !ValidNumber(temp[1],0)){
			return sDate
		}

		var arr
		arr=sDate.split('/')

		if(arr.length > 2){
			nMonth=1 * temp[iMonthIndex]
			nYear=1 * temp[iYearIndex]
		}else{
			if(iMonthIndex < iYearIndex){
				nMonth=1 * temp[0]
				nYear=1 * temp[1]
			}else{
				nMonth=1 * temp[1]
				nYear=1 * temp[0]
			}
		}

	}else{
		if(!ValidNumber(sDate,0)){
			return sDate
		}else{
			switch (sDate.length){
				case 1: //M
				case 2: //MM
					nMonth=1 * rawnum(sDate)
					break

				case 3: //MYY or YYM
					if(iMonthIndex < iYearIndex){
						nMonth=1 * rawnum(sDate.substr(0,1))
						nYear=1 * rawnum(sDate.substr(1,2))
					}else{
						nYear=1 * rawnum(sDate.substr(0,2))
						nMonth=1 * rawnum(sDate.substr(2,1))
					}

					break

				case 4: //MMYY YYMM or YYYY
					nsDate=1 * rawnum(sDate)
					if((nsDate > 1980) && (nsDate < 2010)){
						nYear=nsDate
					}else{
						if(iMonthIndex < iYearIndex){
							nMonth=1 * rawnum(sDate.substr(0,2))
							nYear=1 * rawnum(sDate.substr(2,2))
						}else{
							nYear=1 * rawnum(sDate.substr(0,2))
							nMonth=1 * rawnum(sDate.substr(2,2))
						}
					}
					break
				case 5:	//MYYYY or YYYYM
					if(iMonthIndex < iYearIndex){
						nMonth=1 * rawnum(sDate.substr(0,1))
						nYear=1 * rawnum(sDate.substr(1,4))
					}else{
						nYear=1 * rawnum(sDate.substr(0,4))
						nMonth=1 * rawnum(sDate.substr(4,1))
					}
					break
				case 6: //MMYYYY or YYYYMM
					if(iMonthIndex < iYearIndex){
						nMonth=1 * rawnum(sDate.substr(0,2))
						nYear=1 * rawnum(sDate.substr(2,4))
					}else{
						nYear=1 * rawnum(sDate.substr(0,4))
						nMonth=1 * rawnum(sDate.substr(4,2))
					}
					break
				default:
					return(sDate)
			}
		}
	}

	if(((nMonth.toString()).length == 0) || (nMonth ==0) || ((nYear.toString()).length == 0)){return ''}
	if(nMonth > 12){nMonth=12}

	if(nYear < 30){
		nYear += 2000
	}else{
		if(nYear < 100){nYear += 1900}
	}

	nComp[iDateIndex]=''
	nComp[iMonthIndex]=(((nMonth.toString()).length == 1)?'0'+nMonth:nMonth)
	nComp[iYearIndex]=nYear

	for (var i=0; i< nComp.length; i++){
		if((nComp[i].toString()).length > 0){
			sRetVal += ((sRetVal.length > 0)?sServerDateSep:'')+nComp[i]
		}
	}

	return sRetVal
}

function DateDiff(sDate1, sDate2){
	/* returns number of milliseconds between dates (sDate1-sDate2)
		sDate1, sDate2 - Date Strings in server format
	*/
	return ((DateStringToObject(sDate1)).getTime() - (DateStringToObject(sDate2)).getTime())
}

function ObjectDateDiff(oDate1, oDate2){
	/* returns number of milliseconds between dates (sDate1-sDate2)
		sDate1, sDate2 - Date Strings in server format
	*/
	return (oDate1.getTime() - oDate2.getTime())
}

function DateIndexes(){
	switch (sServerDateFormat){
		case 'dmy':
		case 'mdy':
		case 'ymd':
			iDateIndex=sServerDateFormat.indexOf("d")
			iMonthIndex=sServerDateFormat.indexOf("m")
			iYearIndex=sServerDateFormat.indexOf("y")
			break
		default:
			alert ('Date format "'+sServerDateFormat+'" not supported')
			break
	}
}

function DateIndexesF(){
	//fuzzy dates support more than the standard three -- supports all formats, in fact
	var sRegExp=new RegExp("["+sServerDateSep+"]", "g")
	var s=sServerShortDate.toLowerCase()
	var sMask=s.split(sRegExp)
	var sFormat=sMask[0].substr(0,1)+sMask[1].substr(0,1)+sMask[2].substr(0,1)
	iDateIdxF=sFormat.indexOf("d")
	iMonthIdxF=sFormat.indexOf("m")
	iYearIdxF=sFormat.indexOf("y")
}

function TodayDate(){
	return DateObjectToString(new Date())
}

function Now(){
	var dte=new Date()
	var h=dte.getHours()
	var m=dte.getMinutes()
	var s=dte.getSeconds()
	var v=((h>=0 && h<=11) ? sServerAMString : sServerPMString)
	if(!bServer24HourClock && h>11){ h=h-12 }
	return h+sServerTimeSep+m+sServerTimeSep+s+(!bServer24HourClock?' '+v:'')
}

function FormatTime(sTime){
	var sTemp=''

	if(sTime == '0'){return sTemp}

	if(sTime.length!=0){
		var nComp=ParseTime(sTime)
		sTemp=nComp[0]+sServerTimeSep+nComp[1]+' '+nComp[2]
	}

	if(ValidTime(sTemp)){
		return sTemp
	}else{
		return sTime
	}

}

function ValidTime(sTime){

	var bValid=true

	if(sTime.length == 0){
		return bValid
	}

	var nComp=ParseTime(sTime)

	if(bServer24HourClock){
		bValid=bValid && ((1 * nComp[0] >= 0) && (1 * nComp[0] <= 23))
	}else{
		bValid=bValid && ((1 * nComp[0] >= 0) && (1 * nComp[0] <= 12))
		bValid=bValid && ((nComp[2] == sServerAMString) || (nComp[2] == sServerPMString))
	}

	bValid=bValid && ((1 * nComp[1] >= 0) && (1 * nComp[1] <= 59))

	return bValid
}

function ParseTime(sTime){

	var nComp=new Array(3)

	nComp[0]=''	//hours
	nComp[1]=''	//minutes
	nComp[2]=''	//suffix (am/pm)

	var x=TrimSpaces(sTime.toUpperCase())
	var nPtr

	while (true){
		nPtr=x.indexOf(' ')
		if(nPtr!=-1){
			nComp[2]=TrimSpaces(x.substr(nPtr))
			if(nComp[2] == 'A'){
				nComp[2]=sServerAMString
			}else if(nComp[2] == 'P'){
				nComp[2]=sServerPMString
			}
			x=x.substring(0, nPtr)
			break
		}

		nPtr=x.indexOf('A')
		if(nPtr!=-1){
			nComp[2]=sServerAMString
			x=x.substring(0, nPtr)
			break;
		}

		nPtr=x.indexOf('P')
		if(nPtr!=-1){
			nComp[2]=sServerPMString
			x=x.substring(0, nPtr)
			break
		}

		if(sServerAMString!=''){
			nPtr=x.indexOf(sServerAMString)
			if(nPtr!=-1){
				nComp[2]=sServerAMString
				x=x.substring(0, nPtr)
				break
			}
		}

		if(sServerPMString!=''){
			nPtr=x.indexOf(sServerPMString)
			if(nPtr!=-1){
				nComp[2]=sServerPMString
				x=x.substring(0, nPtr)
				break
			}
		}
		break
	}

	nPtr=x.indexOf(sServerTimeSep)
	if(nPtr == -1){
		switch (x.length){
			case 0:
				break;
			case 1:
			case 2:
				nComp[0]=x
				nComp[1]='00'
				break

			case 3:
				nComp[0]=x.charAt(0)
				nComp[1]=x.charAt(1)+x.charAt(2)

				break;

			default:
				nComp[0]=x.charAt(0)+x.charAt(1)
				nComp[1]=x.substr(2)
		}
	}else{
		nComp[0]=x.substring(0, nPtr)
		nComp[1]=x.substr(nPtr+1)
	}

	if((nComp[0].length!=0) && ValidNumber(nComp[0],0)){
		var nTemp=nComp[0] * 1
		if(((nTemp > 12) && (nTemp < 24)) && !bServer24HourClock && (nComp[2].length==0)){
			nComp[0]=nTemp - 12
			nComp[2]=sServerPMString
		}
	}

	if((nComp[2].length == 0) && !bServer24HourClock){
		if(oLibPage.OneOf(1 * x.charAt(0), 0, 1)){
			var n=1 * (x.charAt(0)+x.charAt(1))
		}else{
			var n=1 * (x.charAt(0))
		}
		if((n > 7) && (n < 12) ){
			nComp[2]=sServerAMString
		}else{
			nComp[2]=sServerPMString
		}
	}

	nComp[0] *= 1
	if(bServer24HourClock){
		if((sServerPMString!='') && (nComp[2] == sServerPMString) && (nComp[0] < 12)){
			nComp[0] += 12
		}
		nComp[2]=''
	}

	return nComp

}

function ValidTimeRange(vTimeFrom, vTimeTo){
	var startTime=new String
	var endTime=new String
	var sTime=new Date()
	var eTime=new Date()

	if(typeof(vTimeFrom) == 'object'){
		startTime=vTimeFrom.value
	}else{
		startTime=vTimeFrom
	}

	if(typeof(vTimeTo) == 'object'){
		endTime=vTimeTo.value
	}else{
		endTime=vTimeTo
	}

	if((startTime!='') && (endTime!='')){
		startTime=FormatTime(startTime)
		endTime=FormatTime(endTime)

		if(ValidTime(startTime) && ValidTime(endTime)){
			var arr=ParseTime(startTime)
			if((arr[2] == 'PM') && (arr[0] < 12)){
				arr[0] += 12
			}else if((arr[2] == 'AM') && (arr[0] == 12)){
				arr[0]=0
			}
			sTime.setHours(arr[0], arr[1], 0)

			arr=ParseTime(endTime)
			if((arr[2] == 'PM') && (arr[0] < 12)){
				arr[0] += 12
			}else if((arr[2] == 'AM') && (arr[0] == 12)){
				arr[0]=0
			}
			eTime.setHours(arr[0], arr[1], 0)

			if(sTime > eTime){
				return false
			}
		}
	}
	return true
}

function TrimSpaces(sIn){
	var s=sIn.toString()
	return s.replace(/^[ ]+|[ ]+$/g, '')
}

function DateAddDays(sDate,nNumDays){
	//sDate - Date in Server Format
	//nNumDays - Number of days to add (negative will subtract)

	var oDate=DateStringToObject(sDate)
	var nNewDay=oDate.getDate()+nNumDays
	oDate.setDate(nNewDay)

	return DateObjectToString(oDate)
}

	

function AgeInYears(sDOB,sDOD){
	/*	sDOB=Birth date in server format
		sDOD=Deceased date in server format
		if sDOD is blank, then today's date is used
	*/

	var oDOB
	var oDOD
	var sEndDate

	if(sDOB.length == 0){return ''}
	if(!ValidDate(sDOB, fmtDATE_FUZZY)){return ''}
	if((sDOD.length!=0) && !ValidDate(sDOD, fmtDATE_FUZZY)){return ''}

	oDOB=DateStringToObject(sDOB, fmtDATE_FUZZY)
	sEndDate=(sDOD.length == 0)?TodayDate():sDOD
	oDOD=DateStringToObject(sEndDate, fmtDATE_FUZZY)

	var NumMilliSeconds=(ObjectDateDiff(oDOD, oDOB))

	if(NumMilliSeconds <= 0){return ''}

	var newDate=new Date(NumMilliSeconds)
	var baseDate=new Date(1970, 0, 1)

	var NumYears=newDate.getFullYear()-baseDate.getFullYear()

	//adjust for DOB and DOD on same day not occurring

	var MD_DOB=new Date(1980,oDOB.getMonth(),oDOB.getDate())
	var MD_DOD=new Date(1980,oDOD.getMonth(),oDOD.getDate())

	if(DateDiff(DateObjectToString(MD_DOD),DateObjectToString(MD_DOB)) == 0){NumYears++}

	if(NumYears > 0){
		return NumYears
	}else{
		return ''
	}
}

function DateAdd (sDate, nInterval, nFrequency){
	/*	sDate: date as string
		nInterval: interval to add to get new date
		nFrequency: type of interval being added
	*/

	var tempDate=DateStringToObject(sDate)

	var currYear=tempDate.getFullYear()
	var currMonth=tempDate.getMonth()
	var currDay=tempDate.getDate()

	var bLeapDay=((currMonth==1) && (currDay==29))

	if(nInterval!=0){
		switch(nFrequency){
			case 1:	 //Annually
				tempDate.setFullYear(currYear+nInterval)
				break;

			case 2:	 //Semi-Annually
				tempDate.setMonth(currMonth+(nInterval * 6))
				if(currDay!=tempDate.getDate()){
					//adjust for end of month
					tempDate.setMonth((tempDate.getMonth() - 1))
					tempDate.setDate(LastDayOfMonth(tempDate))
				}
				break;

			case 3:	 // Quarterly
				tempDate.setMonth(currMonth+(nInterval * 3))
				if(currDay!=tempDate.getDate()){
					//adjust for end of month
					tempDate.setMonth((tempDate.getMonth() - 1))
					tempDate.setDate(LastDayOfMonth(tempDate))
				}
				break;

			case 4:		//Bi-Monthly
				tempDate.setMonth(currMonth+(nInterval * 2))
				if(currDay!=tempDate.getDate()){
					//adjust for end of month
					tempDate.setMonth((tempDate.getMonth() - 1))
					tempDate.setDate(LastDayOfMonth(tempDate))
				}
				break;

			case 5:	 //Monthly
				tempDate.setMonth(currMonth+nInterval)
				if(currDay!=tempDate.getDate()){
					//adjust for end of month
					tempDate.setMonth((tempDate.getMonth() - 1))
					tempDate.setDate(LastDayOfMonth(tempDate))
				}
				break;

			case 6:		//Semi Monthly
				if((nInterval+1) % 2 == 0){
					//set the current month and then add half the number of days to the date

					tempDate.setMonth(currMonth+Math.ceil((nInterval-1) / 2))
					if(currDay!=tempDate.getDate()){
						//adjust for end of month
						tempDate.setMonth((tempDate.getMonth() - 1))
						tempDate.setDate(LastDayOfMonth(tempDate))
					}


					var td=new Date(tempDate.getFullYear(),tempDate.getMonth(),1)
					var timeAtFirst=td.getTime()
					td.setMonth(td.getMonth()+1)
					td.setDate(td.getDate()-1)
					var timeAtEnd=td.getTime()

					var halfDay=Math.ceil((timeAtEnd-timeAtFirst)/172800000)	//1000*60*60*24*2
					tempDate.setDate(tempDate.getDate()+halfDay)
				}else{
					tempDate.setMonth(currMonth+Math.floor(nInterval / 2))
					if(currDay!=tempDate.getDate()){
						//adjust for end of month
						tempDate.setMonth((tempDate.getMonth() - 1))
						tempDate.setDate(LastDayOfMonth(tempDate))
					}

				}
				break;

			case 7:		//BiWeekly
				tempDate.setDate(currDay+(nInterval * 14))
				break

			case 8:	 //Weekly
				tempDate.setDate(currDay+(nInterval * 7))
				break

			case 9:		//Daily
				tempDate.setDate(currDay+nInterval)
				break

			default:
				return ''
				break //Irregular
		}

		if(bLeapDay){
			if((tempDate.getMonth()==2) && (tempDate.getDate()==1)){
				tempDate.setDate(tempDate.getDate()-1)
			}

		}
	}

	return DateObjectToString(tempDate)
}

function FormatFuzzyDate(sDate){
	if(sDate.length == 0){return ''}

	var aDate=ParseFuzzyDate(sDate)

	if((aDate[0] == -1) && (aDate[1] == -1) && (aDate[2] == -1)){
		//if none of the date parts are filled in, then Invalid
		return sDate
	}else{
		return BuildFuzzyDate(aDate[iDateIdxF], aDate[iMonthIdxF], aDate[iYearIdxF])
	}
}

function ParseFuzzyDate(sDate){

	var aComp=new Array(-1,-1,-1)
	var j

	if(sDate.length == 0){return aComp}

	DateIndexesF()

	if(false && ValidDate(sDate,fmtDATEMDY)){
		aComp=ParseDate(sDate,fmtDATEMDY)
		aComp[iYearIdxF]=Adjust2kYear(aComp[iYearIdxF])
		return aComp
	}else{
		var sRegExp=new RegExp("["+sServerDateSep+"]", "g")
		var sMask=sServerShortDate.split(sRegExp)

		if(sMask.length!=3){return}

		var sYearMask=sServerShortDate.match(/Y+/gi)[0]
		var sMonthMask=sServerShortDate.match(/M+/gi)[0]
		var sDayMask=sServerShortDate.match(/D+/gi)[0]

		sDate=FixMonthNameToNumber(sDate)
		if(sDate.length > 0){
			sDate=InsertSeparators(sDate)
			if(sDate.length > 0){
				var lParts=new Number
				var lPos=new Array(2)
				var sDateParts=new Array(3)
				var oTempDate=new Date()

				lParts=3 //max
				lPos[0]=sDate.indexOf(sServerDateSep)
				lPos[1]=sDate.lastIndexOf(sServerDateSep)

				if(lPos[0] > 0){
					sDateParts[0]=sDate.substr(0, lPos[0])
					if(lPos[1] > lPos[0]){
						sDateParts[1]=sDate.substr(lPos[0]+1, (lPos[1]-lPos[0]) - 1)
						sDateParts[2]=sDate.substr(lPos[1]+1)
					}else{ //just two parts, assume month & year
						sDateParts[1] =	sDate.substr(lPos[0]+1)
						if(iMonthIdxF > iYearIdxF){
							sMask[0]=sYearMask
							sMask[1]=sMonthMask
						}else{
							sMask[0]=sMonthMask
							sMask[1]=sYearMask
						}
						lParts=2
					}
				}else{ // only one part, either day or year
					sDateParts[0]=sDate
					if(Val(sDateParts[0]) < 0){
						return aComp //invalid
					}

					switch (sDateParts[0].length){
						case 1:
						case 2:
							lParts=0
							if(sDateParts[0].length == 2){ //year
								if(!ValidDayForMonth(sDateParts[0], oTempDate.getMonth()+1, oTempDate.getFullYear())){
									sMask[0]=sYearMask
									lParts=1
								}
							}
							if(lParts == 0){ //day
								if(Val(sDateParts[0]) <= 0){
									return aComp //invalid
								}

								lParts=3
								for (j=0; j < 3; j++){
									switch (sMask[j].substr(0,1).toUpperCase()){
										case "M":
											sDateParts[j]=oTempDate.getMonth()+1
											break
										case "D":
											sDateParts[j]=sDate
											break
										case "Y":
											sDateParts[j]=oTempDate.getFullYear()
											break
									}
								}
							}
							break

						default: //assume year
							sMask[0]=sYearMask
							lParts=1
							break
					}
				}

				for (j=0; j < lParts; j++){
					switch (sMask[j].substr(0,1).toUpperCase()){
						case "M":
							aComp[iMonthIdxF]=Val(sDateParts[j])
							if(aComp[iMonthIdxF] == 0){
								aComp[iMonthIdxF]=-1
							}
							break
						case "D":
							aComp[iDateIdxF]=Val(sDateParts[j])
							if(aComp[iDateIdxF] == 0){
								aComp[iDateIdxF]=-1
							}
							break
						case "Y":
							aComp[iYearIdxF]=Val(sDateParts[j])
							if(aComp[iYearIdxF] < 0 ||(aComp[iYearIdxF]==0 && sDateParts[j].length > 3)){
								aComp[iYearIdxF]=-1
							}else{
								aComp[iYearIdxF]=Adjust2kYear(aComp[iYearIdxF])
							}
							if(aComp[iYearIdxF] > 9999){
								aComp[iYearIdxF]=-1 //invalid - clear fields
								aComp[iMonthIdxF]=-1
								aComp[iDateIdxF]=-1
								return aComp
							}
							break
					}
				}
			}
		}
		return aComp
	}
}

function FixMonthNameToNumber(sDate){
	var sMonth=new String
	var nMonth=new Number
	var sRegExp=new RegExp("","g")

	for (j=0; j < sDate.length; j++){
		if(isNaN(sDate.substr(j,1)) && (sDate.substr(j,1)!=sServerDateSep)){
			sMonth += sDate.substr(j,1)
		}
	}

	if(sMonth.length > 0){
		nMonth=MonthNameToNumber(sMonth)
		if(nMonth > 0){
			sRegExp.compile(sMonth, "g")
			sDate.replace(sRegExp, nMonth)
		}else{
			return ''
		}
	}

	return sDate
}

function InsertSeparators(sDate){

	sDate=TrimSpaces(sDate)

	if(sDate.indexOf(sServerDateSep) >= 0){
		return sDate
	}

	var nTemp=new Array(3)

	switch (sDate.length){
		case 3:
			if(iYearIdxF > iMonthIdxF){
				if(Val(sDate.substr(0, 1)) > 0){ //: m/yy
					sDate=sDate.substr(0, 1)+sServerDateSep+RightStr(sDate, 2)
				}else{	//: yy
					sDate=RightStr(sDate, 2)
				}
			}else{
				if(Val(RightStr(sDate, 1)) > 0){ //: yy/m
					sDate=sDate.substr(0, 2)+sServerDateSep+RightStr(sDate, 1)
				}else{	//: yy
					sDate=sDate.substr(0, 2)
				}
			}
			break

		case 4:
			switch (iMonthIdxF){
				case 0:
					if(sDate.search(/^19|^20/g) == -1){
						if(Val(sDate.substr(0, 2)) <= 12){ //: mm/yy
							sDate=sDate.substr(0, 2)+sServerDateSep+RightStr(sDate, 2)
						}else{
							nTemp[iMonthIdxF]=sDate.substr(0, 1)
							nTemp[iDateIdxF]=(iDateIdxF==1?sDate.substr(1, 1):sDate.substr(3, 1))
							nTemp[iYearIdxF]=(iDateIdxF==1?sDate.substr(2, 2):sDate.substr(1, 2))
							if(ValidDayForMonth(nTemp[iDateIdxF], nTemp[iMonthIdxF], nTemp[iYearIdxF])){
								sDate=nTemp[0]+sServerDateSep+nTemp[1]+sServerDateSep+nTemp[2]
							}
						}
					}
					break
				case 1:
					if(iYearIdxF == 0){
						if((sDate.search(/^19|^20/g) == -1) && (sDate.search(/00$/g) == -1)){
							if(Val(RightStr(sDate, 2)) <= 12){ //: yy/mm
								sDate=sDate.substr(0, 2)+sServerDateSep+RightStr(sDate, 2)
							}else{ //: yy/m/d
								if(ValidDayForMonth(Val(RightStr(sDate, 1)), Val(sDate.substr(2, 1)), Val(sDate.substr(0, 2)))){
									sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 1)+sServerDateSep+RightStr(sDate, 1)
								}
							}
						}
					}else{ //: iYearIdxF == 2
						if(sDate.search(/^19|^20/g) == -1){
							if(Val(sDate.substr(0, 2)) <= 12){ //: mm/yy
								sDate=sDate.substr(0, 2)+sServerDateSep+RightStr(sDate, 2)
							}else{ //: d/m/yy
								if(ValidDayForMonth(Val(sDate.substr(0, 1)), Val(sDate.substr(1, 1)), Val(RightStr(sDate, 2)))){
									sDate=sDate.substr(0, 1)+sServerDateSep+sDate.substr(1, 1)+sServerDateSep+RightStr(sDate, 2)
								}else{
									sDate=''
								}
							}
						}
					}
					break
				case 2:
					if((sDate.search(/^19|^20/g) == -1) && (sDate.search(/00$/g) == -1)){
						if(Val(RightStr(sDate,2)) <= 12){ //: yy/mm
							sDate=sDate.substr(0, 2)+sServerDateSep+RightStr(sDate, 2)
						}else{
							nTemp[iMonthIdxF]=sDate.substr(3, 1)
							nTemp[iDateIdxF]=(iDateIdxF==0?sDate.substr(0, 1):sDate.substr(1, 2)) //: d/yy/m
							nTemp[iYearIdxF]=(iDateIdxF==0?sDate.substr(1, 2):sDate.substr(0, 2)) //: yy/d/m
							if(ValidDayForMonth(nTemp[iDateIdxF], nTemp[iMonthIdxF], nTemp[iYearIdxF])){
								sDate=nTemp[0]+sServerDateSep+nTemp[1]+sServerDateSep+nTemp[2]
							}
						}
					}
					break
			}
			break

		case 5:
			switch (iMonthIdxF){
				case 0:
					if(iDateIdxF == 1){ //: mdy (mm/d/yy || m/dd/yy)
						if(ValidDayForMonth(Val(sDate.substr(2, 1)), Val(sDate.substr(0, 2)), Val(RightStr(sDate, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 1)+sServerDateSep+RightStr(sDate, 2)
						}else if(ValidDayForMonth(Val(sDate.substr(1, 2)), Val(sDate.substr(0, 1)), Val(RightStr(sDate, 2)))){
							sDate=sDate.substr(0, 1)+sServerDateSep+sDate.substr(1, 2)+sServerDateSep+RightStr(sDate, 2)
						}else{
							sDate=''
						}
					}else{ //: myd (mm/yy/d || m/yy/dd)
						if(ValidDayForMonth(Val(RightStr(sDate, 1)), Val(sDate.substr(0, 2)), Val(sDate.substr(2, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 2)+sServerDateSep+RightStr(sDate, 1)
						}else if(ValidDayForMonth(Val(RightStr(sDate, 2)), Val(sDate.substr(0, 1)), Val(sDate.substr(1, 2)))){
							sDate=sDate.substr(0, 1)+sServerDateSep+sDate.substr(1, 2)+sServerDateSep+RightStr(sDate, 2)
						}else{
							sDate=''
						}
					}
					break

				case 1:
					if(iDateIdxF == 0){ //: dmy (dd/m/yy || d/mm/yy)
						if(ValidDayForMonth(Val(sDate.substr(0, 2)), Val(sDate.substr(2, 1)), Val(RightStr(sDate, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 1)+sServerDateSep+RightStr(sDate, 2)
						}else if(ValidDayForMonth(Val(sDate.substr(0, 1)), Val(sDate.substr(1, 2)), Val(RightStr(sDate, 2)))){
							sDate=sDate.substr(0, 1)+sServerDateSep+sDate.substr(1, 2)+sServerDateSep+RightStr(sDate, 2)
						}else{
							sDate=''
						}
					}else{ //: ymd (yy/mm/d || yy/m/dd)
						if(ValidDayForMonth(Val(RightStr(sDate, 1)), Val(sDate.substr(2, 2)), Val(sDate.substr(0, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 2)+sServerDateSep+RightStr(sDate, 1)
						}else if(ValidDayForMonth(Val(RightStr(sDate, 2)), Val(sDate.substr(2, 1)), Val(sDate.substr(0, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 1)+sServerDateSep+RightStr(sDate, 2)
						}else{
							sDate=''
						}
					}
					break

				case 2:
					if(iDateIdxF == 0){ //: dym (d/yy/mm || dd/yy/m)
						if(ValidDayForMonth(Val(sDate.substr(0, 1)), Val(RightStr(sDate, 2)), Val(sDate.substr(1, 2)))){
							sDate=sDate.substr(0, 1)+sServerDateSep+sDate.substr(1, 2)+sServerDateSep+RightStr(sDate, 2)
						}else if(ValidDayForMonth(Val(sDate.substr(0, 2)), Val(RightStr(sDate, 1)), Val(sDate.substr(2, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 2)+sServerDateSep+RightStr(sDate, 1)
						}else{
							sDate=''
						}
					}else{ //: ydm (yy/d/mm || yy/dd/m)
						if(ValidDayForMonth(Val(sDate.substr(2, 1)), Val(RightStr(sDate, 2)), Val(sDate.substr(0, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 1)+sServerDateSep+RightStr(sDate, 2)
						}else if(ValidDayForMonth(Val(sDate.substr(2, 2)), Val(RightStr(sDate, 1)), Val(sDate.substr(0, 2)))){
							sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 2)+sServerDateSep+RightStr(sDate, 1)
						}else{
							sDate=''
						}
					}
					break
			}
			break

		case 7:
			if(Val(sDate.substr(0, 1)) == 0){
				sDate=sDate.substr(1) // trim then fall into case 6
			}else{
				break
			}

		case 6:
			if(ValidDayForMonth(Val(sDate.substr((2 * iDateIdxF), 2)), Val(sDate.substr((2 * iMonthIdxF), 2)), Val(sDate.substr((2 * iYearIdxF), 2)))){
				//Valid date, so insert separators
				sDate=sDate.substr(0, 2)+sServerDateSep+sDate.substr(2, 2)+sServerDateSep+RightStr(sDate, 2)
			}else{
				sDate=''
			}
			break

		case 8:
			nTemp[iYearIdxF]=sDate.substr((2 * iYearIdxF), 4)
			switch (iYearIdxF){
				case 0: // yyyy/dd/mm || yyyy/mm/dd
					nTemp[iMonthIdxF]=(iDateIdxF==1?sDate.substr(6, 2):sDate.substr(4, 2))
					nTemp[iDateIdxF]=(iDateIdxF==1?sDate.substr(4, 2):sDate.substr(6, 2))
					break
				case 1: // dd/yyyy/mm || mm/yyyy/dd
					nTemp[iMonthIdxF]=(iDateIdxF==0?sDate.substr(6, 2):sDate.substr(0, 2))
					nTemp[iDateIdxF]=(iDateIdxF==0?sDate.substr(0, 2):sDate.substr(6, 2))
					break
				case 2: // dd/mm/yyyy || mm/dd/yyyy
					nTemp[iMonthIdxF]=(iDateIdxF==0?sDate.substr(2, 2):sDate.substr(0, 2))
					nTemp[iDateIdxF]=(iDateIdxF==0?sDate.substr(0, 2):sDate.substr(2, 2))
					break
			}
			if(ValidDayForMonth(Val(nTemp[iDateIdxF]), Val(nTemp[iMonthIdxF]), Val(nTemp[iYearIdxF]))){
				sDate=nTemp[0]+sServerDateSep+nTemp[1]+sServerDateSep+nTemp[2]
			}else{
				sDate=''
			}

			break

	}

	return sDate
}

function BuildFuzzyDate(nDay, nMonth, nYear){

	//parameters:	must be numbers
	//				nYear must be full year format

	nDay=parseInt(nDay)
	nMonth=parseInt(nMonth)
	nYear=parseInt(nYear)

	if(isNaN(nDay) || isNaN(nMonth) || isNaN(nYear)){return ''}

	//sServerDateSep
	//sServerShortDate

	var aMask
	var sDate=new String
	var sRegExp=new RegExp("["+sServerDateSep+"]", "g")
	var nTemp=new Number
	var sTemp=new String

	aMask=sServerShortDate.split(sRegExp)
	if(aMask.length!=3){return ''}

	for (var j=0; j<3; j++){
		switch (aMask[j].substr(0,1).toUpperCase()){
			case "Y":
				if(nYear > 0){
					if(sDate.length > 0){
						sDate += sServerDateSep
					}
					switch (aMask[j].length){
						case 2:
							if((nYear < 1930 || nYear > 1999) || (nMonth < 1 && nDay < 1)){
								if(nYear.toString().length < 4){
									nYear=Adjust2kYear(nYear)
								}
								sDate += nYear.toString()
							}else{
								sDate += nYear.toString().substr(2)
							}
							break
						default:
							sDate += nYear.toString()
					}
				}
				break

			case "M":
				if(nMonth > 0 && nMonth < 13){
					if(sDate.length > 0){
						sDate += sServerDateSep
					}
					switch (aMask[j].length){
						case 1:
							sDate += nMonth.toString()
							break

						case 2:
							nTemp=100+nMonth
							sTemp=nTemp.toString()
							sDate += sTemp.substr(sTemp.length - 2)
							break

						case 3:
							sDate += MonthName(nMonth, true)
							break

						default:
							sDate += MonthName(nMonth, false)
							break
					}
				}
				break

			case "D":
				if(nDay > 0){
					if(sDate.length > 0){
						sDate += sServerDateSep
					}
					if(aMask[j].length == 1){
						sDate += nDay.toString()
					}else{
						nTemp=100+nDay
						sTemp=nTemp.toString()
						sDate += sTemp.substr(sTemp.length - 2)
					}
				}
				break
		}
	}
	return sDate

}

function ValidFuzzyDateRange(fieldFrom, fieldTo){
	var sDateFrom=fieldFrom.value
	var sDateTo=fieldTo.value

	if((sDateFrom.length > 0) && (sDateTo.length > 0)){
		var oNow=new Date()
		var sDate=''
		sDateFrom=NormalizeFuzzyDate(sDateFrom)
		sDateTo=NormalizeFuzzyDate(sDateTo)

		return ValidDateRange(sDateFrom, sDateTo)
	}
	return true
}

function NormalizeFuzzyDate(sDate){
	var oNow=new Date()
	var aComp=ParseFuzzyDate(sDate)
	var bRebuild=false
	if(aComp[iYearIdxF]==-1){ aComp[iYearIdxF]=oNow.getFullYear(); bRebuild=true }
	if(aComp[iMonthIdxF]==-1){ aComp[iMonthIdxF]=1; bRebuild=true }
	if(aComp[iDateIdxF]==-1){ aComp[iDateIdxF]=1; bRebuild=true }
	if(bRebuild){
		sDate=BuildFuzzyDate(aComp[iDateIdxF], aComp[iMonthIdxF], aComp[iYearIdxF])
	}
	return sDate
}

var oMonths=[['',''],['Jan','January'],['Feb','February'],['Mar','March'],['Apr','April'],['May','May'],['Jun','June'],['Jul','July'],['Aug','August'],['Sep','September'],['Oct','October'],['Nov','November'],['Dec','December']]

function MonthName(nMonth, bAbbrev){
	var oMonth=oMonths[nMonth]
	return (oMonth?oMonth[bAbbrev?0:1]:'')
}


function MonthNameToNumber(sMonth){
	var s=new String
	var sRegExp=new RegExp("", "g")

	sMonth=sMonth.toUpperCase()

	//try to match as much as we have
	for (var j=1; j <= 12; j++){
		s=MonthName(j, false)
		s=s.toUpperCase()
		if(s.substr(0, sMonth.length) == sMonth){
			return j
		}
	}

	//try pattern match using abbreviations for the month names
	for (j=0; j < 12; j++){
		s=MonthName(j, true)
		sRegExp.compile("^"+s, "gi") //check for name at beginning of user string
		if(sMonth.search(sRegExp) > -1){
			return j
		}
	}
	return -1
}

function ValidDayForMonth(nDate, nMonth, nYear){
	nDate=Val(nDate)
	nMonth=Val(nMonth)
	nYear=Val(nYear)

	if((nDate <= 0) || (nDate > 31) || (nMonth < 1) || (nMonth > 12)){
		return false
	}

	nYear=Adjust2kYear(nYear)
	var oDate=new Date(nYear, nMonth - 1, 1)
	var nLastDay=LastDayOfMonth(oDate)
	return (nDate <= nLastDay)
}