//isDate(date)							**Check date format (e.g DD/MM/YYYY)
//compareDate(objDateFrom, objDateTo, objDate)			**Compare 2 different date - must between the range
//isNumber(number,length,precision)				**Validate for numeric value
//round_decimals(original_number, decimals)			**Round number to decimal
//convert_currency(number,decimals)				**Convert to currency (e.g 12,888.56)
//trim(string)							**Trim the string
//leftTrim(string)						**Left trim
//rightTrim(string)						**Right trim
//left(string,intlength)					**Number of length from left 
//right(string,intlength)					**Number of length from right
//isEmpty(estr)							**Validate the empty string
//underline_Enable(obj)						**Draw a line within the string
//underline_Disable(obj)					**Remove the line within the string 
//trap_key()							**Press enter will move to next line(like tab)
//URLEncoding(val)						**Encode the URL string
//HTMLEncoding(val)						**Encode the HTML string
//_dataChange()							**Check for data change before on blur
//upperCase(string) 						**Change all string to UpperCase
//isValidEmail(string)						**Check for valid email address (e.g abc@xyz.com)
//isInteger(num)						**Check for integer value only not allow negative / positive sign
//formReset(theForm, theName)					**Reset the form
//addZero(vNumber)						**Add zero(0) for those number less than 10 (e.g 01,02,03,04,05,06,07,08,09) -make to 2 digit
//getShortMonth()						**Get the month in 3 aphabet (e.g. Jan, Feb, Mar, Apr..) 
//getFullMonth()						**Get the month in full sentence (e.g January, February, March...)
//replace_quote(s)						**Replace quote
//MyDate()	
//isValidTime							**check for valid time format HH:MM
//js_encode_single_quote					**encode single quote using escape
//removeComma(inputValue)					**remove common

//---------------------------------------isDate(a)---------------------------------------
function isDate(a)
{

	a=trim(a)	
	var err=0;

	if (a.length != 10) err=1;

	b = a.substring(0, 2);  // day
	c = a.substring(2, 3);  // '/'
	d = a.substring(3, 5);  // month
	e = a.substring(5, 6);  // '/'
	f = a.substring(6, 10); // year

	//basic error checking
	if (b<1 || b>31) err = 1;
	if (c != '/') err = 1;
	if (d<1 || d>12) err = 1;
	if (e != '/') err = 1;
	if (f<0000 || f>9999) err = 1;
	if (isNaN(b)) err = 1;
	if (isNaN(d)) err = 1;
	if (isNaN(f)) err = 1;

	//advanced error checking
	// months with 30 days
	if (d==4 || d==6 || d==9 || d==11)
	{
		if (b==31) err=1;
	}

	// february, leap year
	if (d==2)
	{
		var g=parseInt(f/4);

		if (isNaN(g)) err=1;
		if (b>29) err=1;
		if (b==29 && ((f/4)!=parseInt(f/4))) err=1;
	}

	if (err==1)	return false;
	else return true;
}
//---------------------------------------------------------------------------------------


//--------------------compareDate(objDateFrom, objDateTo, objDate)-----------------------
function compareDate(objDateFrom, objDateTo, objDate){

	//if (checkDate(objDate.value)==false)
		//return;
		
	var strDateFrom=objDateFrom.value;
	var strDateTo=objDateTo.value;
	
	if (strDateFrom==null || strDateFrom ==""||strDateTo==null || strDateTo ==""){
		return;
	}

	var arrayDate;
	var datDateFrom;
	var datDateTo;
	var datTemp=new Date();
	
	arrayDate=strDateFrom.split("/");

	if (arrayDate.length != 3)
		return;

	datDateFrom= new Date(arrayDate[2], arrayDate[1]-1, arrayDate[0]);

	arrayDate=strDateTo.split("/");

	if (arrayDate.length != 3)
		return;

	datDateTo= new Date(arrayDate[2], arrayDate[1]-1, arrayDate[0]);

	if(datDateTo.getTime() - datDateFrom.getTime() <0 ){
		alert("Date From must not later than Date To")
		objDate.value="";
		objDate.focus();
	}
	
}
//---------------------------------------------------------------------------------------


