//////////////////////////////////////////////////
// abs(x)                                       //
//////////////////////////////////////////////////
function abs(x) {return Math.abs(x);}
//////////////////////////////////////////////////
// acos(x)                                      //
//////////////////////////////////////////////////
function acos(x) {return Math.acos(x);}
//////////////////////////////////////////////////
// arrayappend(array,value)                     //
//////////////////////////////////////////////////
function arrayappend(array,value){
eval(array)[eval(array).length] = value
}
//////////////////////////////////////////////////
// arrayavg(array)                              //
//////////////////////////////////////////////////
function arrayavg(array){
x=0;
for(i=0;i<eval(array).length;i++)
{
x+=eval(array)[i];}
v = x/eval(array).length;
return v;
}

//////////////////////////////////////////////////
// arrayclear(array)                            //
//////////////////////////////////////////////////
function arrayclear(array){
eval(array).length=0;
return true;
}
//////////////////////////////////////////////////
// arraydeleteat(array,position)                //
//////////////////////////////////////////////////
function arraydeleteat(array,position){
eval(array).splice(position-1,1)
return true;
}
//////////////////////////////////////////////////
// arrayinsertat(array,position,value)         //
//////////////////////////////////////////////////
function arrayinsertat(array,position,value){
eval(array).splice(position-1,0,value)
return true;
}
//////////////////////////////////////////////////
// arrayisempty(array)                          //
//////////////////////////////////////////////////
function arrayisempty(array){
if (eval(array).length==0)
{return true;}
else
{return false;}
}
//////////////////////////////////////////////////
// arraylen(array)                             //
//////////////////////////////////////////////////
function arraylen(array){
return eval(array).length
}
//////////////////////////////////////////////////
// arraymax(array)                             //
//////////////////////////////////////////////////
function arraymax(array){
x = eval(array)[0]
for(i=0;i<eval(array).length;i++)
{
x = Math.max(x,eval(array)[i])
}
return x
}
//////////////////////////////////////////////////
// arraymin(array)                             //
//////////////////////////////////////////////////
function arraymin(array){
x = eval(array)[0]
for(i=0;i<eval(array).length;i++)
{
x = Math.min(x,eval(array)[i])
}
return x
}
//////////////////////////////////////////////////
// arrayprepend(array,value)                    //
//////////////////////////////////////////////////
function arrayprepend(array,value){
add = eval(array).splice(0,0,value)
return true;
}
//////////////////////////////////////////////////
// arrayresize(array,value)                    //
//////////////////////////////////////////////////
function arrayresize(array,value){
eval(array).length = value
return true;
}

//////////////////////////////////////////////////
// arrayset(array, start_pos, end_pos, value)   //
//////////////////////////////////////////////////
function arrayset(array, start_pos, end_pos, value){
for(i=start_pos-1;i<end_pos;i++)
eval(array)[i] = value
return true;
}


