// querystring related stuff ... This is really just for testing the default states via querystring, for development purposes.

	var querystring = document.location.search;
	var jsQueryValues = new Array();

	// strip leading '?' if present
		if (querystring) {
			if (querystring.charAt(0) == '?') {
				querystring = querystring.substring(1, querystring.length);
			}
		if (document.location.href.indexOf('&') != -1) { var queryStringDelimiter = '&'; } else { var queryStringDelimiter = '&'; }

		// loop through pairs and assign them in the array
			for (loop = 0; loop < querystring.split(queryStringDelimiter).length; loop++) {
				var thisPair = querystring.split(queryStringDelimiter)[loop];
				var thisName = unescape(thisPair.split('=')[0]);
				var thisValue = unescape(thisPair.split('=')[1]);
				jsQueryValues[thisName] = thisValue;
			}
		}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////                                                                                                          ////
////    THIS IS A FLEXIBLE AND FULL-FEATURED IMAGE REPLACEMENT FUNCTION.                                      ////
////                                                                                                          ////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////    DESCRIPTION & USAGE:    //////////////////////////////////////////////////////////////////////////////
////                                                                                                          ////
////    This function is designed to do three things:                                                         ////
////        1. reduce and simplify rollover code in the <img> tag for standard and custom image states.       ////
////        2. handle standard image states by naming convention and custom image states by image path.       ////
////        3. handle ID or DOM referral methods interchangeably.                                             ////
////                                                                                                          ////
////    This function allows you to refer to images by ID or by DOM referral, so you no longer need to        ////
////    create an ID for every image you want to swap. Because this function uses the naming convention       ////
////    that you specify for any image states you find yourself using you do not need to send it the          ////
////    image path or file, it determines the correct path based upon the naming convention you set. The      ////
////    result is reusable code, any image that has a standard rollover state and passive state will use      ////
////    the exact same code for onmouseover and onmouseout. Because this function is DOM friendly, you        ////
////    can put your code in the <a> tag or the <img> tag.                                                    ////
////                                                                                                          ////
////    USAGE - REFERING TO THE IMAGE:                                                                        ////
////        The first argument 'thisImg' in the function can be either an ID or DOM referral, (such as        ////
////        "this" in the image itself or "this.firstChild" in the link tag surrounding that image).          ////
////                                                                                                          ////
////    USAGE - DEFINING YOUR NEW IMAGE STATE:                                                                ////
////        The second argument 'imgState' represents either a standard image state, or a custom image        ////
////        state. Standard image states are defined in the 'stdImgState' associative array below,            ////
////        which has four key/value pairs by default. By default there are three states 'out', 'ovr',        ////
////        and 'clk'--those states are paired with the naming conventions 'imageName.gif',                   ////
////        'imageName_o.gif', and 'imageName_c.gif', resectively. to request the out state of an image       ////
////        set the  the 'imgState' argument to 'out', to request, the over state, set it to 'ovr' and        ////
////        so fourth. you can add as many states to the array as you like.                                   ////
////                                                                                                          ////
////        If you would like to replace an image with a custom image (eg, one that is not one of your        ////
////        standard image states, or does not follow your naming convention) just send it the image          ////
////        name (without the images directory path affixed) and it will know that it is not a standard       ////
////        state and replace your image with that particular image.                                          ////
////                                                                                                          ////
////    PLEASE NOTE:                                                                                          ////
////    if you do send an image a custom state that violates your naming convention, you have to              ////
////    restore it to a standard state using the custom state method (full image name of a standard           ////
////    state as second argument) before standard states will work again on this image, because this          ////
////    function works by parsing the image filename. I may find a way to fix this in the future but          ////
////    it's not a big problem for now.                                                                       ////
////                                                                                                          ////
////    QUESTIONS? BUGS? COMMENTS? PLEASE EMAIL ME. jose@jcao.com, jose.caogarcia@ogilvy.com                  ////
////                                                                                                          ////
////    REQUIRED FUNCTIONS: none;                                                                             ////
////                                                                                                          ////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////    ARGUMENTS, ARRAYS & Variables:    ////////////////////////////////////////////////////////////////////
////                                                                                                          ////
////      thisImg = String or DOM referral: If it's a string, it should be the target image's id.             ////
////                otherwise, it should be a DOM referral to the target image.                               ////
////                                                                                                          ////
////     imgState = A string: This is either a standard state as described in the stdImgState array, or       ////
////                an image name, (custom state) please read above for further info.                         ////
////                                                                                                          ////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	//// PATH TO IMAGES DIRECTORY, KEPT OUTSIDE THE FUNCTION TO MAKE IT ACCESSIBLE TO OTHER FUNCTIONS
		var pathToImages = '/us/en/images/nav/';
		var pathToTabImages = '/us/en/images/tabs/';

	// DEFINE THE STANDARD STATES IN AN ASSOCIATIVE ARRAY
		var stdImgState = new Array('out','ovr','clk'); // each state must be listed here, in the same order as it is below
		stdImgState['out'] = '.';  // do not edit this line  // first node must ALWAYS be the default state, with the value of '.',
		stdImgState['ovr'] = '_o.';
		stdImgState['clk'] = '_c.';

	//// THIS IS THE IMAGE REPLACEMENT COMPOMENT
	function imgState(thisImg, imgState, type) {
	
	// get info about source image we are replacing, get full image filename, mimetype and filename without mimetype.
			if (thisImg.toString().indexOf('[object') == 0) {
				var imgSrc = thisImg.src.split('/')[thisImg.src.split('/').length - 1];
			} else {
				var imgSrc = document.getElementById(thisImg).src.split('/')[document.getElementById(thisImg).src.split('/').length - 1];
			// here, we alter thisImg to be the id referral method, rather than the DOM referral method
				thisImg = document.getElementById(thisImg);
			}
		var imgMim = imgSrc.split('.')[imgSrc.split('.').length - 1];
		var imgNam = imgSrc.substring(0, (imgSrc.length - imgMim.length - 1));
	// strip state suffixes from imgNam so that we do not duplicate them. we want just the root string of the naming convention
		for (var loop = 0; loop < stdImgState.length; loop++) {
		var endOfImgNam = imgNam.substring((imgNam.length - stdImgState[loop].length) + 1, imgNam.length)
		var stateValue = stdImgState[eval('stdImgState["' + loop + '"]')].substring(0, stdImgState[eval('stdImgState["' + loop + '"]')].length - 1);
			if(endOfImgNam == stateValue && loop != 0) {
				imgNam = imgNam.substring(0 , (imgNam.length - stateValue.length));
			}
		}
		
	var imgPath = pathToImages;
	if (type=='tab')
		imgPath = pathToTabImages;
		
	// replace an image based upon what we know
		if (stdImgState[imgState]){
			// if the imgState argument calls one of the standard states:
			thisImg.src = imgPath + imgNam + stdImgState[imgState] + imgMim;
			//alert(imgPath + imgNam + stdImgState[imgState] + imgMim);
		} else {
			// if the imgState argument is a custom state
			if (imgState.indexOf('.') == '-1') {
				thisImg.src = imgPath + imgState + '.' + imgMim;
			} else {
				thisImg.src = imgPath + imgState;
			}
		}
	}


	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    THIS FUNCTION RETURNS AN ARRAY OF ALL CHILD DOM ELEMENTS (NO TEXT NODES) FOR A SPECIFIED OBJECT.      ////
	////    IT MAKES WORKING WITH CHILDNODES MUCH EASIER BECAUSE WE KNOW WE ARE ONLY DEALING WITH ELEMENTS AND    ////
	////    NO TEXTNODES, NO MATTER WHAT WEB BROWSER WE ARE USING. I'M A A BIG FAN OF CONSISTENT BEHAVIOUR.       ////
	////                                                                                                          ////
	////    QUESTIONS? BUGS? COMMENTS? PLEASE EMAIL ME. jose@jcao.com, jose.caogarcia@ogilvy.com                  ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////////    DESCRIPTION & USAGE:    //////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    JUST SEND IT A DOM REFERENCE FOR THE ELEMENT WHOSE CHILDNODES YOU WANT, AND IT WILL RETURN AN ARRAY   ////
	////    WITH NODES (CONTAINING DOM REFS) FOR EACH SUCH CHILD ELEMENT.                                         ////
	////                                                                                                          ////
	////////    IMPORTANT:    ////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    YOU MUST HAVE A VALID PARSE TREE TO WORK WITH THIS FUNCTION, SO IF YOU ENCOUNTER PROBLEMS CHECK YOUR  ////
	////    CODE FOR VALIDATION ERRORS AND INCOMPLETE OR IMPROPERLY NESTED ELEMENTS.                              ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		function getElementDom(targetElement) {
			var elementsArray = new Array();
				for (var contLoop = 0; contLoop < targetElement.childNodes.length; contLoop++) {
					if (targetElement.childNodes[contLoop].nodeType == 1) {
						elementsArray[elementsArray.length++] = targetElement.childNodes[contLoop];
					}
				}
			return elementsArray;
		}


	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    THIS FUNCTION RETURNS A DOM REFERENCE (HTML OBJECT/ENTITY) THAT HAS A DIRECT RELATIONSHIP TO          ////
	////    ANOTHER REFERENCE NODE (WHICH YOU PASS TO IT, AS AN ARGUMENT). IT IS DESIGNED TO SIMPLIFY AND         ////
	////    ACCELERATE THE PROCESS OF TRAVERSING DOM STRUCTURES IN XHTML DOCUMENTS. THIS FUNCTION CAN DO TWO      ////
	////    THINGS: (1) IT CAN RETURN AN OBJECT REFERENCE FOR THAT IS X NUMBER OF PARENT NODES "SENIOR" TO THE    ////
	////    REFERENCE NODE, OR (2) IT CAN RETURN A SPECIFIC CHILD (X of Y CHILDREN) OF THE REFERENCE ELEMENT.     ////
	////                                                                                                          ////
	////    QUESTIONS? BUGS? COMMENTS? PLEASE EMAIL ME. jose@jcao.com, jose.caogarcia@ogilvy.com                  ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////////    DESCRIPTION & USAGE:    //////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    THIS FUNCTION REQURES THREE ARGUMENTS. THE FIRST ARGUMENT "obj" IS THE REFERENCE ELEMENT, THE         ////
	////    FUNCTION WILL BE RETURNING AN REFERENCE TO AN HTML ENTITIY WHOSE POSITION IN THE PARSE TREE IS        ////
	////    RELATIVE TO THIS ELEMENT. THE "obj" ELEMENT IS YOUR STARTING POINT. THE NEXT ARGUMENT IS "upDown"     ////
	////    THIS ELEMENT TELLS US WHETHER WE ARE GOING UP THE PARSE TREE (parentNodes) OR DOWN THE PARSE TREE     ////
	////    (childNodes). THE LAST ARGUMENT (nodesNum) IS A NUMERIC VALUE THAT REPRESENTS EITHER (1) HOW MANY     ////
	////    PARENT NODES WE WANT TO TRAVERSE BY, OR (2) WHICH CHILD ELEMENT YOU WANT TO GET. IN BOTH CASES, WE    ////
	////    START WITH ZERO, SO THE FIRST CHILD, OR THE FIRST PARENT NODE ARE REPRESENTED BY 0, WHERAS THE        ////
	////    SECOND CHILD AND THE PARENT NODE OF THE PARENT NODE ARE REPRESENTED BY 1.                             ////
	////                                                                                                          ////
	////////    IMPORTANT:    ////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    YOU MUST HAVE A VALID PARSE TREE TO WORK WITH THIS FUNCTION, SO IF YOU ENCOUNTER PROBLEMS CHECK YOUR  ////
	////    CODE FOR VALIDATION ERRORS AND INCOMPLETE OR IMPROPERLY NESTED ELEMENTS. IN ORDER FOR THIS FUNCTION   ////
	////    TO WORK, THE SUPPORTING FUNCTION getElementDom() MUST BE PRESENT.                                     ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		function getRelatedDom(obj, upDown, nodesNum) {
		// make sure nodesNum is a number and not a string
		var nodesNum = parseInt(nodesNum);
			if (upDown == 'up') {
			// here we are moving UP the dom (towards the body tag, to general elements)
				var getParentStr = '.parentNode';
				var getFinalObj = '';
				for (loop = 0; loop <= nodesNum; loop++) { getFinalObj = getFinalObj + getParentStr; }
				var targetElement = eval('obj' + getFinalObj);
			} else {
			// here we are moving DOWN the dom (away from the body tag, to specific elements)
				var targetElement = getElementDom(obj)[nodesNum];
			}
		return targetElement;
		}


	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    THIS FUNCTION WILL TELL YOU WHAT INDEX OF A PARENTS CHILDREN A GIVEN ELEMENT REPRESENTS. IT IS        ////
	////    VERY EASY TO USE, ALL YOU HAVE TO DO IS PASS IT THE ELEMENT THAT YOU WANT TO FIND OUT ABOUT, AND      ////
	////    IT WILL RETURN A NUMERIC VALUE INDICATING WHICH NODE OF IT'S PARENTS CHILDREN IT IS (STARTING WITH    ////
	////    ZERO FOR THE FIRST NODE).                                                                             ////
	////                                                                                                          ////
	////    QUESTIONS? BUGS? COMMENTS? PLEASE EMAIL ME. jose@jcao.com, jose.caogarcia@ogilvy.com                  ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	////////    IMPORTANT:    ////////////////////////////////////////////////////////////////////////////////////////
	////                                                                                                          ////
	////    YOU MUST HAVE A VALID PARSE TREE TO WORK WITH THIS FUNCTION, SO IF YOU ENCOUNTER PROBLEMS CHECK YOUR  ////
	////    CODE FOR VALIDATION ERRORS AND INCOMPLETE OR IMPROPERLY NESTED ELEMENTS. IN ORDER FOR THIS FUNCTION   ////
	////    TO WORK, THE SUPPORTING FUNCTION getElementDom() MUST BE PRESENT.                                     ////
	////                                                                                                          ////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////

		function getWhichParentChild(obj) {
			var parentObj = obj.parentNode;
			var parentChildrenArr = getElementDom(parentObj);
			for (loop = 0; loop < parentChildrenArr.length; loop++) {
				if (obj == parentChildrenArr[loop]) {
					return loop;
				}
			}
		}

	// OBJECT ARRAY STORAGE.
		var menuKillTimer;
		var mouseOutLag   = 1000;

	// OBJECT ARRAY STORAGE.
		var lv1ObjArr      = new Array();
		var lv2DivObjArr   = new Array();
		var lv2ImgObjArr   = new Array();
		var lv3ObjArr      = new Array();

	// default onstates for menus (pre-existing hard coded var overrides)
	if (!menuSelectedState1) {
	// start with one, 0 is null state
		var menuSelectedState1         = (jsQueryValues['menuSelectedState1']) ? jsQueryValues['menuSelectedState1'] : 0 ;
		var menuSelectedState2         = (jsQueryValues['menuSelectedState2']) ? jsQueryValues['menuSelectedState2'] : 0 ;
		var menuSelectedState3         = (jsQueryValues['menuSelectedState3']) ? jsQueryValues['menuSelectedState3'] : 0 ;
	}
	// start with one, 0 is null state
	if (!utilitiesSelectedState) { var utilitiesSelectedState     = (jsQueryValues['utilitiesSelectedState']) ? jsQueryValues['utilitiesSelectedState'] : 0 ; }

	// THIS FUNCTION INTERPRETS ALL NAV EVENTS, AND PASSES THE BALL TO setNavState()
		function navEvent(thisObj, uiEvent) {
			if (uiEvent == 'ovr') { clearTimeout(menuKillTimer); }
		// determine DOM offset values by nav reference object level
			var parentObjId = getRelatedDom(thisObj, 'up', 0).className;
			if (parentObjId.indexOf('navLevelTwo') == 0 ) { parentObjId = 'navLevelTwo' } // we have two different classes for level 2 navs, we want to treat them as one in JS.
			switch (parentObjId) {
				case 'navLevelOne':
					var whichIndexOne = getWhichParentChild(thisObj);
					var whichIndexTwo = false;
				break;
				case 'navLevelTwo':
					var whichIndexOne = getWhichParentChild(getRelatedDom(thisObj, 'up', 1));
					var whichIndexTwo = getWhichParentChild(thisObj);
				break;
				case 'navLevelThree':
					var whichIndexOne = parseInt(thisObj.parentNode.id.substring(3, thisObj.parentNode.id.length).split('-')[0]) - 1;
					var whichIndexTwo = parseInt(thisObj.parentNode.id.substring(3, thisObj.parentNode.id.length).split('-')[1]) - 1;
				break;
			}
		// define the two main nav parent elements
			var levelOneParent = document.getElementById('navLevelOne');
			var levelTwoParent = document.getElementById('navLevelTwo');
		// get the level 1 nav object
			var lv1Obj    = getRelatedDom(levelOneParent, 'dn', whichIndexOne).firstChild;
			var lv2DivObj = getRelatedDom(levelTwoParent, 'dn', whichIndexOne);
		// get the level 2 & 3 nav objects only if level 2 is active
			var lv2ImgObj = (parentObjId == 'navLevelOne') ? false : getRelatedDom(getRelatedDom(getRelatedDom(levelTwoParent, 'dn', whichIndexOne), 'dn', 0), 'dn', whichIndexTwo).firstChild; // write a complex, recursive, dom traversing function to vastly simplify statements like this.
			var lv3Obj    = (parentObjId == 'navLevelOne') ? false : document.getElementById('sub' + (whichIndexOne + 1) + '-' + (whichIndexTwo + 1));
		// pass the appropriate dom refs and state on to the handling function
			setNavState(uiEvent, lv1Obj, lv2DivObj, lv2ImgObj, lv3Obj);
		}


		function setNavState(uiEvent, lv1Obj, lv2DivObj, lv2ImgObj, lv3Obj) {
			if (uiEvent != 'def' || menuSelectedState1 > 0) {
			// get DOM arrays for each section of navigation that we need to manipulate.
				lv1ObjArr = getElementDom(document.getElementById('navLevelOne'));
				// adjust offsets
					lv1ObjArr.length = (lv1ObjArr.length - 1); // we cut off the last reference because it is the level 2 nav.
					for (var loop in lv1ObjArr) { lv1ObjArr[loop] = lv1ObjArr[loop].firstChild; } // Write a function that does this (for each element of an array offset down by x elements).
				lv2DivObjArr = getElementDom(document.getElementById('navLevelTwo'));
				lv2ImgObjArr = getElementDom(getRelatedDom(lv2DivObj, 'dn', 0));
				// adjust offsets
					for (var loop in lv2ImgObjArr) { lv2ImgObjArr[loop] = lv2ImgObjArr[loop].firstChild; } // Write a function that does this (for each element of an array offset down by x elements).
				lv3ObjArr = getElementDom(getRelatedDom(lv2DivObj, 'dn', 1));
			}
		// manipulate each array of DOM refs according to the objects passed to us.
			if (uiEvent == 'ovr' || uiEvent == 'def') {
				for (var loop in lv1ObjArr)    { if (lv1ObjArr[loop] == lv1Obj) { imgState(lv1ObjArr[loop], 'ovr'); } else { imgState(lv1ObjArr[loop], 'out'); } }
				for (var loop in lv2DivObjArr) { lv2DivObjArr[loop].style.display = (lv2DivObjArr[loop] == lv2DivObj) ? 'block': 'none'; }
				for (var loop in lv2ImgObjArr) { if (lv2ImgObjArr[loop] == lv2ImgObj) { imgState(lv2ImgObjArr[loop], 'ovr'); } else { imgState(lv2ImgObjArr[loop], 'out'); } }
				for (var loop in lv3ObjArr)    { lv3ObjArr[loop].style.display = (lv3ObjArr[loop] == lv3Obj && uiEvent == 'ovr') ? 'block': 'none'; }
				for (var loop in lv3ObjArr)    { lv3ObjArr[loop].style.visibility = (lv3ObjArr[loop] == lv3Obj && uiEvent == 'ovr') ? 'visible' : 'hidden'; }
				// BEGIN MICROSOFT INTERNET EXPLORER HANDHOLDING ...
				if (navigator.appName == 'Microsoft Internet Explorer') {
					for (var loop in lv3ObjArr) { getElementDom(lv3ObjArr[loop])[ (getElementDom(lv3ObjArr[loop]).length - 1) ].style.visibility = (lv3ObjArr[loop] == lv3Obj && uiEvent == 'ovr') ? 'visible' : 'hidden'; }
					for (var loop in lv3ObjArr) { getElementDom(lv3ObjArr[loop])[ (getElementDom(lv3ObjArr[loop]).length - 2) ].style.visibility = (lv3ObjArr[loop] == lv3Obj && uiEvent == 'ovr') ? 'visible' : 'hidden'; }
				}
				// END MICROSOFT INTERNET EXPLORER HANDHOLDING ...
			} else {
				menuKillTimer = (menuSelectedState1 > 0) ? setTimeout('initialNav()', (mouseOutLag)) : setTimeout('setNavState("def", false, false, false, false)', (mouseOutLag));
			}
		}


	// initializes nav with default states
		function initialNav() {
		// get the relevant objects
			var lv1defaultObj = (menuSelectedState1 == 0) ? false : getElementDom(document.getElementById('navLevelOne'))[(menuSelectedState1 - 1)];
			var lv2defaultObj = (menuSelectedState2 == 0) ? false : getRelatedDom(getRelatedDom(getRelatedDom(document.getElementById('navLevelTwo'), 'dn', getWhichParentChild(lv1defaultObj)), 'dn', 0), 'dn', (menuSelectedState2 - 1)); // write a complex, recursive, dom traversing function to vastly simplify statements like this.
			var lv3defaultObj = (menuSelectedState3 == 0) ? false : getElementDom(document.getElementById('sub' + menuSelectedState1 + '-' + menuSelectedState2))[(menuSelectedState3 - 1)]; // (menuSelectedState3 - 1)
		// call nav events for relevant objects
			if (lv1defaultObj) { navEvent(lv1defaultObj, 'def'); } 
			if (lv2defaultObj) { navEvent(lv2defaultObj, 'def'); }
			if (lv3defaultObj) { lv3defaultObj.className = 'current'; }
			if (utilitiesSelectedState != 0) {
				var currentUtility = getElementDom(document.getElementById('utilitiesNav'))[utilitiesSelectedState].firstChild;
				imgState(currentUtility, 'ovr');
				currentUtility.className = 'current';
			}
			if (tabsSelectedState != 0) {
				var currentTab = getElementDom(document.getElementById('tabs'))[tabsSelectedState - 1].firstChild.firstChild;
				imgState(currentTab, 'clk', 'tab');
				currentTab.className = 'current';
			}
		}

		function utilityState(utilityObj, thisState) {
			if (utilityObj.className != 'current') { imgState(utilityObj, thisState); }
		}
		
		function tabState(tabObj, thisState) {
			if (tabObj.className != 'current') { imgState(tabObj, thisState, 'tab'); }
		}