//--------------------checkExpireDate(objToday, objExpDate)-----------------------
function checkExpireDate(objToday, objExpDate){
		
	var strDateFrom=objToday;
	var strDateTo=objExpDate;
	
	if (strDateFrom==null || strDateFrom ==""||strDateTo==null || strDateTo ==""){
		return false;
	}

	var arrayDate;
	var datDateFrom;
	var datDateTo;
	var datTemp=new Date();

	arrayDate=strDateFrom.split("/");

	if (arrayDate.length != 3)
		return;

	datDateFrom= new Date(arrayDate[2], arrayDate[1]-1, arrayDate[0]);

	arrayDate=strDateTo.split("/");

	if (arrayDate.length != 3)
		return;
		
	

	datDateTo= new Date(arrayDate[2], arrayDate[1]-1, arrayDate[0]);
	
	if(datDateTo.getTime() - datDateFrom.getTime() <0 ){
		return false;
	}
}
//---------------------------------------------------------------------------------------


//------------------isNumber(number,number_length,number_precision)----------------------
function isNumber(number,number_length,number_precision)
{
	var foundPosition = number.indexOf(".");
	var xArray = number.split(".");

	if (!(isNaN(number)))
	{
		if (foundPosition == -1)
		{
			if (number.length > number_length)
				return false;
			else
				return true;
		}
		else
		{
			if (xArray[0].length > number_length | xArray[1].length > number_precision)
				return false;
			else
				return true;
		}
	}
	else
		return false;
}
//---------------------------------------------------------------------------------------


//--------------------------------round_decimals(numChar, noOfDec)-----------------------

function round_decimals(numChar, noOfDec)
{
  if(numChar == ''){
  return '0.00';}
  
  if(!isInteger(noOfDec))  return Number.NaN;
  if(noOfDec>10 || noOfDec<0)  return Number.NaN;
  
  return parseFloat(numChar).toFixed(noOfDec);
}

//---------------------------------------------------------------------------------------


//--------------------convert_currency(number,decimals)----------------------------------
function convert_currency(number,decimals)
{

	number = round_decimals(number,decimals)

	var foundPosition = number.indexOf(".");
	var xArray = number.split(".");

	if (!(isNaN(number)))
	{
		if (foundPosition == -1)
			return format_number(number);
		else{
			xArray[0] = format_number(parseInt(xArray[0]))
			if(number>=0)
				return xArray.join('.');
			else if(parseInt(xArray[0])==0)
				return '-' + xArray.join('.');
			else
				return xArray.join('.');			}
	}
	else
		return "NaN.00";
}
//---------------------------------------------------------------------------------------



//---------------------------------trim(strString)---------------------------------------
function trim(strString)
{
	if(strString==null)
	  return (null);

	return rightTrim(leftTrim(strString));
}
//---------------------------------------------------------------------------------------


//--------------------------------leftTrim(strString)------------------------------------
function leftTrim(strString)
{

	if(strString==null)
	  return (null);

	var i;
	var intLength=strString.length;

	for (i=0; i<strString.length; i++)
	{
	  if(strString.charAt(i)!=" " && strString.charAt(i)!="\t" && strString.charAt(i)!="\r" && strString.charAt(i)!="\f" && strString.charAt(i)!="\n")
	    break;
	}

	return right(strString, intLength-i);
}
//---------------------------------------------------------------------------------------


//--------------------------------rightTrim(strString)-----------------------------------
function rightTrim(strString)
{
	var i;
	if (strString==null)
	  return (null);

	for(i=strString.length-1; i>=0; i--)
	{
	  if(strString.charAt(i)!=" " && strString.charAt(i)!="\t" && strString.charAt(i)!="\r" && strString.charAt(i)!="\f" && strString.charAt(i)!="\n")
	    break;
	}
	return left(strString, i+1);
}
//---------------------------------------------------------------------------------------


//--------------------------------left(strString, intLength)-----------------------------
function left(strString, intLength)
{
	if(strString==null)
	  return (null);

	if(intLength>strString.length)
	  intLength=strString.length;

	return strString.substr(0, intLength);
}
//---------------------------------------------------------------------------------------