//////////////////////////////////////////////////
// arraysum(array)                              //
//////////////////////////////////////////////////
function arraysum(array, start_pos, end_pos, value){
x=0
for(i=0;i<eval(array).length;i++)
{x += eval(array)[i] }
return x;
}
//////////////////////////////////////////////////
// arrayswap(array, position1, position2)       //
//////////////////////////////////////////////////
function arrayswap(array, position1, position2){
x = array[position1-1];
y = array[position2-1];
array[position2-1] = x;
array[position1-1] = y;
return true;
}
//////////////////////////////////////////////////
// arraytolist(array,  delimiter )       //
//////////////////////////////////////////////////
function arraytolist(array,  delimiter ) {
if(!delimiter){var delimiter=','}
x = eval(array).join(delimiter)
return x;
}
//////////////////////////////////////////////////
// arraysort(array, sort_type , sort_order )     //
//////////////////////////////////////////////////
function arraysort(array, sort_type , sort_order ) {
if(!sort_type){var sort_type='text'}
if(!sort_type){var sort_type='asc'}

}
//////////////////////////////////////////////////
// asc(mystring)                                //
//////////////////////////////////////////////////
function asc(mystring) {return mystring.charCodeAt(0);}
//////////////////////////////////////////////////
// asin(x)                                      //
//////////////////////////////////////////////////
function asin(x) {return Math.asin(x);}
//////////////////////////////////////////////////
// atan(x)                                      //
//////////////////////////////////////////////////
function atan(x) {return Math.atan(x);}
//////////////////////////////////////////////////
// bitand(number1,  number2 )       //
//////////////////////////////////////////////////
function bitand(number1,  number2 ) {
x = number1 & number2
return x;
}
//////////////////////////////////////////////////
// bitnot(number)                               //
//////////////////////////////////////////////////
function bitnot(number) {
x =  ~ number
return x;
}
//////////////////////////////////////////////////
// bitor(number1,  number2 )       //
//////////////////////////////////////////////////
function bitor(number1,  number2 ) {
x = number1 | number2
return x;
}
//////////////////////////////////////////////////
// bitshln(number,  count )       //
//////////////////////////////////////////////////
function bitshln(number,  count ) {
x = number << count
return x;
}
//////////////////////////////////////////////////
// bitshrn(number,  count )       //
//////////////////////////////////////////////////
function bitshrn(number,  count ) {
x = number >> count
return x;
}
//////////////////////////////////////////////////
// bitxor(number1,  number2 )       //
//////////////////////////////////////////////////
function bitxor(number1,  number2 ) {
x = number1 ^ number2
return x;
}

//////////////////////////////////////////////////
// ceiling(x)                                   //
//////////////////////////////////////////////////
function ceiling(x) {return Math.ceil(x);}

//////////////////////////////////////////////////
// chr(number)                                //
//////////////////////////////////////////////////
function chr(number) {return String.fromCharCode(number);}
//////////////////////////////////////////////////
//  cjustify(string, length)                  //
//////////////////////////////////////////////////
function cjustify(mystring,number) {
NoOfCharsToAdd = Math.floor((number - mystring.length) / 2)
for(i=0;i<NoOfCharsToAdd;i++)
{mystring = ' ' + mystring + ' ' }
if(mystring.length < number){mystring += ' '}
return mystring
}
//////////////////////////////////////////////////
//  compare(string1, string2)                  //
//////////////////////////////////////////////////
function compare(string1, string2) {
if(string1==string2)
		{
		x= 0
		}
else
{

for(i=0;i<Math.max(string1.length,string2.length);i++)
	{
	if(string1.charCodeAt(i)!=string2.charCodeAt(i))
		{
			if (string1.charCodeAt(i) < string2.charCodeAt(i)) {x = -1;}
			if (string1.charCodeAt(i) > string2.charCodeAt(i)) {x = 1;}
			break;
		}
	}

}

return x;
}
//////////////////////////////////////////////////
//  comparenocase(string1, string2)                  //
//////////////////////////////////////////////////
function comparenocase(string1, string2) {
string1 = string1.toUpperCase();
string2 = string2.toUpperCase();
if(string1==string2)
		{
		x= 0
		}
else
{

for(i=0;i<Math.max(string1.length,string2.length);i++)
	{
	if(string1.charCodeAt(i)!=string2.charCodeAt(i))
		{
			if (string1.charCodeAt(i) < string2.charCodeAt(i)) {x = -1;}
			if (string1.charCodeAt(i) > string2.charCodeAt(i)) {x = 1;}
			break;
		}
	}

}

return x;
}
//////////////////////////////////////////////////
//  createdate(year, month, day)                //
//////////////////////////////////////////////////
function createdate(myyear,mymonth,myday) {
mydate = new Date(myyear,mymonth,myday)
return mydate;
}
//////////////////////////////////////////////////
//  createdatetime(year, month, day,hour,minute,second)   //
//////////////////////////////////////////////////
function createdatetime(myyear,mymonth,myday,myhour,myminute,mysecond) {
mydate = new Date(myyear,mymonth,myday,myhour,myminute,mysecond)
return mydate;
}

 
//////////////////////////////////////////////////
// cos(x)                                      //
//////////////////////////////////////////////////
function cos(x) {return Math.cos(x);}


