//Collapsing panel js
 function ToggleCollapseState(collapseButton, bodyDiv)
{
    try
    {
      var bodyDivRef = document.getElementById(bodyDiv);

      if (bodyDivRef)
      {
        if (bodyDivRef.style.display == 'none' || bodyDivRef.className.indexOf('hidden') > -1)
        {
          collapseButton.src = 'images/Base/button-collapse.gif';
          if (collapseButtonHideTitle)
          {
            collapseButton.title = 'Hide';
          }
          bodyDivRef.style.display = 'block';
          
          if (bodyDivRef.className.indexOf('hidden') > -1)
          {
            bodyDivRef.className = bodyDivRef.className.substring(0, bodyDivRef.className.indexOf('hidden') -1); 
          }
        }
        else
        {
         collapseButton.src = 'images/Base/button-expand.gif';
          if (collapseButtonShowTitle)
          {
            collapseButton.title = collapseButtonShowTitle;
          }
          bodyDivRef.style.display = 'none';
        }
      }
      else
      {
        alert('Unable to find target body');
      }
    }
    catch (e)
    {
      alert(e.message);
    }
}

var errorsHeader = 'Please correct the following.\n\n';

function Validate(form, controlID, errorsHeader, regexElementIdFilter)
{
	// set up properties
	this.form = form;
	this.namespace = controlID;
	this.errors = '';
	this.setfocus = null;
	this.errorsHeader = errorsHeader;
	this.namedErrors = new Array();
	if (regexElementIdFilter)
	{
		this.regexElementIdFilter = regexElementIdFilter;
	}
	// set up attributes
	this.requiredAttribute = 'required';
	this.requiredEmptyAttribute = 'requiredEmpty';
	this.validationTypeAttribute = 'validationtype';
	this.regexAttribute = 'regex';
	this.minLengthAttribute = 'minlength';
	this.numericMinLengthAttribute = 'numericminlength';
	this.maxLengthAttribute = 'maxlength';
	this.numericMaxLengthAttribute = 'numericmaxlength';
	this.minValueAttribute = 'minvalue';
	this.maxValueAttribute = 'maxvalue';
	this.equalsAttribute = 'equals';
	
	// set up error handling attributes
	this.defaultErrorAttribute = 'error';
	this.requiredErrorAttribute = 'requirederror';
	this.validationTypeErrorAttribute = 'validationtypeerror';
	this.regexErrorAttribute = 'regexerror';
	this.minLengthErrorAttribute = 'minlengtherror';
	this.maxLengthErrorAttribute = 'maxlengtherror';
	this.minValueErrorAttribute = 'minvalueerror';
	this.maxValueErrorAttribute = 'maxvalueerror';
	this.equalsErrorAttribute = 'equalserror';
	
	// set up error handling default errors
	this.defaultError = '{name} is invalid.'
	this.defaultRequiredError = '{name} is required.';
	this.defaultValidationTypeError = '{name} is invalid.';
	this.defaultRegexError = '{name} is invalid.';
	this.defaultMinLengthError = '{name} is too short in length.';
	this.defaultMaxLengthError = '{name} is too long in length.';
	this.defaultMinValueError = '{name} must be greater than {minValue}.';
	this.defaultMaxValueError = '{name} must be less than {maxValue}.';
	this.defaultEqualsError = '{name} is not equal to {equals}';
	this.defaultNotEqualsError = '{name} cannot equal {equals}';
	
	// add methods to object
	this.run = run;
	this.validateSingleElement = validateSingleElement;
	this.outputErrors = outputErrors;
	this.checkFocus = checkFocus;
	this.setError = setError;
	this.cleanAttributeForErrorDisplay = cleanAttributeForErrorDisplay;
	this.validateRequired = validateRequired;
	this.validateType = validateType;
	this.validateRegex = validateRegex;
	this.validateMinLength = validateMinLength;
	this.validateMaxLength = validateMaxLength;
	this.validateMinValue = validateMinValue;
	this.validateMaxValue = validateMaxValue;
	this.validateEquals = validateEquals;
	this.isExemptFromValidation = isExemptFromValidation;
	
	// add validation type methods
	this.setValidateTypeError = setValidateTypeError;
	this.validateAmount = validateAmount;
	this.validateDate = validateDate;
	this.validateMod10 = validateMod10;
	this.validateNumeric = validateNumeric;
	
	//this.nonePattern = '^\.*$';
	this.stringPattern = '^.+$';	
	this.upperCaseStringPattern = '^[A-Z]([A-Z)|\s)*$';
	this.numericPattern = '^\\d+$';
	this.numericStripper = /\D/g;
	this.alphaNumericPattern = '^\\w+$';
	
	var amountSeparators = '(\\.|,)';
	this.amountPattern = '^(\\d+(' + amountSeparators + '\\d+)*)$';
	
	this.dateYearPattern = '^\\d{4}$';
	this.dateMonthPattern = '^\\d{2}$';
	this.dateDayPattern = '^\\d{2}$';
	
	var validEmailChars = '[^\:\,\;\#$\%\&\(\)\+\=\/]+';
	this.emailPattern = '^' + validEmailChars + '(\\.' + validEmailChars + ')?@' + validEmailChars + '(\\.' + validEmailChars + ')+$';

}

