/*
* jQuery UI 1.7.2
*
* Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI
*/
; jQuery.ui || (function ($) {

  var _remove = $.fn.remove,
	isFF2 = $.browser.mozilla && (parseFloat($.browser.version) < 1.9);

  //Helper functions and ui object
  $.ui = {
    version: "1.7.2",

    // $.ui.plugin is deprecated.  Use the proxy pattern instead.
    plugin: {
      add: function (module, option, set) {
        var proto = $.ui[module].prototype;
        for (var i in set) {
          proto.plugins[i] = proto.plugins[i] || [];
          proto.plugins[i].push([option, set[i]]);
        }
      },
      call: function (instance, name, args) {
        var set = instance.plugins[name];
        if (!set || !instance.element[0].parentNode) { return; }

        for (var i = 0; i < set.length; i++) {
          if (instance.options[set[i][0]]) {
            set[i][1].apply(instance.element, args);
          }
        }
      }
    },

    contains: function (a, b) {
      return document.compareDocumentPosition
			? a.compareDocumentPosition(b) & 16
			: a !== b && a.contains(b);
    },

    hasScroll: function (el, a) {

      //If overflow is hidden, the element might have extra content, but the user wants to hide it
      if ($(el).css('overflow') == 'hidden') { return false; }

      var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop',
			has = false;

      if (el[scroll] > 0) { return true; }

      // TODO: determine which cases actually cause this to happen
      // if the element doesn't have the scroll set, see if it's possible to
      // set the scroll
      el[scroll] = 1;
      has = (el[scroll] > 0);
      el[scroll] = 0;
      return has;
    },

    isOverAxis: function (x, reference, size) {
      //Determines when x coordinate is over "b" element axis
      return (x > reference) && (x < (reference + size));
    },

    isOver: function (y, x, top, left, height, width) {
      //Determines when x, y coordinates is over "b" element
      return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);
    },

    keyCode: {
      BACKSPACE: 8,
      CAPS_LOCK: 20,
      COMMA: 188,
      CONTROL: 17,
      DELETE: 46,
      DOWN: 40,
      END: 35,
      ENTER: 13,
      ESCAPE: 27,
      HOME: 36,
      INSERT: 45,
      LEFT: 37,
      NUMPAD_ADD: 107,
      NUMPAD_DECIMAL: 110,
      NUMPAD_DIVIDE: 111,
      NUMPAD_ENTER: 108,
      NUMPAD_MULTIPLY: 106,
      NUMPAD_SUBTRACT: 109,
      PAGE_DOWN: 34,
      PAGE_UP: 33,
      PERIOD: 190,
      RIGHT: 39,
      SHIFT: 16,
      SPACE: 32,
      TAB: 9,
      UP: 38
    }
  };

  // WAI-ARIA normalization
  if (isFF2) {
    var attr = $.attr,
		removeAttr = $.fn.removeAttr,
		ariaNS = "http://www.w3.org/2005/07/aaa",
		ariaState = /^aria-/,
		ariaRole = /^wairole:/;

    $.attr = function (elem, name, value) {
      var set = value !== undefined;

      return (name == 'role'
			? (set
				? attr.call(this, elem, name, "wairole:" + value)
				: (attr.apply(this, arguments) || "").replace(ariaRole, ""))
			: (ariaState.test(name)
				? (set
					? elem.setAttributeNS(ariaNS,
						name.replace(ariaState, "aaa:"), value)
					: attr.call(this, elem, name.replace(ariaState, "aaa:")))
				: attr.apply(this, arguments)));
    };

    $.fn.removeAttr = function (name) {
      return (ariaState.test(name)
			? this.each(function () {
			  this.removeAttributeNS(ariaNS, name.replace(ariaState, ""));
			}) : removeAttr.call(this, name));
    };
  }

  //jQuery plugins
  $.fn.extend({
    remove: function () {
      // Safari has a native remove event which actually removes DOM elements,
      // so we have to use triggerHandler instead of trigger (#3037).
      $("*", this).add(this).each(function () {
        $(this).triggerHandler("remove");
      });
      return _remove.apply(this, arguments);
    },

    enableSelection: function () {
      return this
			.attr('unselectable', 'off')
			.css('MozUserSelect', '')
			.unbind('selectstart.ui');
    },

    disableSelection: function () {
      return this
			.attr('unselectable', 'on')
			.css('MozUserSelect', 'none')
			.bind('selectstart.ui', function () { return false; });
    },

    scrollParent: function () {
      var scrollParent;
      if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
        scrollParent = this.parents().filter(function () {
          return (/(relative|absolute|fixed)/).test($.curCSS(this, 'position', 1)) && (/(auto|scroll)/).test($.curCSS(this, 'overflow', 1) + $.curCSS(this, 'overflow-y', 1) + $.curCSS(this, 'overflow-x', 1));
        }).eq(0);
      } else {
        scrollParent = this.parents().filter(function () {
          return (/(auto|scroll)/).test($.curCSS(this, 'overflow', 1) + $.curCSS(this, 'overflow-y', 1) + $.curCSS(this, 'overflow-x', 1));
        }).eq(0);
      }

      return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
    }
  });


  //Additional selectors
  $.extend($.expr[':'], {
    data: function (elem, i, match) {
      return !!$.data(elem, match[3]);
    },

    focusable: function (element) {
      var nodeName = element.nodeName.toLowerCase(),
			tabIndex = $.attr(element, 'tabindex');
      return (/input|select|textarea|button|object/.test(nodeName)
			? !element.disabled
			: 'a' == nodeName || 'area' == nodeName
				? element.href || !isNaN(tabIndex)
				: !isNaN(tabIndex))
      // the element and all of its ancestors must be visible
      // the browser may report that the area is hidden
			&& !$(element)['area' == nodeName ? 'parents' : 'closest'](':hidden').length;
    },

    tabbable: function (element) {
      var tabIndex = $.attr(element, 'tabindex');
      return (isNaN(tabIndex) || tabIndex >= 0) && $(element).is(':focusable');
    }
  });


  // $.widget is a factory to create jQuery plugins
  // taking some boilerplate code out of the plugin code
  function getter(namespace, plugin, method, args) {
    function getMethods(type) {
      var methods = $[namespace][plugin][type] || [];
      return (typeof methods == 'string' ? methods.split(/,?\s+/) : methods);
    }

    var methods = getMethods('getter');
    if (args.length == 1 && typeof args[0] == 'string') {
      methods = methods.concat(getMethods('getterSetter'));
    }
    return ($.inArray(method, methods) != -1);
  }

  $.widget = function (name, prototype) {
    var namespace = name.split(".")[0];
    name = name.split(".")[1];

    // create plugin method
    $.fn[name] = function (options) {
      var isMethodCall = (typeof options == 'string'),
			args = Array.prototype.slice.call(arguments, 1);

      // prevent calls to internal methods
      if (isMethodCall && options.substring(0, 1) == '_') {
        return this;
      }

      // handle getter methods
      if (isMethodCall && getter(namespace, name, options, args)) {
        var instance = $.data(this[0], name);
        return (instance ? instance[options].apply(instance, args)
				: undefined);
      }

      // handle initialization and non-getter methods
      return this.each(function () {
        var instance = $.data(this, name);

        // constructor
        (!instance && !isMethodCall &&
				$.data(this, name, new $[namespace][name](this, options))._init());

        // method call
        (instance && isMethodCall && $.isFunction(instance[options]) &&
				instance[options].apply(instance, args));
      });
    };

    // create widget constructor
    $[namespace] = $[namespace] || {};
    $[namespace][name] = function (element, options) {
      var self = this;

      this.namespace = namespace;
      this.widgetName = name;
      this.widgetEventPrefix = $[namespace][name].eventPrefix || name;
      this.widgetBaseClass = namespace + '-' + name;

      this.options = $.extend({},
			$.widget.defaults,
			$[namespace][name].defaults,
			$.metadata && $.metadata.get(element)[name],
			options);

      this.element = $(element)
			.bind('setData.' + name, function (event, key, value) {
			  if (event.target == element) {
			    return self._setData(key, value);
			  }
			})
			.bind('getData.' + name, function (event, key) {
			  if (event.target == element) {
			    return self._getData(key);
			  }
			})
			.bind('remove', function () {
			  return self.destroy();
			});
    };

    // add widget prototype
    $[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);

    // TODO: merge getter and getterSetter properties from widget prototype
    // and plugin prototype
    $[namespace][name].getterSetter = 'option';
  };

  $.widget.prototype = {
    _init: function () { },
    destroy: function () {
      this.element.removeData(this.widgetName)
			.removeClass(this.widgetBaseClass + '-disabled' + ' ' + this.namespace + '-state-disabled')
			.removeAttr('aria-disabled');
    },

    option: function (key, value) {
      var options = key,
			self = this;

      if (typeof key == "string") {
        if (value === undefined) {
          return this._getData(key);
        }
        options = {};
        options[key] = value;
      }

      $.each(options, function (key, value) {
        self._setData(key, value);
      });
    },
    _getData: function (key) {
      return this.options[key];
    },
    _setData: function (key, value) {
      this.options[key] = value;

      if (key == 'disabled') {
        this.element
				[value ? 'addClass' : 'removeClass'](
					this.widgetBaseClass + '-disabled' + ' ' +
					this.namespace + '-state-disabled')
				.attr("aria-disabled", value);
      }
    },

    enable: function () {
      this._setData('disabled', false);
    },
    disable: function () {
      this._setData('disabled', true);
    },

    _trigger: function (type, event, data) {
      var callback = this.options[type],
			eventName = (type == this.widgetEventPrefix
				? type : this.widgetEventPrefix + type);

      event = $.Event(event);
      event.type = eventName;

      // copy original event properties over to the new event
      // this would happen if we could call $.event.fix instead of $.Event
      // but we don't have a way to force an event to be fixed multiple times
      if (event.originalEvent) {
        for (var i = $.event.props.length, prop; i; ) {
          prop = $.event.props[--i];
          event[prop] = event.originalEvent[prop];
        }
      }

      this.element.trigger(event, data);

      return !($.isFunction(callback) && callback.call(this.element[0], event, data) === false
			|| event.isDefaultPrevented());
    }
  };

  $.widget.defaults = {
    disabled: false
  };


  /** Mouse Interaction Plugin **/

  $.ui.mouse = {
    _mouseInit: function () {
      var self = this;

      this.element
			.bind('mousedown.' + this.widgetName, function (event) {
			  return self._mouseDown(event);
			})
			.bind('click.' + this.widgetName, function (event) {
			  if (self._preventClickEvent) {
			    self._preventClickEvent = false;
			    event.stopImmediatePropagation();
			    return false;
			  }
			});

      // Prevent text selection in IE
      if ($.browser.msie) {
        this._mouseUnselectable = this.element.attr('unselectable');
        this.element.attr('unselectable', 'on');
      }

      this.started = false;
    },

    // TODO: make sure destroying one instance of mouse doesn't mess with
    // other instances of mouse
    _mouseDestroy: function () {
      this.element.unbind('.' + this.widgetName);

      // Restore text selection in IE
      ($.browser.msie
			&& this.element.attr('unselectable', this._mouseUnselectable));
    },

    _mouseDown: function (event) {
      // don't let more than one widget handle mouseStart
      // TODO: figure out why we have to use originalEvent
      event.originalEvent = event.originalEvent || {};
      if (event.originalEvent.mouseHandled) { return; }

      // we may have missed mouseup (out of window)
      (this._mouseStarted && this._mouseUp(event));

      this._mouseDownEvent = event;

      var self = this,
			btnIsLeft = (event.which == 1),
			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
      if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
        return true;
      }

      this.mouseDelayMet = !this.options.delay;
      if (!this.mouseDelayMet) {
        this._mouseDelayTimer = setTimeout(function () {
          self.mouseDelayMet = true;
        }, this.options.delay);
      }

      if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
        this._mouseStarted = (this._mouseStart(event) !== false);
        if (!this._mouseStarted) {
          event.preventDefault();
          return true;
        }
      }

      // these delegates are required to keep context
      this._mouseMoveDelegate = function (event) {
        return self._mouseMove(event);
      };
      this._mouseUpDelegate = function (event) {
        return self._mouseUp(event);
      };
      $(document)
			.bind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.bind('mouseup.' + this.widgetName, this._mouseUpDelegate);

      // preventDefault() is used to prevent the selection of text here -
      // however, in Safari, this causes select boxes not to be selectable
      // anymore, so this fix is needed
      ($.browser.safari || event.preventDefault());

      event.originalEvent.mouseHandled = true;
      return true;
    },

    _mouseMove: function (event) {
      // IE mouseup check - mouseup happened when mouse was out of window
      if ($.browser.msie && !event.button) {
        return this._mouseUp(event);
      }

      if (this._mouseStarted) {
        this._mouseDrag(event);
        return event.preventDefault();
      }

      if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
        this._mouseStarted =
				(this._mouseStart(this._mouseDownEvent, event) !== false);
        (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
      }

      return !this._mouseStarted;
    },

    _mouseUp: function (event) {
      $(document)
			.unbind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.unbind('mouseup.' + this.widgetName, this._mouseUpDelegate);

      if (this._mouseStarted) {
        this._mouseStarted = false;
        this._preventClickEvent = (event.target == this._mouseDownEvent.target);
        this._mouseStop(event);
      }

      return false;
    },

    _mouseDistanceMet: function (event) {
      return (Math.max(
				Math.abs(this._mouseDownEvent.pageX - event.pageX),
				Math.abs(this._mouseDownEvent.pageY - event.pageY)
			) >= this.options.distance
		);
    },

    _mouseDelayMet: function (event) {
      return this.mouseDelayMet;
    },

    // These are placeholder methods, to be overriden by extending plugin
    _mouseStart: function (event) { },
    _mouseDrag: function (event) { },
    _mouseStop: function (event) { },
    _mouseCapture: function (event) { return true; }
  };

  $.ui.mouse.defaults = {
    cancel: null,
    distance: 1,
    delay: 0
  };

})(jQuery);



