/*!
* jQuery JavaScript Library v1.3.2
* http://jquery.com/
*
* Copyright (c) 2009 John Resig
* Dual licensed under the MIT and GPL licenses.
* http://docs.jquery.com/License
*
* Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
* Revision: 6246
*/

(function () {



    var 

    // Will speed up references to window, and allows munging its name.

	window = this,

    // Will speed up references to undefined, and allows munging its name.

	undefined,

    // Map over jQuery in case of overwrite

	_jQuery = window.jQuery,

    // Map over the $ in case of overwrite

	_$ = window.$,



	jQuery = window.jQuery = window.$ = function (selector, context) {

	    // The jQuery object is actually just the init constructor 'enhanced'

	    return new jQuery.fn.init(selector, context);

	},



    // A simple way to check for HTML strings or ID strings

    // (both of which we optimize for)

	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,

    // Is it a simple selector

	isSimple = /^.[^:#\[\.,]*$/;



    jQuery.fn = jQuery.prototype = {

        init: function (selector, context) {

            // Make sure that a selection was provided

            selector = selector || document;



            // Handle $(DOMElement)

            if (selector.nodeType) {

                this[0] = selector;

                this.length = 1;

                this.context = selector;

                return this;

            }

            // Handle HTML strings

            if (typeof selector === "string") {

                // Are we dealing with HTML string or an ID?

                var match = quickExpr.exec(selector);



                // Verify a match, and that no context was specified for #id

                if (match && (match[1] || !context)) {



                    // HANDLE: $(html) -> $(array)

                    if (match[1])

                        selector = jQuery.clean([match[1]], context);



                    // HANDLE: $("#id")

                    else {

                        var elem = document.getElementById(match[3]);



                        // Handle the case where IE and Opera return items

                        // by name instead of ID

                        if (elem && elem.id != match[3])

                            return jQuery().find(selector);



                        // Otherwise, we inject the element directly into the jQuery object

                        var ret = jQuery(elem || []);

                        ret.context = document;

                        ret.selector = selector;

                        return ret;

                    }



                    // HANDLE: $(expr, [context])

                    // (which is just equivalent to: $(content).find(expr)

                } else

                    return jQuery(context).find(selector);



                // HANDLE: $(function)

                // Shortcut for document ready

            } else if (jQuery.isFunction(selector))

                return jQuery(document).ready(selector);



            // Make sure that old selector state is passed along

            if (selector.selector && selector.context) {

                this.selector = selector.selector;

                this.context = selector.context;

            }



            return this.setArray(jQuery.isArray(selector) ?

			selector :

			jQuery.makeArray(selector));

        },



        // Start with an empty selector

        selector: "",



        // The current version of jQuery being used

        jquery: "1.3.2",



        // The number of elements contained in the matched element set

        size: function () {

            return this.length;

        },



        // Get the Nth element in the matched element set OR

        // Get the whole matched element set as a clean array

        get: function (num) {

            return num === undefined ?



            // Return a 'clean' array

			Array.prototype.slice.call(this) :



            // Return just the object

			this[num];

        },



        // Take an array of elements and push it onto the stack

        // (returning the new matched element set)

        pushStack: function (elems, name, selector) {

            // Build a new jQuery matched element set

            var ret = jQuery(elems);



            // Add the old object onto the stack (as a reference)

            ret.prevObject = this;



            ret.context = this.context;



            if (name === "find")

                ret.selector = this.selector + (this.selector ? " " : "") + selector;

            else if (name)

                ret.selector = this.selector + "." + name + "(" + selector + ")";



            // Return the newly-formed element set

            return ret;

        },



        // Force the current matched set of elements to become

        // the specified array of elements (destroying the stack in the process)

        // You should use pushStack() in order to do this, but maintain the stack

        setArray: function (elems) {

            // Resetting the length to 0, then using the native Array push

            // is a super-fast way to populate an object with array-like properties

            this.length = 0;

            Array.prototype.push.apply(this, elems);



            return this;

        },



        // Execute a callback for every element in the matched set.

        // (You can seed the arguments with an array of args, but this is

        // only used internally.)

        each: function (callback, args) {

            return jQuery.each(this, callback, args);

        },



        // Determine the position of an element within

        // the matched set of elements

        index: function (elem) {

            // Locate the position of the desired element

            return jQuery.inArray(

            // If it receives a jQuery object, the first element is used

			elem && elem.jquery ? elem[0] : elem

		, this);

        },



        attr: function (name, value, type) {

            var options = name;



            // Look for the case where we're accessing a style value

            if (typeof name === "string")

                if (value === undefined)

                    return this[0] && jQuery[type || "attr"](this[0], name);



                else {

                    options = {};

                    options[name] = value;

                }



            // Check to see if we're setting style values

            return this.each(function (i) {

                // Set all the styles

                for (name in options)

                    jQuery.attr(

					type ?

						this.style :

						this,

					name, jQuery.prop(this, options[name], type, i, name)

				);

            });

        },



        css: function (key, value) {

            // ignore negative width and height values

            if ((key == 'width' || key == 'height') && parseFloat(value) < 0)

                value = undefined;

            return this.attr(key, value, "curCSS");

        },



        text: function (text) {

            if (typeof text !== "object" && text != null)

                return this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(text));



            var ret = "";



            jQuery.each(text || this, function () {

                jQuery.each(this.childNodes, function () {

                    if (this.nodeType != 8)

                        ret += this.nodeType != 1 ?

						this.nodeValue :

						jQuery.fn.text([this]);

                });

            });



            return ret;

        },



        wrapAll: function (html) {

            if (this[0]) {

                // The elements to wrap the target around

                var wrap = jQuery(html, this[0].ownerDocument).clone();



                if (this[0].parentNode)

                    wrap.insertBefore(this[0]);



                wrap.map(function () {

                    var elem = this;



                    while (elem.firstChild)

                        elem = elem.firstChild;



                    return elem;

                }).append(this);

            }



            return this;

        },



        wrapInner: function (html) {

            return this.each(function () {

                jQuery(this).contents().wrapAll(html);

            });

        },



        wrap: function (html) {

            return this.each(function () {

                jQuery(this).wrapAll(html);

            });

        },



        append: function () {

            return this.domManip(arguments, true, function (elem) {

                if (this.nodeType == 1)

                    this.appendChild(elem);

            });

        },



        prepend: function () {

            return this.domManip(arguments, true, function (elem) {

                if (this.nodeType == 1)

                    this.insertBefore(elem, this.firstChild);

            });

        },



        before: function () {

            return this.domManip(arguments, false, function (elem) {

                this.parentNode.insertBefore(elem, this);

            });

        },



        after: function () {

            return this.domManip(arguments, false, function (elem) {

                this.parentNode.insertBefore(elem, this.nextSibling);

            });

        },



        end: function () {

            return this.prevObject || jQuery([]);

        },



        // For internal use only.

        // Behaves like an Array's method, not like a jQuery method.

        push: [].push,

        sort: [].sort,

        splice: [].splice,



        find: function (selector) {

            if (this.length === 1) {

                var ret = this.pushStack([], "find", selector);

                ret.length = 0;

                jQuery.find(selector, this[0], ret);

                return ret;

            } else {

                return this.pushStack(jQuery.unique(jQuery.map(this, function (elem) {

                    return jQuery.find(selector, elem);

                })), "find", selector);

            }

        },



        clone: function (events) {

            // Do the clone

            var ret = this.map(function () {

                if (!jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this)) {

                    // IE copies events bound via attachEvent when

                    // using cloneNode. Calling detachEvent on the

                    // clone will also remove the events from the orignal

                    // In order to get around this, we use innerHTML.

                    // Unfortunately, this means some modifications to

                    // attributes in IE that are actually only stored

                    // as properties will not be copied (such as the

                    // the name attribute on an input).

                    var html = this.outerHTML;

                    if (!html) {

                        var div = this.ownerDocument.createElement("div");

                        div.appendChild(this.cloneNode(true));

                        html = div.innerHTML;

                    }



                    return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];

                } else

                    return this.cloneNode(true);

            });



            // Copy the events from the original to the clone

            if (events === true) {

                var orig = this.find("*").andSelf(), i = 0;



                ret.find("*").andSelf().each(function () {

                    if (this.nodeName !== orig[i].nodeName)

                        return;



                    var events = jQuery.data(orig[i], "events");



                    for (var type in events) {

                        for (var handler in events[type]) {

                            jQuery.event.add(this, type, events[type][handler], events[type][handler].data);

                        }

                    }



                    i++;

                });

            }



            // Return the cloned set

            return ret;

        },



        filter: function (selector) {

            return this.pushStack(

			jQuery.isFunction(selector) &&

			jQuery.grep(this, function (elem, i) {

			    return selector.call(elem, i);

			}) ||



			jQuery.multiFilter(selector, jQuery.grep(this, function (elem) {

			    return elem.nodeType === 1;

			})), "filter", selector);

        },



        closest: function (selector) {

            var pos = jQuery.expr.match.POS.test(selector) ? jQuery(selector) : null,

			closer = 0;



            return this.map(function () {

                var cur = this;

                while (cur && cur.ownerDocument) {

                    if (pos ? pos.index(cur) > -1 : jQuery(cur).is(selector)) {

                        jQuery.data(cur, "closest", closer);

                        return cur;

                    }

                    cur = cur.parentNode;

                    closer++;

                }

            });

        },



        not: function (selector) {

            if (typeof selector === "string")

            // test special case where just one selector is passed in

                if (isSimple.test(selector))

                    return this.pushStack(jQuery.multiFilter(selector, this, true), "not", selector);

                else

                    selector = jQuery.multiFilter(selector, this);



            var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;

            return this.filter(function () {

                return isArrayLike ? jQuery.inArray(this, selector) < 0 : this != selector;

            });

        },



        add: function (selector) {

            return this.pushStack(jQuery.unique(jQuery.merge(

			this.get(),

			typeof selector === "string" ?

				jQuery(selector) :

				jQuery.makeArray(selector)

		)));

        },



        is: function (selector) {

            return !!selector && jQuery.multiFilter(selector, this).length > 0;

        },



        hasClass: function (selector) {

            return !!selector && this.is("." + selector);

        },



        val: function (value) {

            if (value === undefined) {

                var elem = this[0];



                if (elem) {

                    if (jQuery.nodeName(elem, 'option'))

                        return (elem.attributes.value || {}).specified ? elem.value : elem.text;



                    // We need to handle select boxes special

                    if (jQuery.nodeName(elem, "select")) {

                        var index = elem.selectedIndex,

						values = [],

						options = elem.options,

						one = elem.type == "select-one";



                        // Nothing was selected

                        if (index < 0)

                            return null;



                        // Loop through all the selected options

                        for (var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++) {

                            var option = options[i];



                            if (option.selected) {

                                // Get the specifc value for the option

                                value = jQuery(option).val();



                                // We don't need an array for one selects

                                if (one)

                                    return value;



                                // Multi-Selects return an array

                                values.push(value);

                            }

                        }



                        return values;

                    }



                    // Everything else, we just grab the value

                    return (elem.value || "").replace(/\r/g, "");



                }



                return undefined;

            }



            if (typeof value === "number")

                value += '';



            return this.each(function () {

                if (this.nodeType != 1)

                    return;



                if (jQuery.isArray(value) && /radio|checkbox/.test(this.type))

                    this.checked = (jQuery.inArray(this.value, value) >= 0 ||

					jQuery.inArray(this.name, value) >= 0);



                else if (jQuery.nodeName(this, "select")) {

                    var values = jQuery.makeArray(value);



                    jQuery("option", this).each(function () {

                        this.selected = (jQuery.inArray(this.value, values) >= 0 ||

						jQuery.inArray(this.text, values) >= 0);

                    });



                    if (!values.length)

                        this.selectedIndex = -1;



                } else

                    this.value = value;

            });

        },



        html: function (value) {

            return value === undefined ?

			(this[0] ?

				this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :

				null) :

			this.empty().append(value);

        },



        replaceWith: function (value) {

            return this.after(value).remove();

        },



        eq: function (i) {

            return this.slice(i, +i + 1);

        },



        slice: function () {

            return this.pushStack(Array.prototype.slice.apply(this, arguments),

			"slice", Array.prototype.slice.call(arguments).join(","));

        },



        map: function (callback) {

            return this.pushStack(jQuery.map(this, function (elem, i) {

                return callback.call(elem, i, elem);

            }));

        },



        andSelf: function () {

            return this.add(this.prevObject);

        },



        domManip: function (args, table, callback) {

            if (this[0]) {

                var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),

				scripts = jQuery.clean(args, (this[0].ownerDocument || this[0]), fragment),

				first = fragment.firstChild;



                if (first)

                    for (var i = 0, l = this.length; i < l; i++)

                        callback.call(root(this[i], first), this.length > 1 || i > 0 ?

							fragment.cloneNode(true) : fragment);



                if (scripts)

                    jQuery.each(scripts, evalScript);

            }



            return this;



            function root(elem, cur) {

                return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?

				(elem.getElementsByTagName("tbody")[0] ||

				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :

				elem;

            }

        }

    };



    // Give the init function the jQuery prototype for later instantiation

    jQuery.fn.init.prototype = jQuery.fn;



    function evalScript(i, elem) {

        if (elem.src)

            jQuery.ajax({

                url: elem.src,

                async: false,

                dataType: "script"

            });



        else

            jQuery.globalEval(elem.text || elem.textContent || elem.innerHTML || "");



        if (elem.parentNode)

            elem.parentNode.removeChild(elem);

    }



    function now() {

        return +new Date;

    }



    jQuery.extend = jQuery.fn.extend = function () {

        // copy reference to target object

        var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;



        // Handle a deep copy situation

        if (typeof target === "boolean") {

            deep = target;

            target = arguments[1] || {};

            // skip the boolean and the target

            i = 2;

        }



        // Handle case when target is a string or something (possible in deep copy)

        if (typeof target !== "object" && !jQuery.isFunction(target))

            target = {};



        // extend jQuery itself if only one argument is passed

        if (length == i) {

            target = this;

            --i;

        }



        for (; i < length; i++)

        // Only deal with non-null/undefined values

            if ((options = arguments[i]) != null)

            // Extend the base object

                for (var name in options) {

                    var src = target[name], copy = options[name];



                    // Prevent never-ending loop

                    if (target === copy)

                        continue;



                    // Recurse if we're merging object values

                    if (deep && copy && typeof copy === "object" && !copy.nodeType)

                        target[name] = jQuery.extend(deep,

                    // Never move original objects, clone them

						src || (copy.length != null ? [] : {})

					, copy);



                    // Don't bring in undefined values

                    else if (copy !== undefined)

                        target[name] = copy;



                }



        // Return the modified object

        return target;

    };



    // exclude the following css properties to add px

    var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,

    // cache defaultView

	defaultView = document.defaultView || {},

	toString = Object.prototype.toString;



    jQuery.extend({

        noConflict: function (deep) {

            window.$ = _$;



            if (deep)

                window.jQuery = _jQuery;



            return jQuery;

        },



        // See test/unit/core.js for details concerning isFunction.

        // Since version 1.3, DOM methods and functions like alert

        // aren't supported. They return false on IE (#2968).

        isFunction: function (obj) {

            return toString.call(obj) === "[object Function]";

        },



        isArray: function (obj) {

            return toString.call(obj) === "[object Array]";

        },



        // check if an element is in a (or is an) XML document

        isXMLDoc: function (elem) {

            return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||

			!!elem.ownerDocument && jQuery.isXMLDoc(elem.ownerDocument);

        },



        // Evalulates a script in a global context

        globalEval: function (data) {

            if (data && /\S/.test(data)) {

                // Inspired by code by Andrea Giammarchi

                // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

                var head = document.getElementsByTagName("head")[0] || document.documentElement,

				script = document.createElement("script");



                script.type = "text/javascript";

                if (jQuery.support.scriptEval)

                    script.appendChild(document.createTextNode(data));

                else

                    script.text = data;



                // Use insertBefore instead of appendChild  to circumvent an IE6 bug.

                // This arises when a base node is used (#2709).

                head.insertBefore(script, head.firstChild);

                head.removeChild(script);

            }

        },



        nodeName: function (elem, name) {

            return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();

        },



        // args is for internal usage only

        each: function (object, callback, args) {

            var name, i = 0, length = object.length;



            if (args) {

                if (length === undefined) {

                    for (name in object)

                        if (callback.apply(object[name], args) === false)

                            break;

                } else

                    for (; i < length; )

                        if (callback.apply(object[i++], args) === false)

                            break;



                // A special, fast, case for the most common use of each

            } else {

                if (length === undefined) {

                    for (name in object)

                        if (callback.call(object[name], name, object[name]) === false)

                            break;

                } else

                    for (var value = object[0];

					i < length && callback.call(value, i, value) !== false; value = object[++i]) { }

            }



            return object;

        },



        prop: function (elem, value, type, i, name) {

            // Handle executable functions

            if (jQuery.isFunction(value))

                value = value.call(elem, i);



            // Handle passing in a number to a CSS property

            return typeof value === "number" && type == "curCSS" && !exclude.test(name) ?

			value + "px" :

			value;

        },



        className: {

            // internal only, use addClass("class")

            add: function (elem, classNames) {

                jQuery.each((classNames || "").split(/\s+/), function (i, className) {

                    if (elem.nodeType == 1 && !jQuery.className.has(elem.className, className))

                        elem.className += (elem.className ? " " : "") + className;

                });

            },



            // internal only, use removeClass("class")

            remove: function (elem, classNames) {

                if (elem.nodeType == 1)

                    elem.className = classNames !== undefined ?

					jQuery.grep(elem.className.split(/\s+/), function (className) {

					    return !jQuery.className.has(classNames, className);

					}).join(" ") :

					"";

            },



            // internal only, use hasClass("class")

            has: function (elem, className) {

                return elem && jQuery.inArray(className, (elem.className || elem).toString().split(/\s+/)) > -1;

            }

        },



        // A method for quickly swapping in/out CSS properties to get correct calculations

        swap: function (elem, options, callback) {

            var old = {};

            // Remember the old values, and insert the new ones

            for (var name in options) {

                old[name] = elem.style[name];

                elem.style[name] = options[name];

            }



            callback.call(elem);



            // Revert the old values

            for (var name in options)

                elem.style[name] = old[name];

        },



        css: function (elem, name, force, extra) {

            if (name == "width" || name == "height") {

                var val, props = { position: "absolute", visibility: "hidden", display: "block" }, which = name == "width" ? ["Left", "Right"] : ["Top", "Bottom"];



                function getWH() {

                    val = name == "width" ? elem.offsetWidth : elem.offsetHeight;



                    if (extra === "border")

                        return;



                    jQuery.each(which, function () {

                        if (!extra)

                            val -= parseFloat(jQuery.curCSS(elem, "padding" + this, true)) || 0;

                        if (extra === "margin")

                            val += parseFloat(jQuery.curCSS(elem, "margin" + this, true)) || 0;

                        else

                            val -= parseFloat(jQuery.curCSS(elem, "border" + this + "Width", true)) || 0;

                    });

                }



                if (elem.offsetWidth !== 0)

                    getWH();

                else

                    jQuery.swap(elem, props, getWH);



                return Math.max(0, Math.round(val));

            }



            return jQuery.curCSS(elem, name, force);

        },



        curCSS: function (elem, name, force) {

            var ret, style = elem.style;



            // We need to handle opacity special in IE

            if (name == "opacity" && !jQuery.support.opacity) {

                ret = jQuery.attr(style, "opacity");



                return ret == "" ?

				"1" :

				ret;

            }



            // Make sure we're using the right name for getting the float value

            if (name.match(/float/i))

                name = styleFloat;



            if (!force && style && style[name])

                ret = style[name];



            else if (defaultView.getComputedStyle) {



                // Only "float" is needed here

                if (name.match(/float/i))

                    name = "float";



                name = name.replace(/([A-Z])/g, "-$1").toLowerCase();



                var computedStyle = defaultView.getComputedStyle(elem, null);



                if (computedStyle)

                    ret = computedStyle.getPropertyValue(name);



                // We should always get a number back from opacity

                if (name == "opacity" && ret == "")

                    ret = "1";



            } else if (elem.currentStyle) {

                var camelCase = name.replace(/\-(\w)/g, function (all, letter) {

                    return letter.toUpperCase();

                });



                ret = elem.currentStyle[name] || elem.currentStyle[camelCase];



                // From the awesome hack by Dean Edwards

                // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291



                // If we're not dealing with a regular pixel number

                // but a number that has a weird ending, we need to convert it to pixels

                if (!/^\d+(px)?$/i.test(ret) && /^\d/.test(ret)) {

                    // Remember the original values

                    var left = style.left, rsLeft = elem.runtimeStyle.left;



                    // Put in the new values to get a computed value out

                    elem.runtimeStyle.left = elem.currentStyle.left;

                    style.left = ret || 0;

                    ret = style.pixelLeft + "px";



                    // Revert the changed values

                    style.left = left;

                    elem.runtimeStyle.left = rsLeft;

                }

            }



            return ret;

        },



        clean: function (elems, context, fragment) {

            context = context || document;



            // !context.createElement fails in IE with an error but returns typeof 'object'

            if (typeof context.createElement === "undefined")

                context = context.ownerDocument || context[0] && context[0].ownerDocument || document;



            // If a single string is passed in and it's a single tag

            // just do a createElement and skip the rest

            if (!fragment && elems.length === 1 && typeof elems[0] === "string") {

                var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);

                if (match)

                    return [context.createElement(match[1])];

            }



            var ret = [], scripts = [], div = context.createElement("div");



            jQuery.each(elems, function (i, elem) {

                if (typeof elem === "number")

                    elem += '';



                if (!elem)

                    return;



                // Convert html string into DOM nodes

                if (typeof elem === "string") {

                    // Fix "XHTML"-style tags in all browsers

                    elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function (all, front, tag) {

                        return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?

						all :

						front + "></" + tag + ">";

                    });



                    // Trim whitespace, otherwise indexOf won't work as expected

                    var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();



                    var wrap =

                    // option or optgroup

					!tags.indexOf("<opt") &&

					[1, "<select multiple='multiple'>", "</select>"] ||



					!tags.indexOf("<leg") &&

					[1, "<fieldset>", "</fieldset>"] ||



					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&

					[1, "<table>", "</table>"] ||



					!tags.indexOf("<tr") &&

					[2, "<table><tbody>", "</tbody></table>"] ||



                    // <thead> matched above

					(!tags.indexOf("<td") || !tags.indexOf("<th")) &&

					[3, "<table><tbody><tr>", "</tr></tbody></table>"] ||



					!tags.indexOf("<col") &&

					[2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"] ||



                    // IE can't serialize <link> and <script> tags normally

					!jQuery.support.htmlSerialize &&

					[1, "div<div>", "</div>"] ||



					[0, "", ""];



                    // Go to html and back, then peel off extra wrappers

                    div.innerHTML = wrap[1] + elem + wrap[2];



                    // Move to the right depth

                    while (wrap[0]--)

                        div = div.lastChild;



                    // Remove IE's autoinserted <tbody> from table fragments

                    if (!jQuery.support.tbody) {



                        // String was a <table>, *may* have spurious <tbody>

                        var hasBody = /<tbody/i.test(elem),

						tbody = !tags.indexOf("<table") && !hasBody ?

							div.firstChild && div.firstChild.childNodes :



                        // String was a bare <thead> or <tfoot>

						wrap[1] == "<table>" && !hasBody ?

							div.childNodes :

							[];



                        for (var j = tbody.length - 1; j >= 0; --j)

                            if (jQuery.nodeName(tbody[j], "tbody") && !tbody[j].childNodes.length)

                                tbody[j].parentNode.removeChild(tbody[j]);



                    }



                    // IE completely kills leading whitespace when innerHTML is used

                    if (!jQuery.support.leadingWhitespace && /^\s/.test(elem))

                        div.insertBefore(context.createTextNode(elem.match(/^\s*/)[0]), div.firstChild);



                    elem = jQuery.makeArray(div.childNodes);

                }



                if (elem.nodeType)

                    ret.push(elem);

                else

                    ret = jQuery.merge(ret, elem);



            });



            if (fragment) {

                for (var i = 0; ret[i]; i++) {

                    if (jQuery.nodeName(ret[i], "script") && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript")) {

                        scripts.push(ret[i].parentNode ? ret[i].parentNode.removeChild(ret[i]) : ret[i]);

                    } else {

                        if (ret[i].nodeType === 1)

                            ret.splice.apply(ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))));

                        fragment.appendChild(ret[i]);

                    }

                }



                return scripts;

            }



            return ret;

        },



        attr: function (elem, name, value) {

            // don't set attributes on text and comment nodes

            if (!elem || elem.nodeType == 3 || elem.nodeType == 8)

                return undefined;



            var notxml = !jQuery.isXMLDoc(elem),

            // Whether we are setting (or getting)

			set = value !== undefined;



            // Try to normalize/fix the name

            name = notxml && jQuery.props[name] || name;



            // Only do all the following if this is a node (faster for style)

            // IE elem.getAttribute passes even for style

            if (elem.tagName) {



                // These attributes require special treatment

                var special = /href|src|style/.test(name);



                // Safari mis-reports the default selected property of a hidden option

                // Accessing the parent's selectedIndex property fixes it

                if (name == "selected" && elem.parentNode)

                    elem.parentNode.selectedIndex;



                // If applicable, access the attribute via the DOM 0 way

                if (name in elem && notxml && !special) {

                    if (set) {

                        // We can't allow the type property to be changed (since it causes problems in IE)

                        if (name == "type" && jQuery.nodeName(elem, "input") && elem.parentNode)

                            throw "type property can't be changed";



                        elem[name] = value;

                    }



                    // browsers index elements by id/name on forms, give priority to attributes.

                    if (jQuery.nodeName(elem, "form") && elem.getAttributeNode(name))

                        return elem.getAttributeNode(name).nodeValue;



                    // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set

                    // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/

                    if (name == "tabIndex") {

                        var attributeNode = elem.getAttributeNode("tabIndex");

                        return attributeNode && attributeNode.specified

						? attributeNode.value

						: elem.nodeName.match(/(button|input|object|select|textarea)/i)

							? 0

							: elem.nodeName.match(/^(a|area)$/i) && elem.href

								? 0

								: undefined;

                    }



                    return elem[name];

                }



                if (!jQuery.support.style && notxml && name == "style")

                    return jQuery.attr(elem.style, "cssText", value);



                if (set)

                // convert the value to a string (all browsers do this but IE) see #1070

                    elem.setAttribute(name, "" + value);



                var attr = !jQuery.support.hrefNormalized && notxml && special

                // Some attributes require a special call on IE

					? elem.getAttribute(name, 2)

					: elem.getAttribute(name);



                // Non-existent attributes return null, we normalize to undefined

                return attr === null ? undefined : attr;

            }



            // elem is actually elem.style ... set the style



            // IE uses filters for opacity

            if (!jQuery.support.opacity && name == "opacity") {

                if (set) {

                    // IE has trouble with opacity if it does not have layout

                    // Force it by setting the zoom level

                    elem.zoom = 1;



                    // Set the alpha filter to set the opacity

                    elem.filter = (elem.filter || "").replace(/alpha\([^)]*\)/, "") +

					(parseInt(value) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");

                }



                return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?

				(parseFloat(elem.filter.match(/opacity=([^)]*)/)[1]) / 100) + '' :

				"";

            }



            name = name.replace(/-([a-z])/ig, function (all, letter) {

                return letter.toUpperCase();

            });



            if (set)

                elem[name] = value;



            return elem[name];

        },



        trim: function (text) {

            return (text || "").replace(/^\s+|\s+$/g, "");

        },



        makeArray: function (array) {

            var ret = [];



            if (array != null) {

                var i = array.length;

                // The window, strings (and functions) also have 'length'

                if (i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval)

                    ret[0] = array;

                else

                    while (i)

                        ret[--i] = array[i];

            }



            return ret;

        },



        inArray: function (elem, array) {

            for (var i = 0, length = array.length; i < length; i++)

            // Use === because on IE, window == document

                if (array[i] === elem)

                    return i;



            return -1;

        },



        merge: function (first, second) {

            // We have to loop this way because IE & Opera overwrite the length

            // expando of getElementsByTagName

            var i = 0, elem, pos = first.length;

            // Also, we need to make sure that the correct elements are being returned

            // (IE returns comment nodes in a '*' query)

            if (!jQuery.support.getAll) {

                while ((elem = second[i++]) != null)

                    if (elem.nodeType != 8)

                        first[pos++] = elem;



            } else

                while ((elem = second[i++]) != null)

                    first[pos++] = elem;



            return first;

        },



        unique: function (array) {

            var ret = [], done = {};



            try {



                for (var i = 0, length = array.length; i < length; i++) {

                    var id = jQuery.data(array[i]);



                    if (!done[id]) {

                        done[id] = true;

                        ret.push(array[i]);

                    }

                }



            } catch (e) {

                ret = array;

            }



            return ret;

        },



        grep: function (elems, callback, inv) {

            var ret = [];



            // Go through the array, only saving the items

            // that pass the validator function

            for (var i = 0, length = elems.length; i < length; i++)

                if (!inv != !callback(elems[i], i))

                    ret.push(elems[i]);



            return ret;

        },



        map: function (elems, callback) {

            var ret = [];



            // Go through the array, translating each of the items to their

            // new value (or values).

            for (var i = 0, length = elems.length; i < length; i++) {

                var value = callback(elems[i], i);



                if (value != null)

                    ret[ret.length] = value;

            }



            return ret.concat.apply([], ret);

        }

    });



    // Use of jQuery.browser is deprecated.

    // It's included for backwards compatibility and plugins,

    // although they should work to migrate away.



    var userAgent = navigator.userAgent.toLowerCase();



    // Figure out what browser is being used

    jQuery.browser = {

        version: (userAgent.match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/) || [0, '0'])[1],

        safari: /webkit/.test(userAgent),

        opera: /opera/.test(userAgent),

        msie: /msie/.test(userAgent) && !/opera/.test(userAgent),

        mozilla: /mozilla/.test(userAgent) && !/(compatible|webkit)/.test(userAgent)

    };



    jQuery.each({

        parent: function (elem) { return elem.parentNode; },

        parents: function (elem) { return jQuery.dir(elem, "parentNode"); },

        next: function (elem) { return jQuery.nth(elem, 2, "nextSibling"); },

        prev: function (elem) { return jQuery.nth(elem, 2, "previousSibling"); },

        nextAll: function (elem) { return jQuery.dir(elem, "nextSibling"); },

        prevAll: function (elem) { return jQuery.dir(elem, "previousSibling"); },

        siblings: function (elem) { return jQuery.sibling(elem.parentNode.firstChild, elem); },

        children: function (elem) { return jQuery.sibling(elem.firstChild); },

        contents: function (elem) { return jQuery.nodeName(elem, "iframe") ? elem.contentDocument || elem.contentWindow.document : jQuery.makeArray(elem.childNodes); }

    }, function (name, fn) {

        jQuery.fn[name] = function (selector) {

            var ret = jQuery.map(this, fn);



            if (selector && typeof selector == "string")

                ret = jQuery.multiFilter(selector, ret);



            return this.pushStack(jQuery.unique(ret), name, selector);

        };

    });



    jQuery.each({

        appendTo: "append",

        prependTo: "prepend",

        insertBefore: "before",

        insertAfter: "after",

        replaceAll: "replaceWith"

    }, function (name, original) {

        jQuery.fn[name] = function (selector) {

            var ret = [], insert = jQuery(selector);



            for (var i = 0, l = insert.length; i < l; i++) {

                var elems = (i > 0 ? this.clone(true) : this).get();

                jQuery.fn[original].apply(jQuery(insert[i]), elems);

                ret = ret.concat(elems);

            }



            return this.pushStack(ret, name, selector);

        };

    });



    jQuery.each({

        removeAttr: function (name) {

            jQuery.attr(this, name, "");

            if (this.nodeType == 1)

                this.removeAttribute(name);

        },



        addClass: function (classNames) {

            jQuery.className.add(this, classNames);

        },



        removeClass: function (classNames) {

            jQuery.className.remove(this, classNames);

        },



        toggleClass: function (classNames, state) {

            if (typeof state !== "boolean")

                state = !jQuery.className.has(this, classNames);

            jQuery.className[state ? "add" : "remove"](this, classNames);

        },



        remove: function (selector) {

            if (!selector || jQuery.filter(selector, [this]).length) {

                // Prevent memory leaks

                jQuery("*", this).add([this]).each(function () {

                    jQuery.event.remove(this);

                    jQuery.removeData(this);

                });

                if (this.parentNode)

                    this.parentNode.removeChild(this);

            }

        },



        empty: function () {

            // Remove element nodes and prevent memory leaks

            jQuery(this).children().remove();



            // Remove any remaining nodes

            while (this.firstChild)

                this.removeChild(this.firstChild);

        }

    }, function (name, fn) {

        jQuery.fn[name] = function () {

            return this.each(fn, arguments);

        };

    });



    // Helper function used by the dimensions and offset modules

    function num(elem, prop) {

        return elem[0] && parseInt(jQuery.curCSS(elem[0], prop, true), 10) || 0;

    }

    var expando = "jQuery" + now(), uuid = 0, windowData = {};



    jQuery.extend({

        cache: {},



        data: function (elem, name, data) {

            elem = elem == window ?

			windowData :

			elem;



            var id = elem[expando];



            // Compute a unique ID for the element

            if (!id)

                id = elem[expando] = ++uuid;



            // Only generate the data cache if we're

            // trying to access or manipulate it

            if (name && !jQuery.cache[id])

                jQuery.cache[id] = {};



            // Prevent overriding the named cache with undefined values

            if (data !== undefined)

                jQuery.cache[id][name] = data;



            // Return the named cache data, or the ID for the element

            return name ?

			jQuery.cache[id][name] :

			id;

        },



        removeData: function (elem, name) {

            elem = elem == window ?

			windowData :

			elem;



            var id = elem[expando];



            // If we want to remove a specific section of the element's data

            if (name) {

                if (jQuery.cache[id]) {

                    // Remove the section of cache data

                    delete jQuery.cache[id][name];



                    // If we've removed all the data, remove the element's cache

                    name = "";



                    for (name in jQuery.cache[id])

                        break;



                    if (!name)

                        jQuery.removeData(elem);

                }



                // Otherwise, we want to remove all of the element's data

            } else {

                // Clean up the element expando

                try {

                    delete elem[expando];

                } catch (e) {

                    // IE has trouble directly removing the expando

                    // but it's ok with using removeAttribute

                    if (elem.removeAttribute)

                        elem.removeAttribute(expando);

                }



                // Completely remove the data cache

                delete jQuery.cache[id];

            }

        },

        queue: function (elem, type, data) {

            if (elem) {



                type = (type || "fx") + "queue";



                var q = jQuery.data(elem, type);



                if (!q || jQuery.isArray(data))

                    q = jQuery.data(elem, type, jQuery.makeArray(data));

                else if (data)

                    q.push(data);



            }

            return q;

        },



        dequeue: function (elem, type) {

            var queue = jQuery.queue(elem, type),

			fn = queue.shift();



            if (!type || type === "fx")

                fn = queue[0];



            if (fn !== undefined)

                fn.call(elem);

        }

    });



    jQuery.fn.extend({

        data: function (key, value) {

            var parts = key.split(".");

            parts[1] = parts[1] ? "." + parts[1] : "";



            if (value === undefined) {

                var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);



                if (data === undefined && this.length)

                    data = jQuery.data(this[0], key);



                return data === undefined && parts[1] ?

				this.data(parts[0]) :

				data;

            } else

                return this.trigger("setDa…