//////////////////////////////////////////////////
// day(datestring)                           //
//////////////////////////////////////////////////
function day(datestring) {return datestring.getDate();}
//////////////////////////////////////////////////
// dayofweek(datestring)                           //
//////////////////////////////////////////////////
function dayofweek(datestring) {return datestring.getDay()+1;}
//////////////////////////////////////////////////
// dayofweekasstring(datestring)                           //
//////////////////////////////////////////////////
function dayofweekasstring(datestring) {
x = datestring.getDay()+1
if(x==1){_string='Sunday'}
if(x==2){_string='Monday'}
if(x==3){_string='Tuesday'}
if(x==4){_string='Wednesday'}
if(x==5){_string='Thursday'}
if(x==6){_string='Friday'}
if(x==7){_string='Saturday'}
return _string

}
//////////////////////////////////////////////////
// daysinmonth(datestring)                           //
//////////////////////////////////////////////////
function daysinmonth(datestring) {
x = datestring.getMonth()+1
if (x==1||x==3||x==5||x==7||x==8||x==10||x==12){return 31};
if (x==2){return 28};
if (x==4||x==6||x==9||x==11){return 30};
}
//////////////////////////////////////////////////
// isleapyear(year)                           //
//////////////////////////////////////////////////
function isleapyear(year)       {
return (year%4 == 0 && (year%100 != 0 || year%400 == 0) ? true : false)
}

////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
////////////////
//////////////////////////////////////////////////
// dollarformat(number)                        //
//////////////////////////////////////////////////
function dollarformat(number) {
if(number<0){number = '($' + number +')'}
else{number = '$' + number}
return number;
}
////////////////
//////still need to cut at decimal point//////////
////////////////
////////////////
////////////////
////////////////
////////////////
//////////////////////////////////////////////////
// decrementvalue(number)                       //
//////////////////////////////////////////////////
function  decrementvalue(number)  {return number-1;}
//////////////////////////////////////////////////
// function encrypt(mystring, key)            //
//////////////////////////////////////////////////
function encrypt(mystring, key){
     Ref="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz._~"
        key = parseInt(key)
        var Temp=""
        for (Count=0; Count < mystring.length; Count++) {
                var TempChar = mystring.substring (Count, Count+1)
                var Conv = Ref.indexOf(TempChar)
                var Cipher=Conv^key
                Cipher=Ref.substring(Cipher, Cipher+1)
                Temp += Cipher
        }
        return (Temp)

}

 

//////////////////////////////////////////////////
// evaluate(stringexpression)                  //
//////////////////////////////////////////////////
function evaluate(stringexpression){ return eval(stringexpression);}
//////////////////////////////////////////////////
//  find(substring, string , start )                  //
//////////////////////////////////////////////////
function find(mysubstring,mystring,mystart)
 {
 if(!mystart){var mystart=0;}
 else
 {mystart = mystart - 1;}
return mystring.indexOf(mysubstring, mystart)+1;
 }
//////////////////////////////////////////////////
//  findnocase(substring, string , start )                  //
//////////////////////////////////////////////////
function findnocase(mysubstring,mystring,mystart)
 {
 if(!mystart){var mystart=0;}
 else
 {mystart = mystart - 1;}
 mystring = mystring.toUpperCase()
 mysubstring = mysubstring.toUpperCase()
return mystring.indexOf(mysubstring, mystart)+1;
 }
//////////////////////////////////////////////////
//  fix(number)                        //
//////////////////////////////////////////////////
function  fix(number) {
if(number<0)
{return Math.ceil(number);}
else {return Math.floor(number);}
}

 

 
//////////////////////////////////////////////////
// hour(datestring)                           //
//////////////////////////////////////////////////
function hour(datestring) {return datestring.getHours();}
/////////////////////////////////////////////////////////////////////
//   iif(condition, string_expression1, string_expression2)        //
/////////////////////////////////////////////////////////////////////
function  iif(condition, string_expression1, string_expression2) {
return (eval(condition) ? string_expression1 :  string_expression2 )
}
 //////////////////////////////////////////////////
