function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_findObj(n, d) { //v4.01 - Alex 2006-10-08: THIS MAY BE NON-OPTIMAL FOR NEWER BROWSERS - SHOULD TRY getElementById FIRST
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

/********************************************************
 * Copyright (C) 2002-2003, CodeHouse.com. All rights reserved.
 * CodeHouse(TM) is a registered trademark.
 *
 * THIS SOURCE CODE MAY BE USED FREELY PROVIDED THAT
 * IT IS NOT MODIFIED OR DISTRIBUTED, AND IT IS USED
 * ON A PUBLICLY ACCESSIBLE INTERNET WEB SITE.
 * 
 * CodeHouse.com JavaScript Library Module: Get Current Style Method
 *
 * You can obtain this script at http://www.codehouse.com
 ********************************************************/
function CJL_getCurrentStyle(elem, prop)
{
   if( elem.currentStyle )
   {  
      var ar = prop.match(/\w[^-]*/g);
      var s = ar[0];
      
      for(var i = 1; i < ar.length; ++i)		   
      {
         s += ar[i].replace(/\w/, ar[i].charAt(0).toUpperCase());
      }
           
      return elem.currentStyle[s]
   }
   else if( document.defaultView && document.defaultView.getComputedStyle )
   {
      return document.defaultView.getComputedStyle(elem, null).getPropertyValue(prop);
   }
}


/**
 * Determine if an element is rendered.  An element is not rendered
 * if it has style display=none, visibility=hidden, or is a form 
 * field of type hidden, or if any of its parent elements have style
 * display=none or visibility=hidden.  (In IE 6, display style for form
 * fields of type "hidden" is inline, in Mozilla 1.6 is "none".)
 * Recursive
 */
function am_isRendered(elem_or_elemID) {
    var el = (isString(elem_or_elemID)) ? document.getElementById(elem_or_elemID) : elem_or_elemID;

    var visibility = CJL_getCurrentStyle(el, 'visibility');
    var display = CJL_getCurrentStyle(el, 'display');
    if (display == 'none' || 
        visibility == 'hidden' ||
        el.type == 'hidden') {
        return 0;
    }
    if (el.parentNode != document) {
        return am_isRendered(el.parentNode);
    }
    return 1;
}

/**
 * Commonly used to make text next to a radio button or checkbox
 * ("inputs" below refers to these two types only) act as if it was 
 * part of that input element.  Sample usage:
 *
 * <span onMouseUp="return am_clickChildCheckOrRadio(this);">
 *   <input type="checkbox" onClick="alert('something')">Some text
 * </span>
 *
 * Note the use of onMouseUp and not onClick - if you use onClick
 * you would get a loop.  For future, think of ways to prevent
 * bubble up from causing a loop.
 *
 * Takes one required argument, par, in which you should pass <this>.  
 * We use parameter to make sure that the input's onClick doesn't get 
 * called twice if it was the element that triggered the onMouseUp.
 *
 * Takes one optional argument, pattern, which should be a regular
 * expression.  If specified, only operates on elements whose name
 * matches that pattern.  Don't forget to escape backslashes.
 *
 * The onClick handler for the inputs is called as necessary.  If 
 * multiple checkboxes are encountered, each is clicked.  If multiple
 * radio buttons are encountered, the first will be clicked.  
 * Multiple radio buttons are not recommended, as this effect can be
 * unexpected.  Mixing checkboxes and radio buttons is also not
 * recommended.
 *
 * This function will currently only affect inputs that are both
 * enabled and rendered.  We may want to make this configurable in the
 * future.
 *
 * IE6 oddity - Having an alert during onMouseUp/Down processing seems
 * to cancel the processing of the events.  Make sure you avoid them.
 */
function am_clickChildCheckOrRadio (par) {

    var pattern  = arguments[1];

    // Determine the element clicked on in a cross-browser way.
    var e = window.event || arguments.callee.caller.arguments[0];
    var src = e.srcElement || (e.target.nodeType == 3 ? e.target.parentNode : e.target);
    // In Mozilla, could use e.currentTarget as par instead of having to pass this.

    var ie = document.all && navigator.userAgent.indexOf("Opera") == -1;

    var aInputs = par.getElementsByTagName('INPUT');
    for (var i = 0; i < aInputs.length; i++) {
        var input = aInputs[i];

        // Don't call the onClick handler of the Input in these cases:
        //  1. Element was the original source of the click.
        //  2. We have specified a pattern for the name and this doesn't match it.
        //  3. Input is disabled, or not currently rendered.
        if (input == src) { continue; }
        
        if (pattern && (!input.name || !input.name.match(pattern))) { continue; }
        if (input.disabled || !am_isRendered(input)) { continue; }

        if (input.type == 'radio') {
            input.checked = true;
            if (input.onclick) input.onclick();
            break;
        } else if (input.type == 'checkbox') {
            input.checked = !input.checked;
            if (input.onclick) input.onclick();
        }
    }
    return true;
}

/**
 * Return a boolean value telling whether the first argument is a string.
 * Modified slightly from version at:
 *      http://www.planetpdf.com/mainpage.asp?webpageid=1144
 * JCR - Modified to return null when given null
 */
function isString() {
    if (!arguments[0]) return null;
    if (typeof arguments[0] == 'string') return true;
    if (typeof arguments[0] == 'object') {
        // this could be a String object
        if (arguments[0].constructor) {
            // The following test blows in IE apparently because arguments[0].constructor
            // is undefined on the type of object being passed in (in test case the img object).
            // Thus, the surrounding extra 'if' was added.
            var criterion = arguments[0].constructor.toString().match(/string/i);
            return (criterion != null);
        }
    }
    return false;
}

/**
 * Thin wrapper to am_getDisplayType
 */
function am_getDisplayTypeById(id) {
    return am_getDisplayType(document.getElementById(id).tagName);
}

function am_getElementDisplayType(el) {
    return am_getDisplayType(el.tagName);
}

/**
 * Determine the default display type for a given tag name.
 * Default values are from http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/display.asp
 * Modified to follow http://www.w3schools.com/css/pr_class_display.asp more
 */
function am_getDisplayType(str) {
    var ie = navigator.userAgent.toLowerCase().indexOf("msie") > -1;
    var dispType = '';
    switch (str.toUpperCase()) {
        case 'ADDRESS':    case 'BLOCKQUOTE':  case 'BODY':
        case 'CENTER':     case 'COL':         case 'COLGROUP':
        case 'DD':         case 'DIR':         case 'DIV':
        case 'DL':         case 'DT':          case 'FIELDSET':
        case 'FORM':       case 'H1':          case 'H2':
        case 'H3':         case 'H4':          case 'H5':
        case 'H6':         case 'HR':          case 'IFRAME':
        case 'LEGEND':     case 'LISTING':     case 'MARQUEE':
        case 'MENU':       case 'OL':          case 'P':
        case 'PLAINTEXT':  case 'PRE':         case 'TABLE':
        case 'UL':         case 'XMP':
            dispType = 'block';
            break;
        case 'LI':
            dispType = 'list-item';
            break;
        case 'FRAME':
        case 'TBODY': case 'TFOOT': case 'THEAD':
            dispType = 'none';
            break;
        case 'TR':
            dispType = ie ? 'block' : 'table-row';
            break;
        case 'TD': case 'TH':
            dispType = ie ? 'block' : 'table-cell';
            break;
        default:
            dispType = 'inline';
    }
    return dispType;
}


/**
 * Show/Hide functions that protect against the element not existing
 * Accept either an ID or an element object directly.
 * Originally named showUIElement and hideUIElement in utility.js
 */
function am_show(elem_or_elemID, setVisibility) {
	var myElem = (isString(elem_or_elemID)) ? document.getElementById(elem_or_elemID) : elem_or_elemID;
	if (myElem) {
		if (setVisibility) {
			myElem.style.visibility='visible';
		} else {
			myElem.style.display = am_getElementDisplayType(myElem);
		}
	}
}

function am_hide(elem_or_elemID, setVisibility) {
	var myElem = (isString(elem_or_elemID)) ? document.getElementById(elem_or_elemID) : elem_or_elemID;
	if (myElem) {
		if (setVisibility) {
			myElem.style.visibility='hidden';
		} else {
			myElem.style.display='none';
		}
	}
}

function am_toggleShow(elem_or_elemID, setVisibility) {
    if (!am_isRendered(elem_or_elemID)) {
        am_show(elem_or_elemID, setVisibility);
    } else {
        am_hide(elem_or_elemID, setVisibility);
    }
}

/**
 * Given a DOM object, replaces occurrences of oldClass in the className
 * attribute with newClass.  Case-insensitive match of oldClass.
 *
 * oldClass - assumed to only have characters that are valid as normal characters
 *        (non-escaped) within a regular expression
 *         oldClass will not be matched on for partial strings.
 *
 * Previously named replaceClassName in utility.js, we should switch
 * everything to use this version, which can take element ids in
 * addition to elements.
 */
function am_replaceClassName(elem_or_elemID, oldClass, newClass) {
	var obj = isString(elem_or_elemID) ? document.getElementById(elem_or_elemID) : elem_or_elemID;
	if (obj) {
    	var regexp = eval("/\\b" + oldClass + "\\b/i");
		obj.className = obj.className.replace(regexp, newClass);
    }
}

// Give each button an enable() and disable() method
// Attach hover/click, etc. effects to all image buttons
// Pre-load all button images for all states
// Requires ExtJs
function am_initImageButtons () {
    var allImageButtons = Ext.query('input[type=image]');
    // This loop probably ought to be Ext.each(allImageButtons,function(button){ ...
    for (var i = 0; i < allImageButtons.length; i++) {
        var button = allImageButtons[i];
    
        // set up enable/disable methods
        button.enable = function () {
            var newsrc = this.getAttribute('enabledsrc');
            if (newsrc) {this.src = newsrc;}
            var newtitle = this.getAttribute('enabledtitle');
            if (newtitle) {this.title = newtitle;}
            this.style.cursor = 'pointer';
            this.disabled = false;
        };
        button.disable = function () {
            var newsrc = this.getAttribute('disabledsrc');
            if (newsrc) {this.src = newsrc;}
            var newtitle = this.getAttribute('disabledtitle');
            if (newtitle) {this.title = newtitle;}
            this.style.cursor = 'default';
            this.disabled = true;
        };
        
        // set up event listeners for effects
        Ext.get(button).addListener ( {
            'mouseover' : function () {
                if (!this.disabled) {
                    var newsrc = this.getAttribute('hoversrc');
                    if (newsrc) {this.src = newsrc;}
                }
            },
            'mouseout'  : function () {
                if (!this.disabled) {
                    var newsrc = this.getAttribute('enabledsrc');
                    if (newsrc) {this.src = newsrc;}
                }
            },
            'mousedown' : function () {
                if (!this.disabled) {
                    var newsrc = this.getAttribute('clicksrc');
                    if (newsrc) {this.src = newsrc;}
                }
            }
            
        });
    
        // pre-load images:
        var customAttributes = ['enabledsrc','disabledsrc','hoversrc','clicksrc'];
        var buttonImages = [];
        for (var j = 0; j < 4; j++) {
            var attribute = customAttributes[j];
            var imagesrc = button.getAttribute(attribute);
            if (imagesrc) {
                buttonImages[i] = new Array(4);
                buttonImages[i][j] = new Image();
                buttonImages[i][j].src = imagesrc;
            }
        }
    }
}

/**
 * Given either an element or an id, return the next visible and 
 * enabled element in the tab order.  This proc follows the Mozilla
 * method of treating negative tabIndexes exactly like 0.  In IE,
 * objects with a negative tabIndex are completely omitted from the
 * tabbing order.  We may want to make this configurable.
 *
 * Takes one optional argument, loopAtEnd, which defaults to true.
 * If loopAtEnd is false, will return null at the end of the tab order.
 * Otherwise, will return the first element in the tab order.
 *
 * Tab Order is:
 * 
 * Objects with a positive tabIndex are selected in increasing order 
 *   and in source order to resolve duplicates.
 * Objects with an tabIndex of less than or equal to zero are selected 
 *   in source order, and come after positive tabIndexes in tabbing 
 *   order.
 *
 * TODO: Refactor this so we can have an am_prevElementInTabOrder too,
 *       which we will likely trigger on backspace in some cases.
 */
function am_nextElementInTabOrder(elem_or_elemID, loopAtEnd) {
	var el = isString(elem_or_elemID) ? document.getElementById(elem_or_elemID) : elem_or_elemID;
    if (typeof(loopAtEnd) == 'undefined') {
        var loopAtEnd = true;
    }

    // Loop over all of the elements in order - should probably cache this
    var f = el.form;
    var tabOrders = new Array();
    var elsInOrder = new Array();
    var namesInOrder = new Array();

    for (var i = 0; i < f.elements.length; i++) {
        var fel = f.elements[i];
        if (fel.disabled || !am_isRendered(fel)) { continue; }  // Only include visible elements
        var tabOrder = fel.tabIndex;
        if (tabOrder <= 0) {
            elsInOrder.push(fel);
            namesInOrder.push(fel.name);
        } else {
            for (var j=0; j < elsInOrder.length; j++) {
                var ti = tabOrders[j];
                if (!ti || ti > tabOrder) break;
            }
            // have found place to insert current element at j.
            tabOrders.splice(j, 0, tabOrder);
            elsInOrder.splice(j, 0, fel);
            namesInOrder.splice(j, 0, fel.name);
        }
    }
//    alert(namesInOrder.toString());

    var nextElementIndex = elsInOrder.indexOf(el) + 1;
    if (nextElementIndex == elsInOrder.length) {
        if (!loopAtEnd) return null;
        nextElementIndex = 0;
    }
    return elsInOrder[nextElementIndex];
}

/**
 * Designed to be used like onKeyUp="am_nextOnMaxLength();"
 * If the current key press will have us reaching the source element's
 * maxlength, focus on the next element in the tab order.
 */
function am_nextOnMaxLength() {

    // Access event id on both IE (window.event) and Netscape
    var event = window.event || arguments.callee.caller.arguments[0];
    var el = event.srcElement || event.currentTarget || event.target;

    var keyCode = event.keyCode || event.which; 
    var filter = [0,8,9,16,17,18,37,38,39,40,46];

    var maxLength = el.getAttribute('maxLength');
    if (maxLength != null && el.value.length >= maxLength && !filter.contains(keyCode)) {
        am_nextElementInTabOrder(el).focus();
    }
    return true;
}

// Returns true if the array contains the element
Array.prototype.contains = function (element) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] == element) {
           return true;
        }
    }
    return false;
};