/*
* jQuery UI Accordion 1.7.2
*
* Copyright (c) 2009 AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* http://docs.jquery.com/UI/Accordion
*
* Depends:
*	ui.core.js
*/
(function ($) {

  $.widget("ui.accordion", {

    _init: function () {

      var o = this.options, self = this;
      this.running = 0;

      // if the user set the alwaysOpen option on init
      // then we need to set the collapsible option
      // if they set both on init, collapsible will take priority
      if (o.collapsible == $.ui.accordion.defaults.collapsible &&
			o.alwaysOpen != $.ui.accordion.defaults.alwaysOpen) {
        o.collapsible = !o.alwaysOpen;
      }

      if (o.navigation) {
        var current = this.element.find("a").filter(o.navigationFilter);
        if (current.length) {
          if (current.filter(o.header).length) {
            this.active = current;
          } else {
            this.active = current.parent().parent().prev();
            current.addClass("ui-accordion-content-active");
          }
        }
      }

      this.element.addClass("ui-accordion ui-widget ui-helper-reset");

      // in lack of child-selectors in CSS we need to mark top-LIs in a UL-accordion for some IE-fix
      if (this.element[0].nodeName == "UL") {
        this.element.children("li").addClass("ui-accordion-li-fix");
      }

      this.headers = this.element.find(o.header).addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all")
			.bind("mouseenter.accordion", function () { $(this).addClass('ui-state-hover'); })
			.bind("mouseleave.accordion", function () { $(this).removeClass('ui-state-hover'); })
			.bind("focus.accordion", function () { $(this).addClass('ui-state-focus'); })
			.bind("blur.accordion", function () { $(this).removeClass('ui-state-focus'); });

      this.headers
			.next()
				.addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom");

      this.active = this._findActive(this.active || o.active).toggleClass("ui-state-default").toggleClass("ui-state-active").toggleClass("ui-corner-all").toggleClass("ui-corner-top");
      this.active.next().addClass('ui-accordion-content-active');

      //Append icon elements
      $("<span/>").addClass("ui-icon " + o.icons.header).prependTo(this.headers);
      this.active.find(".ui-icon").toggleClass(o.icons.header).toggleClass(o.icons.headerSelected);

      // IE7-/Win - Extra vertical space in lists fixed
      if ($.browser.msie) {
        this.element.find('a').css('zoom', '1');
      }

      this.resize();

      //ARIA
      this.element.attr('role', 'tablist');

      this.headers
			.attr('role', 'tab')
			.bind('keydown', function (event) { return self._keydown(event); })
			.next()
			.attr('role', 'tabpanel');

      this.headers
			.not(this.active || "")
			.attr('aria-expanded', 'false')
			.attr("tabIndex", "-1")
			.next()
			.hide();

      // make sure at least one header is in the tab order
      if (!this.active.length) {
        this.headers.eq(0).attr('tabIndex', '0');
      } else {
        this.active
				.attr('aria-expanded', 'true')
				.attr('tabIndex', '0');
      }

      // only need links in taborder for Safari
      if (!$.browser.safari)
        this.headers.find('a').attr('tabIndex', '-1');

      if (o.event) {
        this.headers.bind((o.event) + ".accordion", function (event) { return self._clickHandler.call(self, event, this); });
      }

    },

    destroy: function () {
      var o = this.options;

      this.element
			.removeClass("ui-accordion ui-widget ui-helper-reset")
			.removeAttr("role")
			.unbind('.accordion')
			.removeData('accordion');

      this.headers
			.unbind(".accordion")
			.removeClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-corner-top")
			.removeAttr("role").removeAttr("aria-expanded").removeAttr("tabindex");

      this.headers.find("a").removeAttr("tabindex");
      this.headers.children(".ui-icon").remove();
      var contents = this.headers.next().css("display", "").removeAttr("role").removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active");
      if (o.autoHeight || o.fillHeight) {
        contents.css("height", "");
      }
    },

    _setData: function (key, value) {
      if (key == 'alwaysOpen') { key = 'collapsible'; value = !value; }
      $.widget.prototype._setData.apply(this, arguments);
    },

    _keydown: function (event) {

      var o = this.options, keyCode = $.ui.keyCode;

      if (o.disabled || event.altKey || event.ctrlKey)
        return;

      var length = this.headers.length;
      var currentIndex = this.headers.index(event.target);
      var toFocus = false;

      switch (event.keyCode) {
        case keyCode.RIGHT:
        case keyCode.DOWN:
          toFocus = this.headers[(currentIndex + 1) % length];
          break;
        case keyCode.LEFT:
        case keyCode.UP:
          toFocus = this.headers[(currentIndex - 1 + length) % length];
          break;
        case keyCode.SPACE:
        case keyCode.ENTER:
          return this._clickHandler({ target: event.target }, event.target);
      }

      if (toFocus) {
        $(event.target).attr('tabIndex', '-1');
        $(toFocus).attr('tabIndex', '0');
        toFocus.focus();
        return false;
      }

      return true;

    },

    resize: function () {

      var o = this.options, maxHeight;

      if (o.fillSpace) {

        if ($.browser.msie) { var defOverflow = this.element.parent().css('overflow'); this.element.parent().css('overflow', 'hidden'); }
        maxHeight = this.element.parent().height();
        if ($.browser.msie) { this.element.parent().css('overflow', defOverflow); }

        this.headers.each(function () {
          maxHeight -= $(this).outerHeight();
        });

        var maxPadding = 0;
        this.headers.next().each(function () {
          maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
        }).height(Math.max(0, maxHeight - maxPadding))
			.css('overflow', 'auto');

      } else if (o.autoHeight) {
        maxHeight = 0;
        this.headers.next().each(function () {
          maxHeight = Math.max(maxHeight, $(this).outerHeight());
        }).height(maxHeight);
      }

    },

    activate: function (index) {
      // call clickHandler with custom event
      var active = this._findActive(index)[0];
      this._clickHandler({ target: active }, active);
    },

    _findActive: function (selector) {
      return selector
			? typeof selector == "number"
				? this.headers.filter(":eq(" + selector + ")")
				: this.headers.not(this.headers.not(selector))
			: selector === false
				? $([])
				: this.headers.filter(":eq(0)");
    },

    _clickHandler: function (event, target) {

      var o = this.options;
      if (o.disabled) return false;

      // called only when using activate(false) to close all parts programmatically
      if (!event.target && o.collapsible) {
        this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
				.find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
        this.active.next().addClass('ui-accordion-content-active');
        var toHide = this.active.next(),
				data = {
				  options: o,
				  newHeader: $([]),
				  oldHeader: o.active,
				  newContent: $([]),
				  oldContent: toHide
				},
				toShow = (this.active = $([]));
        this._toggle(toShow, toHide, data);
        return false;
      }

      // get the click target
      var clicked = $(event.currentTarget || target);
      var clickedIsActive = clicked[0] == this.active[0];

      // if animations are still active, or the active header is the target, ignore click
      if (this.running || (!o.collapsible && clickedIsActive)) {
        return false;
      }

      // switch classes
      this.active.removeClass("ui-state-active ui-corner-top").addClass("ui-state-default ui-corner-all")
			.find(".ui-icon").removeClass(o.icons.headerSelected).addClass(o.icons.header);
      this.active.next().addClass('ui-accordion-content-active');
      if (!clickedIsActive) {
        clicked.removeClass("ui-state-default ui-corner-all").addClass("ui-state-active ui-corner-top")
				.find(".ui-icon").removeClass(o.icons.header).addClass(o.icons.headerSelected);
        clicked.next().addClass('ui-accordion-content-active');
      }

      // find elements to show and hide
      var toShow = clicked.next(),
			toHide = this.active.next(),
			data = {
			  options: o,
			  newHeader: clickedIsActive && o.collapsible ? $([]) : clicked,
			  oldHeader: this.active,
			  newContent: clickedIsActive && o.collapsible ? $([]) : toShow.find('> *'),
			  oldContent: toHide.find('> *')
			},
			down = this.headers.index(this.active[0]) > this.headers.index(clicked[0]);

      this.active = clickedIsActive ? $([]) : clicked;
      this._toggle(toShow, toHide, data, clickedIsActive, down);

      return false;

    },

    _toggle: function (toShow, toHide, data, clickedIsActive, down) {

      var o = this.options, self = this;

      this.toShow = toShow;
      this.toHide = toHide;
      this.data = data;

      var complete = function () { if (!self) return; return self._completed.apply(self, arguments); };

      // trigger changestart event
      this._trigger("changestart", null, this.data);

      // count elements to animate
      this.running = toHide.size() === 0 ? toShow.size() : toHide.size();

      if (o.animated) {

        var animOptions = {};

        if (o.collapsible && clickedIsActive) {
          animOptions = {
            toShow: $([]),
            toHide: toHide,
            complete: complete,
            down: down,
            autoHeight: o.autoHeight || o.fillSpace
          };
        } else {
          animOptions = {
            toShow: toShow,
            toHide: toHide,
            complete: complete,
            down: down,
            autoHeight: o.autoHeight || o.fillSpace
          };
        }

        if (!o.proxied) {
          o.proxied = o.animated;
        }

        if (!o.proxiedDuration) {
          o.proxiedDuration = o.duration;
        }

        o.animated = $.isFunction(o.proxied) ?
				o.proxied(animOptions) : o.proxied;

        o.duration = $.isFunction(o.proxiedDuration) ?
				o.proxiedDuration(animOptions) : o.proxiedDuration;

        var animations = $.ui.accordion.animations,
				duration = o.duration,
				easing = o.animated;

        if (!animations[easing]) {
          animations[easing] = function (options) {
            this.slide(options, {
              easing: easing,
              duration: duration || 700
            });
          };
        }

        animations[easing](animOptions);

      } else {

        if (o.collapsible && clickedIsActive) {
          toShow.toggle();
        } else {
          toHide.hide();
          toShow.show();
        }

        complete(true);

      }

      toHide.prev().attr('aria-expanded', 'false').attr("tabIndex", "-1").blur();
      toShow.prev().attr('aria-expanded', 'true').attr("tabIndex", "0").focus();

    },

    _completed: function (cancel) {

      var o = this.options;

      this.running = cancel ? 0 : --this.running;
      if (this.running) return;

      if (o.clearStyle) {
        this.toShow.add(this.toHide).css({
          height: "",
          overflow: ""
        });
      }

      this._trigger('change', null, this.data);
    }

  });


  $.extend($.ui.accordion, {
    version: "1.7.2",
    defaults: {
      active: null,
      alwaysOpen: true, //deprecated, use collapsible
      animated: 'slide',
      autoHeight: true,
      clearStyle: false,
      collapsible: false,
      event: "click",
      fillSpace: false,
      header: "> li > :first-child,> :not(li):even",
      icons: {
        header: "ui-icon-triangle-1-e",
        headerSelected: "ui-icon-triangle-1-s"
      },
      navigation: false,
      navigationFilter: function () {
        return this.href.toLowerCase() == location.href.toLowerCase();
      }
    },
    animations: {
      slide: function (options, additions) {
        options = $.extend({
          easing: "swing",
          duration: 300
        }, options, additions);
        if (!options.toHide.size()) {
          options.toShow.animate({ height: "show" }, options);
          return;
        }
        if (!options.toShow.size()) {
          options.toHide.animate({ height: "hide" }, options);
          return;
        }
        var overflow = options.toShow.css('overflow'),
				percentDone,
				showProps = {},
				hideProps = {},
				fxAttrs = ["height", "paddingTop", "paddingBottom"],
				originalWidth;
        // fix width before calculating height of hidden element
        var s = options.toShow;
        originalWidth = s[0].style.width;
        s.width(parseInt(s.parent().width(), 10) - parseInt(s.css("paddingLeft"), 10) - parseInt(s.css("paddingRight"), 10) - (parseInt(s.css("borderLeftWidth"), 10) || 0) - (parseInt(s.css("borderRightWidth"), 10) || 0));

        $.each(fxAttrs, function (i, prop) {
          hideProps[prop] = 'hide';

          var parts = ('' + $.css(options.toShow[0], prop)).match(/^([\d+-.]+)(.*)$/);
          showProps[prop] = {
            value: parts[1],
            unit: parts[2] || 'px'
          };
        });
        options.toShow.css({ height: 0, overflow: 'hidden' }).show();
        options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate(hideProps, {
          step: function (now, settings) {
            // only calculate the percent when animating height
            // IE gets very inconsistent results when animating elements
            // with small values, which is common for padding
            if (settings.prop == 'height') {
              percentDone = (settings.now - settings.start) / (settings.end - settings.start);
            }

            options.toShow[0].style[settings.prop] =
						(percentDone * showProps[settings.prop].value) + showProps[settings.prop].unit;
          },
          duration: options.duration,
          easing: options.easing,
          complete: function () {
            if (!options.autoHeight) {
              options.toShow.css("height", "");
            }
            options.toShow.css("width", originalWidth);
            options.toShow.css({ overflow: overflow });
            options.complete();
          }
        });
      },
      bounceslide: function (options) {
        this.slide(options, {
          easing: options.down ? "easeOutBounce" : "swing",
          duration: options.down ? 1000 : 200
        });
      },
      easeslide: function (options) {
        this.slide(options, {
          easing: "easeinout",
          duration: 700
        });
      }
    }
  });

})(jQuery);