//--------------------------------Right(strString, intLength)----------------------------
function right(strString, intLength)
{
	if(strString==null)
	  return (null);

	if(intLength>strString.length)
	  intLength=strString.length;

	return strString.substr(strString.length-intLength);
}
//---------------------------------------------------------------------------------------


//-----------------------------------isEmpty(estr)---------------------------------------
function isEmpty(estr)
{
	estr = trim(estr);
	return ((estr == null) || (estr.length == 0));
}
//---------------------------------------------------------------------------------------


//------------------------------underline_Enable(obj)------------------------------------
function underline_Enable(obj)
{
	obj.style.textDecorationUnderline = true;
}
//---------------------------------------------------------------------------------------


//------------------------------underline_Disable(obj)-----------------------------------
function underline_Disable(obj)
{
	obj.style.textDecorationUnderline = false;
}
//---------------------------------------------------------------------------------------


//------------------------------------trap_key()-----------------------------------------
function trap_key()
{
	if (event.keyCode == 13) event.keyCode = 9;
}
//---------------------------------------------------------------------------------------


//------------------------------------trap_key()-----------------------------------------
function URLEncoding(inputValue)
{
	inputValue=escape(inputValue);
	re = /\+/gi;
	return inputValue.replace(re, "%2B");
}
//---------------------------------------------------------------------------------------


//---------------------------------HTMLEncoding(inputValue)------------------------------
function HTMLEncoding(inputValue)
{
	re = /\</gi;
	return inputValue.replace(re, "&lt;");
}
//---------------------------------------------------------------------------------------


//------------------------------------_dataChange()--------------------------------------
function _dataChange()
{

	var myObj=new Object();
	var initValue="";

	function captureData(){
	initValue=event.srcElement.value;
	}


	function isChange()
	{
		return initValue!=event.srcElement.value;
	}

	function getInitValue()
	{
		return initValue;
	}


	myObj.captureData=captureData;
	myObj.isChange=isChange;
	myObj.getInitValue=getInitValue;
	return myObj;

}
var dataChange = new _dataChange();

//---------------------------------------------------------------------------------------


//------------------------------------upperCase(theObj)----------------------------------
function upperCase(theObj)
{
	theObj.value=theObj.value.toUpperCase();
}
//---------------------------------------------------------------------------------------


//------------------------------------isValidEmail(strValue)-----------------------------
function isValidEmail(strValue) 
{ 
	var reg_exp =/\w[\w\.\-]*\w*@[\w\.\-]*\w\.[a-z]{2,3}/i;

	if (reg_exp.test(strValue))	return true; 
	else return false;
}
//---------------------------------------------------------------------------------------


//------------------------------------isInteger(strInteger)------------------------------
function isInteger(strInteger)
{
	strInteger="" + strInteger;
	if(strInteger==null || strInteger=="")
	  return false;

	strInteger=trim(strInteger);

	var strIntegerPat1=/^(-)?(\d+)(\.0+)?$/;
	var strIntegerPat2=/^(-)?(\d{1,3},)?(\d{3},)*(\d{3})(\.0+)?$/;
	return (strIntegerPat1.test(strInteger) || strIntegerPat2.test(strInteger));
}
//---------------------------------------------------------------------------------------



//----------------------------------formReset(theForm, theName)--------------------------
function formReset(theForm, theName){
	theForm.reset();
	eval("theForm." + theName + ".focus()");
}
//---------------------------------------------------------------------------------------



//-------------------------------------addZero(vNumber)----------------------------------
function addZero(vNumber){ 
return ((vNumber < 10) ? "0" : "") + vNumber;
} 
//---------------------------------------------------------------------------------------


//-------------------------------------getShortMonth()-----------------------------------
Date.prototype.getShortMonth=getShortMonth;
Date.prototype.getFullMonth=getFullMonth;
function getShortMonth(){
var intMonth=this.getMonth();
var arrayShortMonth=new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
return arrayShortMonth[intMonth];
}
//---------------------------------------------------------------------------------------


//--------------------------------------getFullMonth()-----------------------------------
function getFullMonth(){
var intMonth=this.getMonth();
var arrayFullMonth=new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
return arrayFullMonth[intMonth];
}