// This script and many more are available free online at
// The JavaScript Source!! http://javascript.internet.com
// Original:  jgw (jgwang@csua.berkeley.edu )
// Web Site:  http://www.csua.berkeley.edu/~jgwang/
function checkCapsLock( e ) {
	var myKeyCode=0;
	var myShiftKey=false;

        // Doesn't work in Netscape 7.02, which doesn't seem to be able
        // to get shift status from either e.modifiers or e.shiftKey

	// Internet Explorer 4+
	if ( document.all ) {
		myKeyCode=e.keyCode;
		myShiftKey=e.shiftKey;

	// Netscape 4
	} else if ( document.layers ) {
		myKeyCode=e.which;
		myShiftKey=( myKeyCode == 16 ) ? true : false;

        // Mozilla 1.4+
	} else if ( document.getElementById ) {
                // Problem: e.shiftKey is always false on NS 7.02
		myKeyCode=e.which;
		myShiftKey = e.shiftKey;
	}


	// Upper case letters are seen without depressing the Shift key, therefore Caps Lock is on
	if ( ( myKeyCode >= 65 && myKeyCode <= 90 ) && !myShiftKey ) {
		return true;

	// Lower case letters are seen while depressing the Shift key, therefore Caps Lock is on
	} else if ( ( myKeyCode >= 97 && myKeyCode <= 122 ) && myShiftKey ) {
		return true;
	}
	return false;
}