// incrementvalue(number)                        //
//////////////////////////////////////////////////
function  incrementvalue(number)  {return number+1;}
//////////////////////////////////////////////////
//  inputbasen(number,radix)                        //
//////////////////////////////////////////////////
function  inputbasen(number, radix) {return parseInt(number, radix);}
 //////////////////////////////////////////////////
// insert(substring, string, position)                      //
//////////////////////////////////////////////////
function insert(mysubstring, mystring, position){
return mystring.substring(0,position) + mysubstring + mystring.substring(position,mystring.length);
}

//////////////////////////////////////////////////
// exp(x)          //
//////////////////////////////////////////////////
function exp(x){ return Math.exp(x);}
//////////////////////////////////////////////////
// lcase(string)          //
//////////////////////////////////////////////////
function lcase(mystring)  {
return mystring.toLowerCase()
}
//////////////////////////////////////////////////
// left(string,count)          //
//////////////////////////////////////////////////
function left(mystring,count)  {
return mystring.substring(mystring.length-count,mystring.length);
}
//////////////////////////////////////////////////
// len(string)          //
//////////////////////////////////////////////////
function len(mystring)  {return mystring.length;}
//////////////////////////////////////////////////
// listappend(list,value,delimiters)          //
//////////////////////////////////////////////////
function listappend(list,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
added = _TempListFirstSplitArray.splice(_TempListFirstSplitArray.length,0,value)
_TempStringToReturn = _TempListFirstSplitArray.join(delimiters)
return _TempStringToReturn
}
///////////////////////////////////////////////////////////////
// listchangedelims(list,new_delimiters,delimiters)          //
///////////////////////////////////////////////////////////////
function listchangedelims(list,new_delimiters,delimiters) {
if(!delimiters){var delimiters=','}
_TempListSplitArray = list.split(delimiters)
_TempStringToReturn = _TempListSplitArray.join(new_delimiters)
return _TempStringToReturn
}
///////////////////////////////////////////////////////////////
// listcontains(list, substring , delimiters)          //
///////////////////////////////////////////////////////////////
function listcontains(list, mysubstring , delimiters) {
if(!delimiters){var delimiters=','}
x=0
_TempListSplitArray = list.split(delimiters)
for(i=0;i<_TempListSplitArray.length;i++)
{
if (_TempListSplitArray[i].indexOf(mysubstring)!=-1) 
{
x = i+1
} 
}

return x;
}