//---------------------------------------------------------------------------------------
//--------------------------------------removeComma(s)---------------------------------
function removeComma(inputValue)
{
re = /,/gi;
return inputValue.replace(re, "");
}
//---------------------------------------------------------------------------------------

//--------------------------------------replace_quote(s)---------------------------------
function replace_quote(s)
{
	var x =	s.split('"');
	var r = '';		

	for (var i = 0; i < x.length; i++) {
		if ( i == (x.length - 1))
			r += x[i];
		else
			r += x[i] + '&quot;';			
	}

	return r;	
}
//---------------------------------------------------------------------------------------


//-----------------------------------MoveHScroller(obj, intPos)--------------------------
function MoveHScroller(obj, intPos){
	
	if (event.keyCode == 13) obj.scrollLeft = intPos;
}
//---------------------------------------------------------------------------------------



//-----------------------------------function MyDate()-----------------------------------

function MyDate()
{

var myObj=new Object();

var strDay;
var strMonth;
var strYear;
var strSeparator;

var strMonthName=new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
var intTotalMonthDays=new Array(31,28,31,30,31,30,31,31,30,31,30,31);
var intMonthNameIndex;

var boolInputError=false;
var MyDateArgument=arguments;
var datDate;

//--------------------------------IniMyDate()-------------------
function IniMyDate()
{

var strDateFormat;
var strDate;

if(MyDateArgument.length==0)  
  return false;
else if(MyDateArgument.length==2)
{
  strDateFormat=Trim(MyDateArgument[0]);
  strDate=Trim(MyDateArgument[1]);
}
else if(MyDateArgument.length==4)
{
  strDateFormat=trim(MyDateArgument[0]);
  strDate=MyDateArgument[1] + "/" + MyDateArgument[2] + "/" + MyDateArgument[3];
}
else
{
  alert("DEBUGER: Undefined function arguments!")
  return false;
}

var dateFormatPat=/^([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})$/;
var arrayDateFormatMatch=strDateFormat.match(dateFormatPat);
var intDayIndex=0;
var intMonthIndex=0;
var intYearIndex=0;
var i;

if(arrayDateFormatMatch)
{
  for (i=1; i<arrayDateFormatMatch.length; i++)
  {
    if(arrayDateFormatMatch[i]=="d")
      intDayIndex=i;
    else if(arrayDateFormatMatch[i]=="y")
      intYearIndex=i;
    else if(arrayDateFormatMatch[i]=="m")
      intMonthIndex=i;
  }
}
else
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return false;
}

if(!(intDayIndex && intMonthIndex && intYearIndex))
{
  alert("DEBUGER: Undefined date format is provided!")
  return false;
}


var datePat=/^(\w*)\/(\w*)\/(\w*)$/;
var arrayDateMatch=strDate.match(datePat);

if(!arrayDateMatch)
{
  datePat=/^(\w*)-(\w*)-(\w*)$/;
  arrayDateMatch=strDate.match(datePat);
  
  if(!arrayDateMatch)
    return false;
}
 


strDay=arrayDateMatch[intDayIndex];
strMonth=arrayDateMatch[intMonthIndex];
strYear=arrayDateMatch[intYearIndex];
strSeparator=arrayDateMatch[2]

var dayPat=/^(\d{1,2})$/;
if(!dayPat.test(strDay))  return false;

var yearPat=/^(\d{4})$/;
//if(!yearPat.test(strYear)|| parseInt(strYear)<1970 )  return false;
if(!yearPat.test(strYear))  return false;


var boolMatch=false;

var monthPat=/^(\d{1,2})$/;
if(monthPat.test(strMonth))
{
  if(parseInt(strMonth)>12)  return false;
  intMonthNameIndex=parseInt(strMonth)-1;
}
else
{
  strMonth=strMonth.toLowerCase()
  strMonth=left(strMonth,1).toUpperCase() + right(strMonth, strMonth.length-1);

  for(i=0; i<12; i++)
  {
    if(strMonth==strMonthName[i] || strMonth==left(strMonthName[i],3)) 
    {
      intMonthNameIndex=i;
      boolMatch=true;
      break;  
    } 
  }

  if(!boolMatch) 
  {
    return false;
  }  

}



intTotalMonthDays[1]=((parseInt(strYear)%400==0)||((parseInt(strYear)%4==0)&&(parseInt(strYear)%100!=0))) ? 29:28;

if (parseInt(strDay)>parseInt(intTotalMonthDays[intMonthNameIndex])) return false;

datDate=new Date(strYear, intMonthNameIndex, strDay);
return true;
}