function checkKeyPressed(evt, input)
{
  evt = (evt) ? evt : (window.event) ? event : null;
  if (evt)
  {
    var charCode = (evt.charCode) ? evt.charCode :
                   ((evt.keyCode) ? evt.keyCode :
                   ((evt.which) ? evt.which : 0));
    if (charCode == 13) 
    {
        input.click();
        
    }
  }    
}

function run()
{
	// run validation on the form elements
	for (var i = 0; i < this.form.length; i++)
	{
		var e = this.form.elements[i];
		
		if (!this.isExemptFromValidation(e))
		{
			this.validateSingleElement(e);
		}
	}
	
	return this.outputErrors();
}

function isExemptFromValidation(e)
{
	if (e.id.indexOf(this.namespace) != 0)
	{
		return true;
	}
	
	if ((this.regexElementIdFilter) && (!e.id.match(this.regexElementIdFilter)))
	{
		return true;
	} 
	
	return false;
} 

function outputErrors()
{
	// if there is an error output it
	if(this.errors)
	{
		alert(this.errorsHeader + this.errors);
		
		if (this.setfocus)
		{
			this.setfocus.focus();
		}
		
		return false;
	}
	
	return true;
}

function validateSingleElement(e)
{
    this.validateRequired(e);
	// only validate the rest if they actually have something
	if (this.errors.length < 1 && 0 < getValue(e).length)
	{
		this.validateType(e);
		this.validateRegex(e);
		this.validateMinLength(e);
		this.validateMaxLength(e);
		this.validateMinValue(e);
		this.validateMaxValue(e);
		this.validateEquals(e);
	}
}

function checkFocus(e)
{
	if (!this.setfocus)
	{
		this.setfocus = e;
	}
}

function validateRequired(e)
{
    var required = ('' + e.getAttribute(this.requiredAttribute)).toLowerCase();
    var requiredEmptyString = ('' + e.getAttribute(this.requiredEmptyAttribute)).toLowerCase();
    
	if(required != undefined)
    {
        if (required == 'true' || required == 'required')
        {
            var value = getValue(e);
            if((value.length < 1) || (value.toLowerCase() == requiredEmptyString))
	        {
		        this.setError(e, this.requiredErrorAttribute, this.defaultRequiredError);
	        }
	    }    
	}    
}

function getValue(e)
{
    if (e.type == 'radio')
    {
        if (e.getAttribute('name').length > 0)
        {
            var arrayOfRadioButtons = document.getElementsByName(e.getAttribute('name'));
            for (var i = 0; i < arrayOfRadioButtons.length; i++)
            {
                if (arrayOfRadioButtons[i].checked == true)
                {
                    return arrayOfRadioButtons[i].value;
                }
            }
        }
        
        return '';
    }
    else if (e.type == 'checkbox')
    {
        if (e.checked == true)
        {
            return e.value;
        }
        
        return '';
    }
    
    return e.value;
}