///////////////////////////////////////////////////////////////
// listcontainsnocase(list, substring , delimiters)          //
///////////////////////////////////////////////////////////////
function listcontainsnocase(list, mysubstring , delimiters) {
if(!delimiters){var delimiters=','}
x=0
list = list.toUpperCase();
mysubstring = mysubstring.toUpperCase();
_TempListSplitArray = list.split(delimiters)
for(i=0;i<_TempListSplitArray.length;i++)
{
if (_TempListSplitArray[i].indexOf(mysubstring)!=-1) 
{
x = i+1
} 
}

return x;
}
//////////////////////////////////////////////////
// listdeleteat(list,position,delimiters)       //
//////////////////////////////////////////////////
function listdeleteat(list,position,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
removed = _TempListFirstSplitArray.splice(position-1,1)
_TempStringToReturn = _TempListFirstSplitArray.join(delimiters)
return _TempStringToReturn

}
//////////////////////////////////////////////////
// listfind(list,value,delimiters)              //
//////////////////////////////////////////////////
function listfind(list,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListSplitArray = list.split(delimiters)
FoundIdx = 0;
for(i=0;i<_TempListSplitArray.length;i++)
{
if(_TempListSplitArray[i]==value)
	{
	FoundIdx= i+1;
	break
	}
}
return FoundIdx
}
//////////////////////////////////////////////////
// listfindnocase(list,value,delimiters)              //
//////////////////////////////////////////////////
function listfindnocase(list,value,delimiters) {
if(!delimiters){var delimiters=','}
list = list.toUpperCase();
value = value.toUpperCase();
_TempListSplitArray = list.split(delimiters)
FoundIdx = 0;
for(i=0;i<_TempListSplitArray.length;i++)
{
if(_TempListSplitArray[i]==value)
	{
	FoundIdx= i+1;
	break
	}
}
return FoundIdx
}
//////////////////////////////////////////////////
// listfirst(list,delimiters)                   //
//////////////////////////////////////////////////
function listfirst(list,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
return _TempListFirstSplitArray[0]
}
//////////////////////////////////////////////////
// listgetat(list,position,delimiters)          //
//////////////////////////////////////////////////
function listgetat(list,position,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
return _TempListFirstSplitArray[position-1]
}
//////////////////////////////////////////////////
// listinsertat(list,position,value,delimiters) //
//////////////////////////////////////////////////
function listinsertat(list,position,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
added = _TempListFirstSplitArray.splice(position-1,0,value)
_TempStringToReturn = _TempListFirstSplitArray.join(delimiters)
return _TempStringToReturn

}
//////////////////////////////////////////////////
// listlast(list,delimiters)                   //
//////////////////////////////////////////////////
function listlast(list,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
return _TempListFirstSplitArray[_TempListFirstSplitArray.length-1]
}
//////////////////////////////////////////////////
// listlen(list,delimiters)                   //
//////////////////////////////////////////////////
function listlen(list,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
return _TempListFirstSplitArray.length
}
//////////////////////////////////////////////////
// listprepend(list,value,delimiters)          //
//////////////////////////////////////////////////
function listprepend(list,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
added = _TempListFirstSplitArray.splice(0,0,value)
_TempStringToReturn = _TempListFirstSplitArray.join(delimiters)
return _TempStringToReturn
}
//////////////////////////////////////////////////
// listqualify(list,qualifier,delimiters,elements)     //
//////////////////////////////////////////////////
function listqualify(list,qualifier,delimiters,elements) {
if(!delimiters){var delimiters=','}
if(!elements){var elements='ALL'}
_TempListSplitArray = list.split(delimiters)
for(i=0;i<_TempListSplitArray.length;i++)
{
		if(elements == 'CHAR')
		{
		/////////////
		/////////////
		//////////////////////////
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//STILL WORK LEFT HERE !!!
		//////////////////////////
		/////////////
		//////////////////////////
		/////////////
		//////////////////////////
		/////////////
		//////////////////////////
		/////////////
		//////////////////////////
		/////////////
		/////////////
		}
		else
		{
		_TempListSplitArray[i] = qualifier + _TempListSplitArray[i] +  qualifier
		}

}
_TempStringToReturn = _TempListSplitArray.join(delimiters)
return _TempStringToReturn
}