if(!IniMyDate()) boolInputError=true;

function Is4DigitYear()
{
if(boolInputError) return false;

var yearPat=/^(\d{4})$/;

if(yearPat.test(strYear))
  return true;
else
  return false;
}

//--------------------------------IsDate()-------------------
function IsDate()
{

if(boolInputError) return false;

return true;
}

//--------------------------------FormatDate()-------------------
function FormatDate()
{
if(boolInputError) return "Format Date: Error";

if(!(arguments.length==1 || arguments.length==2))
{
  alert("DEBUGER: Undefined function arguments!")
  return "Format Date: Error";
}

var dateFormatPat=/^([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})$/;
var arrayDateFormatMatch=arguments[0].match(dateFormatPat);
var arrayStrSeq=new Array();
var strSeparator2;
var i;

if (arguments[1])
  strSeparator2=arguments[1];
else  
 strSeparator2=strSeparator;

var strMonthType;
var strDayType;
var boolDay=false;
var boolMonth=false;
var boolYear=false;

if(arrayDateFormatMatch)
{
  for (i=1; i<arrayDateFormatMatch.length; i++)
  {
    if(arrayDateFormatMatch[i]=="d" || arrayDateFormatMatch[i]=="dd")
    { 
      boolDay=true;
      strDayType=arrayDateFormatMatch[i];
      arrayStrSeq[arrayStrSeq.length]="strDay2";
    }
    else if(arrayDateFormatMatch[i]=="y")
    {
      boolYear=true;
      arrayStrSeq[arrayStrSeq.length]="strYear";
    }
    else if(arrayDateFormatMatch[i]=="m" || arrayDateFormatMatch[i]=="mm" ||arrayDateFormatMatch[i]=="M" || arrayDateFormatMatch[i]=="MM" )
    {
      boolMonth=true;
      arrayStrSeq[arrayStrSeq.length]="strMonth2";
      strMonthType=arrayDateFormatMatch[i];
    } 
  }
}
else
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return "Format Date: Error";
}

if(!(boolDay && boolMonth && boolYear))
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return "Format Date: Error";
}

var strMonth2;
if(strMonthType=="m")
  strMonth2="" + eval(intMonthNameIndex+1);
else if(strMonthType=="mm")
  strMonth2=right("0" + eval(intMonthNameIndex+1),2);
else if(strMonthType=="M")
  strMonth2=left(strMonthName[intMonthNameIndex],3);
else
  strMonth2=strMonthName[intMonthNameIndex];

var strDay2;
if(strDayType=="d")
  strDay2="" + strDay;
else if(strDayType=="dd")
  strDay2=right("0" + strDay, 2);

return eval(arrayStrSeq[0] + "+strSeparator2+" + arrayStrSeq[1] + "+strSeparator2+" + arrayStrSeq[2]);

}

//--------------------------------AddDay()-------------------

function AddDay()
{

if(!(arguments.length==2 || arguments.length==3))
{
  alert("DEBUGER: Undefined function arguments!")
  return "AddDay: Error"
}

var strDateFormat=arguments[0];
var strAddDay=arguments[1];


var intdayPat=/^(\d+)$/;
if(!intdayPat.test(strAddDay) || boolInputError) return "AddDay: Error";

var datTemp=new Date();
datTemp.setTime(datDate.getTime() + parseInt(strAddDay)*86400000)

strDay="" + datTemp.getDate();
intMonthNameIndex=datTemp.getMonth();
strYear=datTemp.getFullYear();
if(strYear<1000) strYear += 1900;

strYear=""+strYear;
var strAddDay;
if(arguments[2])
  strAddDay=FormatDate(strDateFormat, arguments[2])
else
  strAddDay=FormatDate(strDateFormat)

strDay="" + datDate.getDate();
intMonthNameIndex=datDate.getMonth();
strYear=datDate.getFullYear();
if (strYear<1000)  strYear+=1900;
strYear="" + strYear;
if (strAddDay.indexOf("Error")==-1)
 return strAddDay;
else
 return "AddDay: Error";

}