/**
 * Designed to be called onKeyPress from input fields:
 *  onkeypress="return am_checkForCapsAndEnter(capsWarningObject);"
 *
 * If Enter key is pressed, checks whether form is ready to be
 * submitted.  If so, submits, otherwise, focusses on the next element
 * in the tab order.
 *
 * First optional argument is the object to show/hide which presumably 
 * contains a "CAPS Lock is On" warning.  Second optional argument is
 * whether to loop in the tab order and is passed through to 
 * am_nextElementInTabOrder.
 *
 * Otherwise, if CAPS lock is detected to be on/off (using the 
 * checkCapsLock function) and an object to unhide is provided, it will
 * be shown/hidden.
 *
 * To determine if form is ready to submit, gets an expression to
 * evaluate from the 'enableSubmitFunction' attribute of the source
 * element's form.  The expression should evaluate to true if the form
 * is ready to be submitted, false otherwise.
 */
function am_checkForCapsAndEnter(warnElement, loopAtEnd) {

    var e = window.event || arguments.callee.caller.arguments[0];
    var el = e.srcElement || e.currentTarget || e.target;
    var enableSubmitProc = el.form.getAttribute('enableSubmitFunction');
    if (typeof(warnElement) == 'undefined') {
        var warnElement = null;
    }

    var characterCode; // literal character code will be stored in this variable

    if (e && e.which) { // if which property of event object is supported (NN4)
        characterCode = e.which;
    } else {
        e = window.event || arguments.callee.caller.arguments[0];
        characterCode = e.keyCode; // character code is contained in IE's keyCode property
    }

    // Submit the form on enter key
    if (characterCode == 13) {
        var readyForSubmit = eval(enableSubmitProc);
        if (readyForSubmit) {
            el.form.submit();
        } else {
            var nextEl = am_nextElementInTabOrder(el, loopAtEnd);
            if (nextEl) nextEl.focus();
        }
        return readyForSubmit;
    } else if (warnElement) {
       if (checkCapsLock(e)) {
            am_show(warnElement);
        } else {
            am_hide(warnElement);
        }
    }
    return true;
}