//////////////////////////////////////////////////
// listsetat(list,position,value,delimiters)     //
//////////////////////////////////////////////////
function listsetat(list,position,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListFirstSplitArray = list.split(delimiters)
_TempListFirstSplitArray[position-1]=value
_TempStringToReturn = _TempListFirstSplitArray.join(delimiters)
return _TempStringToReturn

}
//////////////////////////////////////////////////
// listtoarray(list,delimiters)                 //
//////////////////////////////////////////////////
function listtoarray(list,delimiters) {
if(!delimiters){var delimiters=','}
_TempListSplitArray = list.split(delimiters)
return _TempListSplitArray

}
//////////////////////////////////////////////////
// listvaluecount(list,value,delimiters)                 //
//////////////////////////////////////////////////
function listvaluecount(list,value,delimiters) {
if(!delimiters){var delimiters=','}
_TempListSplitArray = list.split(delimiters)
FoundIdx = 0;
for(i=0;i<_TempListSplitArray.length;i++)
{
if(_TempListSplitArray[i]==value)
	{
	FoundIdx++;
	}
}
return FoundIdx
}
//////////////////////////////////////////////////
// ljustify(string, length)                      //
//////////////////////////////////////////////////
function ljustify(mystring, number) {
NoOfCharsToAdd = number - mystring.length
for(i=0;i<NoOfCharsToAdd;i++)
{mystring = ' ' + mystring }
return mystring
}
//////////////////////////////////////////////////
// log(number)                 //
//////////////////////////////////////////////////
function log(number) {
return Math.log(number);
}
//////////////////////////////////////////////////
// ltrim(string)                                //
//////////////////////////////////////////////////
function ltrim(myString) {
i=0
do {i++}
while ( i < myString.length && (myString.charCodeAt(i)==32 || myString.charCodeAt(i)=='NaN') );
return myString.substr(i,myString.length)
}
//////////////////////////////////////////////////
// max(x,y)                                     //
//////////////////////////////////////////////////
function max(x,y) {return Math.max(x,y);}
//////////////////////////////////////////////////
// Mid(string, start, count)                    //
//////////////////////////////////////////////////
function mid(myString,start,count)
{
return myString.substr(start-1,count)
}
//////////////////////////////////////////////////
// min(x,y)                                     //
//////////////////////////////////////////////////
function min(x,y) {return Math.min(x,y);}
//////////////////////////////////////////////////
// minute(datestring)                           //
//////////////////////////////////////////////////
function minute(datestring) {return datestring.getMinutes();}
//////////////////////////////////////////////////
// month(datestring)                                     //
//////////////////////////////////////////////////
function month(datestring) {return datestring.getMonth();}
//////////////////////////////////////////////////
// now()                     //
//////////////////////////////////////////////////
function now()
{
_NewDate = new Date();
return _NewDate
}
//////////////////////////////////////////////////
// pi()                                         //
//////////////////////////////////////////////////
function pi() {return Math.PI;}
//////////////////////////////////////////////////
// rand()                                       //
//////////////////////////////////////////////////
function rand() {   
return Math.random();
}
//////////////////////////////////////////////////
// repeatstring(string, count)                  //
//////////////////////////////////////////////////
function repeatstring(string,count){
var _NewString = '';
for(i=0;i<count;i++)
{_NewString += string}
return _NewString
} 

//////////////////////////////////////////////////
// removechars(string, start, count)            //
//////////////////////////////////////////////////
function removechars(mystring, start, count){
new_string = mystring.slice(0,start-1)
new_string2 = mystring.slice(start+count-1)
return new_string + new_string2
}

 
//////////////////////////////////////////////////
// replace(string, substring1, substring2 , scope)                  //
//////////////////////////////////////////////////
function  replace(string, substring1, substring2 , scope )
{
if(!scope){scope='1'}
if(scope!='ALL'){scope='1'}
re = '/'+substring1
if(scope=='1'){re += '/'}
else{re +='/g'}
new_string = string.replace(eval(re),substring2)
return new_string
}
//////////////////////////////////////////////////
// replacelist(string, list1, list2 )                  //
//////////////////////////////////////////////////
function  replacelist(mystring, list1, list2 ) 
{
delimiters = ','
_TempList1SplitArray = list1.split(delimiters)
_TempList2SplitArray = list2.split(delimiters)
for(i=0;i<_TempList1SplitArray.length;i++)
{
stringtoreplace = '/'+_TempList1SplitArray[i]+'/g'
mystring = mystring.replace(eval(stringtoreplace),_TempList2SplitArray[i])
}
return mystring
}
//////////////////////////////////////////////////
// replacenocase(string, substring1, substring2 , scope )                //
//////////////////////////////////////////////////
function  replacenocase(string, substring1, substring2 , scope )
{
if(!scope){scope='1'}
if(scope!='ALL'){scope='1'}
re = '/'+substring1
if(scope=='1'){re += '/i'}
else{re +='/gi'}
new_string = string.replace(eval(re),substring2)
return new_string
}
/////////////////////////////////////////////////////////////////////////////
// rereplace(string, reg_expression, substring2 , scope )                  //
////////////////////////////////////////////////////////////////////////////
function rereplace(mystring, reg_expression, substring2 , scope )
{if(!scope){scope='ONE'}
if(scope!='ALL'){scope='ONE'}else{reg_expression = reg_expression + '/g'}
new_string = mystring.replace(reg_expression,substring2)
return new_string;

}
/////////////////////////////////////////////////////////////////////////////
// rereplacenocase(string, reg_expression, substring2 , scope )                  //
////////////////////////////////////////////////////////////////////////////
function rereplacenocase(mystring, reg_expression, substring2 , scope )
{if(!scope){scope='ONE'}
if(scope!='ALL'){reg_expression = '/'+reg_expression + '/i'
}
else{reg_expression = '/'+reg_expression + '/gi'}
new_string = mystring.replace(eval(reg_expression),substring2)
return new_string;

}
//////////////////////////////////////////////////
// reverse(string)                              //
//////////////////////////////////////////////////
function reverse(mystring) {
var _TempNewString = ''
for(i=0;i<mystring.length;i++)
{
_TempNewString = mystring.charAt(i) + _TempNewString
}
return _TempNewString
}
//////////////////////////////////////////////////
// right(string,count)                              //
//////////////////////////////////////////////////
function right(string,count) {
return string.substr(0,count);
}
//////////////////////////////////////////////////
// rjustify(string, length)                      //
//////////////////////////////////////////////////
function rjustify(mystring, number) {
NoOfCharsToAdd = number - mystring.length
for(i=0;i<NoOfCharsToAdd;i++)
{mystring =  mystring + ' '}
return mystring
}
//////////////////////////////////////////////////
// round(number)                      //
//////////////////////////////////////////////////
function round(number)  {return Math.round(number);}
//////////////////////////////////////////////////
// rtrim(string)                                //
//////////////////////////////////////////////////
function rtrim(myString) {
i=myString.length
do {i--}
while (myString.charCodeAt(i)==32 || myString.charCodeAt(i)=='NaN' );
return myString.substr(0,i+1)
}
//////////////////////////////////////////////////
// second(datestring)                                      //
//////////////////////////////////////////////////
function second(datestring) {return datestring.getSeconds();}
//////////////////////////////////////////////////
// sin(x)                                      //
//////////////////////////////////////////////////
function sin(x) {return Math.sin(x);}
//////////////////////////////////////////////////
// sgn(x)                                      //
//////////////////////////////////////////////////
function sgn(x) {
if(x==0){return 0}
if(x>0){return 1}
if(x<0){return -1}
}
//////////////////////////////////////////////////
// sqr(x)                                      //
//////////////////////////////////////////////////
function sqr(x) {return Math.sqrt(x);}