function validateType(e)
{
	var type = e.getAttribute(this.validationTypeAttribute);
	var value = getValue(e);
	
	if (type) 
	{
	    type = type.toLowerCase();
		if ((type == 'address') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'alphanumeric') && (!value.match(this.alphaNumericPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'amount') && (!this.validateAmount(value)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'country') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'email') && (!value.match(this.emailPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'mod10') && (!this.validateMod10(value)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'name') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'numeric') && (!this.validateNumeric(value)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type.indexOf('date') == 0) && (!this.validateDate(e, type, value)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'state') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'string') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'uppercasestring') && (!value.match(this.upperCaseStringPattern)))
		{
			this.setValidateTypeError(e);
		}
		else if ((type == 'zip') && (!value.match(this.stringPattern)))
		{
			this.setValidateTypeError(e);
		}
		
	}
}

function validateRegex(e)
{
    var regex = e.getAttribute(this.regexAttribute);
	var value = getValue(e);
	if ((regex) && (!value.match(regex)))
	{
		this.setError(e, this.regexErrorAttribute, this.defaultRegexError);
	}
}

function validateMinLength(e)
{
	var length = e.getAttribute(this.minLengthAttribute);
	var numericLength = e.getAttribute(this.numericMinLengthAttribute);
	var value = getValue(e);
	
	if ((0 < length) && (value.length < length))
	{
		this.setError(e, this.minLengthErrorAttribute, this.defaultMinLengthError);
	}
	else if ((0 < numericLength)  && (0 < value.length) && (value.replace(this.numericStripper, '').length < numericLength))
	{
		this.setError(e, this.minLengthErrorAttribute, this.defaultMinLengthError);
	}
}

function validateMaxLength(e)
{
	var length = e.getAttribute(this.maxLengthAttribute);
	var numericLength = e.getAttribute(this.numericMaxLengthAttribute);
	var value = getValue(e);
				
	if ((0 < length) && (length < value.length))
	{
		this.setError(e, this.maxLengthErrorAttribute, this.defaultMaxLengthError);
	}
	else if ((0 < numericLength)  && (0 < value.length) && (numericLength < value.replace(this.numericStripper, '').length))
	{
		this.setError(e, this.maxLengthErrorAttribute, this.defaultMaxLengthError);
	} 
}

function validateMinValue(e)
{
	var min = e.getAttribute(this.minValueAttribute);
	
	if ((min != null) && (0 < min.length))
	{
	    var value = getValue(e);
	    
		if ((5 < min.length) && (min.substring(0, 5) == '&gt;='))
		{
			if (value < parseFloat(min.substring(5, min.length)))
			{
				this.setError(e, this.minValueErrorAttribute, this.defaultMinValueError);
			}
		}
		else if ((4 < min.length) && (min.substring(0, 4) == '&gt;'))
		{
			if (value <= parseFloat(min.substring(4, min.length)))
			{
				this.setError(e, this.minValueErrorAttribute, this.defaultMinValueError);
			}
		}
		else if (value < parseFloat(min))
		{
			this.setError(e, this.minValueErrorAttribute, this.defaultMinValueError);
		}
	}
}

function validateMaxValue(e)
{
	var max = e.getAttribute(this.maxValueAttribute);
	
	if ((max != null) && (0 < max.length))
	{
	    var value = getValue(e);
	    
		if ((5 < max.length) && (max.substring(0, 5) == '&lt;='))
		{
			if (value > parseFloat(max.substring(5, max.length)))
			{
				this.setError(e, this.maxValueErrorAttribute, this.defaultMaxValueError);
			}
		}
		else if ((4 < max.length) && (max.substring(0, 4) == '&lt;'))
		{
			if (value >= parseFloat(max.substring(4, max.length)))
			{
				this.setError(e, this.maxValueErrorAttribute, this.defaultMaxValueError);
			}
		}
		else if (parseFloat(value) > max)
		{
			this.setError(e, this.maxValueErrorAttribute, this.defaultMaxValueError);
		}
	}
}