//--------------------------------GetTime()-------------------
function GetTime()
{
if(boolInputError)
{
  alert("Get Time: Error");
  return Number.NaN;
}
else
  return datDate.getTime();
}


myObj.IsDate=IsDate;
myObj.Is4DigitYear=Is4DigitYear;
myObj.FormatDate=FormatDate;
myObj.AddDay=AddDay;
myObj.GetTime=GetTime;

return myObj;

}

//------------------------------------------------------------------------------------


//-----------------------------isValidTime(strValue)-(HH:MM)--------------------------
/*function isValidTime(strValue) 
{ 
	var reg_exp =/(\d\d):(\d\d)/;

	if (reg_exp.test(strValue))	return true; 
	else return false;
}*/

function isValidTime(strTime){
 

if(strTime.length!=5)
 return false;
 
var arrayTime = strTime.split(":");
 
if (arrayTime.length!=2)
 return false;
 
var strHour=arrayTime[0]
var strMinute=arrayTime[1]
 
if(strHour.length!=2)
 return false;
 
if(strMinute.length!=2)
 return false;
 

if(!isInteger(strHour)||!isInteger(strMinute))
 return false;
 
if(parseInt(strHour)<0||parseInt(strHour)>23 )
 return false;
 

if(parseInt(strMinute)<0||parseInt(strMinute)>59 )
 return false;
 

return true;

}

//------------------------------------------------------------------------------------

//--------------------------------------js_encode_single_quote(s)---------------------------------
function js_encode_single_quote(s)
{
	var x =	s.split("'");
	var r = '';		

	for (var i = 0; i < x.length; i++) {
		if ( i == (x.length - 1))
			r += x[i];
		else
			r += x[i] + "\\'";			
	}

	return r;	
}
//---------------------------------------------------------------------------------------



//------------------DateAdd(startDate, numDays, numMonths, numYears))--------------------
function DateAdd(startDate, numDays, numMonths, numYears)
	{
		var returnDate = new Date(startDate.toLocaleString());
		
		var yearsToAdd = numYears;
		
		var month = returnDate.getMonth()+ numMonths;
		if (month > 11)
		{
			yearsToAdd = Math.floor((month+1)/12);
			month -= 12*yearsToAdd;
			yearsToAdd += numYears;
		}
		returnDate.setMonth(month);
		returnDate.setFullYear(returnDate.getFullYear()	+ yearsToAdd);
		
		returnDate.setTime(returnDate.getTime()+60000*60*24*numDays);
		
		return returnDate;

	}
	
//---------------------------------------------------------------------------------------

//------------------DateMinus(startDate, numDays, numMonths, numYears)------------------
	function DateMinus(startDate, numDays, numMonths, numYears)
	{
		var returnDate = new Date(startDate.toLocaleString());
		var yearsToAdd = numYears;
		
		var month = returnDate.getMonth()- numMonths;
		if (month > 11)
		{
			yearsToAdd = Math.floor((month+1)/12);
			month -= 12*yearsToAdd;
			yearsToAdd -= numYears;
		}
		returnDate.setMonth(month);
		returnDate.setFullYear(returnDate.getFullYear()	- yearsToAdd);
		
		//returnDate.setTime(returnDate.getTime()+60000*60*24*numDays);
		
		return returnDate;

	}
//---------------------------------------------------------------------------------------
	
//--------------------------YearAdd(startDate, numYears)---------------------------------
	function YearAdd(startDate, numYears)
	{
			return DateAdd(startDate,0,0,numYears);
	}
//---------------------------------------------------------------------------------------

//--------------------------MonthAdd(startDate, numMonths)-------------------------------
	function MonthAdd(startDate, numMonths)
	{
			return DateAdd(startDate,0,numMonths,0);
	}
//---------------------------------------------------------------------------------------

//-----------------------------DayAdd(startDate, numDays)--------------------------------
	function DayAdd(startDate, numDays)
	{
			return DateAdd(startDate,numDays,0,0);
	}
//---------------------------------------------------------------------------------------