//////////////////////////////////////////////////
// tan(x)                                      //
//////////////////////////////////////////////////
function tan(x) {return Math.tan(x);}
//////////////////////////////////////////////////
// trim(string)                                //
//////////////////////////////////////////////////
function trim(myString) {
return rtrim(ltrim(myString));
}
//////////////////////////////////////////////////
// ucase(string)          //
//////////////////////////////////////////////////
function ucase(mystring)  {
return mystring.toUpperCase()
}
//////////////////////////////////////////////////
// val(string)                     //
//////////////////////////////////////////////////
function val(myString) {
newstring = ""
for(i=0;i<myString.length;i++)
{
if(myString.charAt(i)=='1' 
|| myString.charAt(i)=='2' 
|| myString.charAt(i)=='3' 
|| myString.charAt(i)=='4' 
|| myString.charAt(i)=='5' 
|| myString.charAt(i)=='6' 
|| myString.charAt(i)=='7'
|| myString.charAt(i)=='8' 
|| myString.charAt(i)=='9' 
|| myString.charAt(i)=='0' 
|| myString.charAt(i)=='.'
|| myString.charAt(i)=='+'
|| myString.charAt(i)=='-'){
newstring+= myString.charAt(i)
}
else{break;}
}
return newstring;
}
//////////////////////////////////////////////////
// urlencodedformat(string)                     //
//////////////////////////////////////////////////
function urlencodedformat(myString) {
return escape(myString);
}

//////////////////////////////////////////////////
// year(date)                                   //
//////////////////////////////////////////////////
function year(mydate) {
_newDate = new Date(mydate)
return _newDate.getYear();
}
//////////////////////////////////////////////////
// yesnoformat(value)                           //
//////////////////////////////////////////////////
function yesnoformat(value) {
if(value==0){return 'NO'}
else {return 'YES'}
}