function validateEquals(e)
{
	// eventually this should be equipped to do string
	// comparison as well as other element comparisons
	
	var equal = e.getAttribute(this.equalsAttribute);
	
	if ((equal != null) && (0 < equal.length))
	{
	    var value = getValue(e);
	    
		if ((2 < equal.length) && (equal.substring(0, 2) == '!='))
		{
			if (value == equal.substring(2, equal.length))
			{
				this.setError(e, this.equalsErrorAttribute, this.defaultEqualsError);
			}
		}
		else if ((2 < equal.length) && (equal.substring(0, 2) == '=='))
		{
			if (value != equal.substring(2, equal.length))
			{
				this.setError(e, this.equalsErrorAttribute, this.defaultEqualsError);
			}
		}
		else if (equal.charAt(0) == '=')
		{
			if (value != equal.substring(1, equal.length))
			{
				this.setError(e, this.equalsErrorAttribute, this.defaultEqualsError);
			}
		}
		else if (value != equal)
		{
			this.setError(e, this.equalsErrorAttribute, this.defaultEqualsError);
		}
	}
}

function setValidateTypeError(e)
{
	this.setError(e, this.validationTypeErrorAttribute, this.defaultValidationTypeError);
}

function setError(e, errorAttribute, defaultTypeError)
{
    if (e.type == 'radio')
    {
        var name = e.getAttribute('name');
        if (name.length > 0)
        {
            if (this.namedErrors[name] != null)
            {
                return;
            }
            this.namedErrors[name] = name;
        }
    }
         
	var error = e.getAttribute(errorAttribute);
	if (!error)
	{
		if (e.getAttribute(this.defaultErrorAttribute))
		{
			error = e.getAttribute(this.defaultErrorAttribute);
		}
		else if (defaultTypeError)
		{
			error = defaultTypeError;
		}
		else
		{
			error = this.defaultError;
		}
	}
	
	// this would make more sense but it doesn't work
	// so i'll do each explicitly while i make this work
	var results = error.match(/{\s*(\w+)\s*}/g);
	if (results)
	{
		for (var i = 0; i < results.length; i++)
		{
			var dollarOne = results[i].replace(/{\s*(\w+)\s*}/, '$1');
			error = error.replace(/{\s*\w+\s*}/, this.cleanAttributeForErrorDisplay(e, dollarOne));
		}
	}
	
	this.errors += error + '\n';
	this.checkFocus(e);	
}

function cleanAttributeForErrorDisplay(e, attributeName)
{
	var attribute = e.getAttribute(attributeName.toLowerCase());
	
	if (attribute == null)
	{
		return attributeName;
	}
	
	if (attributeName.match(/^(minvalue|maxvalue)$/i))
	{
		return attribute.replace(/[^\d.,]/g, '');
	}
	
	return attribute;
}

function validateAmount(amount)
{
	if ((!amount.match(this.amountPattern)) || (amount == 0))
	{
		return false;
	}
	
	return true;
}

function validateDate(e, type, value)
{
    var lowerCaseType = '';
    if (type)
    {
        lowerCaseType = type.toLowerCase();
    }
	var today = new Date();
	
	if ((lowerCaseType == 'dateyear') && ((value < today.getYear()) || (!value.match(this.dateYearPattern))))
	{
		return false;
	}
	//just make sure it is two digits for now
	else if ((lowerCaseType == 'datemonth') && (!value.match(this.dateMonthPattern)))
	{
		return false;
	}
	//just make sure it is two digits for now
	else if ((lowerCaseType == 'dateday') && (!value.match(this.DateDayPattern)))
	{
		return false;
	}
	
	return true;
}

function validateMod10(cardNumber)
{
	var ccCheckRegExp = /\D/;
	var cardNumbersOnly = cardNumber.replace(/ /g, "");
		
	if (!ccCheckRegExp.test(cardNumbersOnly))
	{
		var numberProduct;
		var checkSumTotal = 0;
		
		while (cardNumbersOnly.length < cardNumber.length)
		{
			cardNumbersOnly = '0' + cardNumbersOnly;
		}

		for (digitCounter = cardNumbersOnly.length - 1; 0 <= digitCounter; digitCounter -= 2)
		{
			checkSumTotal += parseInt (cardNumbersOnly.charAt(digitCounter));
			numberProduct = String((cardNumbersOnly.charAt(digitCounter - 1) * 2));
			for (var productDigitCounter = 0; productDigitCounter < numberProduct.length; productDigitCounter++)
			{
				checkSumTotal += parseInt(numberProduct.charAt(productDigitCounter));
			}
		}

		return (checkSumTotal % 10 == 0);
	}

	return false;
}

function validateNumeric(number)
{
	number = number.replace(/\s/g, '');
	
	if (!number.match(this.numericPattern))
	{
		return false;
	}
	
	return true;
}