/**
 * performs style adjustments and/or executes lambda function on anchors
 * highlightObject is an object with properties 'className', 'style', 'behavior'
 * these items are applied to all <a> elements with href attribute matching current document's location
 *
 * className - a string or array of strings containing the class name(s) to add to the element
 * style - string or object containing css styles to appy
 * behavior - the name of a method in the element object to execute
 * lambda - lambda function to execute on the element. example: behavior: function(element){alert(element.href);}
 * 
 */
function am_HighlightCurrentLocation (highlightObject) {
   
    
    //if we aren't passed any parameters, don't do anything.
    if(!highlightObject.className && !highlightObject.style && !highlightObject.behavior && !hilightObject.lambda){
        return;
    }
    
    
    
    var location = new String(window.location);
    
    //remove the beginning of the url up through the domain name
    var loc = location.search(/(\.com)|(\.net)|(\.org)/);
    location = location.substring(loc+4);
    
    
    //remove any query strings
    loc = location.search(/\?/);
    if(loc!=-1){
        location = location.substring(0, loc-1);
    }
    
    //remove any anchors
    loc = location.search(/#/);
    if(loc!=-1){
        location = location.substring(0, loc-1);
    }
   //  if(window.console)
//	window.console.log(location);

    var anchors = Ext.query('a[href='+location+']');
    var element;
  //  if(window.console)
	//window.console.log(anchors.length);
	//alert(anchors.length);
    for(var x=0;x<anchors.length;x++){
            element = new Ext.Element(anchors[x]);
            if(highlightObject.className){
                anchors[x].className=highlightObject.className;
                
            }
        
            if(highlightObject.style){
                 element.applyStyles(highlightObject.style);
            }
            
            if(highlightObject.lambda){
                highlightObject.lambda(anchors[x]);
            }
            
            if(highlightObject.behavior){
                if(anchors[x][highlightObject.behavior] ){
                    anchors[x][highlightObject.behavior]();
                }
            }            
    }
    
}

/** will cause an image (which can be the el, or the first child image found within the el) to be swapped with other image(s) in a slideshow, using the passed interval as the time between changes
* 
* imageId - An element id that either is an image element or contains an image element.  If el is an element that contains an image element, then the first image returned by el.getElementsByTagName will be used
* interval - The time in milliseconds that between swaps
* additional arguments - pass in one ore more string arguments - these are the image src's that we're rotating between
*/
function am_swapimages(imageId, interval /* additional string arguements here */) {
	// start with the current image
	var ownerImage = document.getElementById(imageId);
	if (!ownerImage)
		return;			// no element with that id - quit
		
	if (ownerImage.tagName.toUpperCase() != "IMG") {
		// element exists, but not an image.  look for the first child image under this element (whatever it is...)
		var imgs = ownerImage.getElementsByTagName("img");
		if (imgs.length == 0)
			return;		// no img element under this element - quit
		ownerImage = imgs[0];
	}
		
	// create an array of image objects, this way we can start our loading and processing
	// and we'll store it in an object to manage the images.  but for now, start with the array of images
	var images = new Array();
	
	// store existing image as teh first one in the images array
	var image = new Image();
	image.src = ownerImage.src;
	images.push(image);
	
	// all the
	for (var x = 2 ; x < arguments.length ; x++) {
		// store the new images into the array
		var image = new Image();
		image.src = arguments[x];
		images.push(image);
	}
	
	// now, store the array + the current position into an object, and start the interval timer
	var obj = {"nextImage" : 1, "images" : images};
	
	// crearte our timer function. pass the object reference in so that we can iterate it.
	setInterval(function() {
		// check if image is loaded
		if (obj["images"][obj["nextImage"]].complete) {
			// loading complete - show
			ownerImage.src = obj["images"][obj["nextImage"]].src;
			// increment to next image, or start over, depending
			obj["nextImage"]++;
			if (obj["nextImage"] >= obj["images"].length)
				obj["nextImage"] = 0;
		}
	}, interval);
}

/** will cause a series of elements to alternate their visibility in a type of slideshow, using the passed interval as the time between changes
* 
* interval - The time in milliseconds that between swaps
* additional arguments - pass in one ore more string arguments - these are the element id's that we're rotating between
*/
function am_swapelements(interval) {
	// create an array of element id strings
	var elements = new Array();
	
	for (var x = 1 ; x < arguments.length ; x++) {
		// store the element id into the array
		//only store elements if they contain somthing.
		if(elementExists(arguments[x]) && document.getElementById(arguments[x]).children.length>0)
			elements.push(arguments[x]);
	}

	if(elements.length<2){
		//alert("there's less than 2 elements!");
		return;
	}
	// now, store the array + the current position into an object, and start the interval timer
	var obj = {"currentElement" : 0, "elements" : elements};
	
	// create our timer function. pass the object reference in so that we can iterate it.
	setInterval(function() {

		// turn off current element
		am_hide(obj["elements"][obj["currentElement"]], false);
		
		// move to next element
		// increment or start over, depending
		var loopCount=0;
			obj["currentElement"]++;
			if (obj["currentElement"] >= obj["elements"].length)
			obj["currentElement"] = 0;
			loopCount++;

		// show next element
		am_show(obj["elements"][obj["currentElement"]], false);
	}, interval);
}

/** replace extjs default blank image with one that's located on the  server..  This only fires if the Ext library is loaded */
if (Ext) {
	Ext.BLANK_IMAGE_URL = "http://js.dncscrub.com/extjs/resources/images/default/s.gif";
}


function elementExists(el){
	//window.console.log(typeof(el));
	if(typeof(el)=='string'){
		if(document.getElementById(el))return true;
	}
	
	else if(typeof(el)=='object'){
		if(el.style)return true;
	}
	

	return false;


}