function validate(controlID, elementName, filter)
{
    //make sure we can run this javascript
 	if (document.getElementById && document.createTextNode)
	{
	    // check if you can getAttribute if you can it is an element use the id.
	    if (controlID.getAttribute)
	    {
	        controlID = controlID.getAttribute("id").replace(/_\w+$/, "");
	    }
	    var validate = new Validate(document['SkySales'], controlID + '_', errorsHeader, filter);
		
		if (elementName)
		{
		    var e = elementName;
		    if (!elementName.getAttribute)
		    {
		        e = document.getElementById(controlID + "_" + elementName);
			}
		    validate.validateSingleElement(e);
			return validate.outputErrors();
		}
		
		return validate.run();
	}
  	
  	// could not use javascript rely on server validation
  	return true;
}


// <preventDoubleClick>
	var submitterClicked = false;
					
	function preventDoubleClick()
	{
		if (!submitterClicked)
		{
			submitterClicked = true;
			return true;
		}
		
		return false;
	}
//</preventDoubleClick>


var events = new Array();

function register(eventName, functionName)
{
	if (eval(events[eventName]) == null)
	{
		events[eventName] = new Array();
	}
	events[eventName][events[eventName].length]	= functionName;
}

function raise(eventName, eventArgs)
{
	var undefined;

	if (events[eventName] != undefined)
	{
		for (var ix=0; ix<events[eventName].length; ix++)
		{
			if ( eval(events[eventName][ix] + "(eventArgs)") == false)
			{
				return false;
			}
		}
	}
	
	return true;
}

function WindowLoadEventArgs()
{
}

function WindowInitialize()
{
    var originalOnLoad = window.onload;
        
    window.onload = function()
        {
            raise('WindowLoad', new WindowLoadEventArgs());
   
            if (originalOnLoad)
            {
                originalOnLoad();
            }
        }
}

function debug()
{
    var items = debug.arguments.length;
    if (items > 0)
    {
        var strbuf = '' + debug.arguments[0] + ' [';
        
        for (var i=1; i < items; i++)
        {
            strbuf += '' + debug.arguments[i];
            if (items != (i + 1))
            {
              strbuf += ', ';
            }
        }
        alert(strbuf + ']');
    }
}

function displayPopUpConverter()
{
    var url = 'CurrencyConverter.aspx';

    if (!window.converterWindow || converterWindow.closed)
    {
      converterWindow = window.open(url,'converter','width=360,height=190,toolbar=0,status=0,location=0,menubar=0,scrollbars=0,resizable=0');
    }
    else
    {
      converterWindow.open(url,'converter','width=360,height=190,toolbar=0,status=0,location=0,menubar=0,scrollbars=0,resizable=0');
      converterWindow.focus();
    }
 }

 //show - hide divs
 function showDivs(bodyDiv) {
     var bodyDivRef = document.getElementById(bodyDiv);
     if (bodyDivRef) {
         if (bodyDivRef.style.display == 'none' || bodyDivRef.className.indexOf('hidden') > -1) {
             bodyDivRef.style.display = 'block';

             if (bodyDivRef.className.indexOf('hidden') > -1) {
                 bodyDivRef.className = bodyDivRef.className.substring(0, bodyDivRef.className.indexOf('hidden') - 1);
             }
         }
     }
 }

 function hideDivs(bodyDiv) {
     var bodyDivRef = document.getElementById(bodyDiv);
     if (bodyDivRef) {
         bodyDivRef.style.display = 'none';
     }
 }
 //end show hide
 
//Hints javascript
var defaultXOffset	= 0;
var defaultYOffset	= 0;
var hintDiv = "cssHelp";
var hintBelowDiv = "cssHints";
var hintContent = "markhelp";
var hintBelowContent = "markhelpbelow";
function showHintArrow(obj)
{
    var x = 0;
    var y = 0;
     
	    x 							= getX(obj);
	    y 							= getY(obj);
		y							= y-28;
	    
	
	var hintHtml = '';
	
	//Get culture XML hint
	if (obj.getAttribute('hint') != null)
		hintHtml += obj.getAttribute('hint');
	
	getObject(hintContent).innerHTML = hintHtml;
	getStyle(hintDiv).visibility 	= 'visible';
	getStyle(hintDiv).left 			= x + 'px';
	getStyle(hintDiv).top = y + 'px';
}

function hideHintArrow(obj)
{
	getStyle(hintDiv).visibility 	= 'hidden';
}

function showHintBelow(obj) {
    var x = 0;
    var y = 0;

    x = getX(obj);
    y = getY(obj);
    y = y + 25;


    var hintHtml = '';

    //Get culture XML hint
    if (obj.getAttribute('hint') != null)
        hintHtml += obj.getAttribute('hint');

    getObject(hintBelowContent).innerHTML = hintHtml;
    getStyle(hintBelowDiv).visibility = 'visible';
    getStyle(hintBelowDiv).left = x + 'px';
    getStyle(hintBelowDiv).top = y + 'px';
}

function hideHintBelow(obj) {
    getStyle(hintBelowDiv).visibility = 'hidden';
}

function erase (element, defaultValue)
{
	if (element.value == defaultValue)
	{
		element.value = "";
	}
}

function set (element, defaultValue)
{
	if (element.value == "")
	{
		element.value = defaultValue;
	}
}

function getX(obj)
{
	var pos = 0;
	if (obj.x)	// N4
	{
		pos += obj.x;
	}
	else if (obj.offsetParent)
	{
		while (obj.offsetParent)
		{
		    pos += obj.offsetLeft;
			obj	 = obj.offsetParent;
		}
	}
	
	return pos;
}

function getY(obj)
{
    var count = 0;
	var pos = 0;
	if (obj.y) // netscape 4
		pos += obj.y;
	else if (obj)
	{
	     while(obj){		
	     pos+=obj.offsetTop;
		 obj=obj.offsetParent;
 	    }
	}
	return pos;
}

function getObject(name)
{
	if (document.getElementById) return document.getElementById(name);
	if (document.all) return document.all[name];
	if (document.layers)
	{
		if (document.layers[name]) return document.layers[name];
		else return document.layers[name].layers[name];
	}
}

function getStyle(name)
{
	if (document.getElementById) return document.getElementById(name).style;
	if (document.all) return document.all[name].style;
	if (document.layers)
	{
		if (document.layers[name]) return document.layers[name];
		else return	this.style = document.layers[name].layers[name];
	}
}

//End of hints

function get_cookie(Name) {
    var search = Name + "="
    var returnvalue = "";
    if (document.cookie.length > 0) {
        offset = document.cookie.indexOf(search)
        if (offset != -1) {
            offset += search.length
            end = document.cookie.indexOf(";", offset);
            if (end == -1) end = document.cookie.length;
            returnvalue = unescape(document.cookie.substring(offset, end))
        }
    }
    return returnvalue;
}
function getAutoSSR(paxcount) {
    if (get_cookie("plsgrdpax") == 0) {
        document.cookie = "plsgrdpax=" + paxcount;
        __doPostBack('ControlGroupSelectView$SSRMarketInputSelectView$LinkButtonSaveSSRRequests', '');
    }
}

function getPaymentCode(bookingcode) {
    var map = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    var returnode = "";
    var i = 0;
    var res = 0;
    var smt = 0;
    var j = 0;

    for (i = 1; i <= 6; i++) {
        j = Math.pow(36, (6 - i));
        smt = InStr(map, Mid(bookingcode, i - 1, 1));
        res = res + (j * smt);
    }

    res = 7000000000 + res;
    returncode = "789" + res;

    return (returncode);
}
function InStr(strSearch, charSearchFor) {
    for (i = 0; i < Len(strSearch); i++) {
        if (charSearchFor == Mid(strSearch, i, 1)) {
            return i;
        }
    }
    return -1;
}
function right(str, n) {
    if (n <= 0)
        return "";
    else if (n > String(str).length)
        return str;
    else {
        var iLen = String(str).length;
        return String(str).substring(iLen, iLen - n);
    }
}

function Mid(str, start, len) {
    if (start < 0 || len < 0) return "";

    var iEnd, iLen = String(str).length;
    if (start + len > iLen)
        iEnd = iLen;
    else
        iEnd = start + len;

    return String(str).substring(start, iEnd);
}

function Len(str) {
    return String(str).length;
}