/*
 * 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 Slider 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/Slider
 *
 * Depends:
 *    ui.core.js
 */

(function($) {

$.widget("ui.slider", $.extend({}, $.ui.mouse, {

    _init: function() {

        var self = this, o = this.options;
        this._keySliding = false;
        this._handleIndex = null;
        this._detectOrientation();
        this._mouseInit();

        this.element
            .addClass("ui-slider"
                + " ui-slider-" + this.orientation
                + " ui-widget"
                + " ui-widget-content"
                + " ui-corner-all");

        this.range = $([]);

        if (o.range) {

            if (o.range === true) {
                this.range = $('<div></div>');
                if (!o.values) o.values = [this._valueMin(), this._valueMin()];
                if (o.values.length && o.values.length != 2) {
                    o.values = [o.values[0], o.values[0]];
                }
            } else {
                this.range = $('<div></div>');
            }

            this.range
                .appendTo(this.element)
                .addClass("ui-slider-range");

            if (o.range == "min" || o.range == "max") {
                this.range.addClass("ui-slider-range-" + o.range);
            }

            // note: this isn't the most fittingly semantic framework class for this element,
            // but worked best visually with a variety of themes
            this.range.addClass("ui-widget-header");

        }

        if ($(".ui-slider-handle", this.element).length == 0)
            $('<a href="#"></a>')
                .appendTo(this.element)
                .addClass("ui-slider-handle");

        if (o.values && o.values.length) {
            while ($(".ui-slider-handle", this.element).length < o.values.length)
                $('<a href="#"></a>')
                    .appendTo(this.element)
                    .addClass("ui-slider-handle");
        }

        this.handles = $(".ui-slider-handle", this.element)
            .addClass("ui-state-default"
                + " ui-corner-all");

        this.handle = this.handles.eq(0);

        this.handles.add(this.range).filter("a")
            .click(function(event) {
                event.preventDefault();
            })
            .hover(function() {
                if (!o.disabled) {
                    $(this).addClass('ui-state-hover');
                }
            }, function() {
                $(this).removeClass('ui-state-hover');
            })
            .focus(function() {
                if (!o.disabled) {
                    $(".ui-slider .ui-state-focus").removeClass('ui-state-focus'); $(this).addClass('ui-state-focus');
                } else {
                    $(this).blur();
                }
            })
            .blur(function() {
                $(this).removeClass('ui-state-focus');
            });

        this.handles.each(function(i) {
            $(this).data("index.ui-slider-handle", i);
        });

        this.handles.keydown(function(event) {

            var ret = true;

            var index = $(this).data("index.ui-slider-handle");

            if (self.options.disabled)
                return;

            switch (event.keyCode) {
                case $.ui.keyCode.HOME:
                case $.ui.keyCode.END:
                case $.ui.keyCode.UP:
                case $.ui.keyCode.RIGHT:
                case $.ui.keyCode.DOWN:
                case $.ui.keyCode.LEFT:
                    ret = false;
                    if (!self._keySliding) {
                        self._keySliding = true;
                        $(this).addClass("ui-state-active");
                        self._start(event, index);
                    }
                    break;
            }

            var curVal, newVal, step = self._step();
            if (self.options.values && self.options.values.length) {
                curVal = newVal = self.values(index);
            } else {
                curVal = newVal = self.value();
            }

            switch (event.keyCode) {
                case $.ui.keyCode.HOME:
                    newVal = self._valueMin();
                    break;
                case $.ui.keyCode.END:
                    newVal = self._valueMax();
                    break;
                case $.ui.keyCode.UP:
                case $.ui.keyCode.RIGHT:
                    if(curVal == self._valueMax()) return;
                    newVal = curVal + step;
                    break;
                case $.ui.keyCode.DOWN:
                case $.ui.keyCode.LEFT:
                    if(curVal == self._valueMin()) return;
                    newVal = curVal - step;
                    break;
            }

            self._slide(event, index, newVal);

            return ret;

        }).keyup(function(event) {

            var index = $(this).data("index.ui-slider-handle");

            if (self._keySliding) {
                self._stop(event, index);
                self._change(event, index);
                self._keySliding = false;
                $(this).removeClass("ui-state-active");
            }

        });

        this._refreshValue();

    },

    destroy: function() {

        this.handles.remove();
        this.range.remove();

        this.element
            .removeClass("ui-slider"
                + " ui-slider-horizontal"
                + " ui-slider-vertical"
                + " ui-slider-disabled"
                + " ui-widget"
                + " ui-widget-content"
                + " ui-corner-all")
            .removeData("slider")
            .unbind(".slider");

        this._mouseDestroy();

    },

    _mouseCapture: function(event) {

        var o = this.options;

        if (o.disabled)
            return false;

        this.elementSize = {
            width: this.element.outerWidth(),
            height: this.element.outerHeight()
        };
        this.elementOffset = this.element.offset();

        var position = { x: event.pageX, y: event.pageY };
        var normValue = this._normValueFromMouse(position);

        var distance = this._valueMax() - this._valueMin() + 1, closestHandle;
        var self = this, index;
        this.handles.each(function(i) {
            var thisDistance = Math.abs(normValue - self.values(i));
            if (distance > thisDistance) {
                distance = thisDistance;
                closestHandle = $(this);
                index = i;
            }
        });

        // workaround for bug #3736 (if both handles of a range are at 0,
        // the first is always used as the one with least distance,
        // and moving it is obviously prevented by preventing negative ranges)
        if(o.range == true && this.values(1) == o.min) {
            closestHandle = $(this.handles[++index]);
        }

        this._start(event, index);

        self._handleIndex = index;

        closestHandle
            .addClass("ui-state-active")
            .focus();

        var offset = closestHandle.offset();
        var mouseOverHandle = !$(event.target).parents().andSelf().is('.ui-slider-handle');
        this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
            left: event.pageX - offset.left - (closestHandle.width() / 2),
            top: event.pageY - offset.top
                - (closestHandle.height() / 2)
                - (parseInt(closestHandle.css('borderTopWidth'),10) || 0)
                - (parseInt(closestHandle.css('borderBottomWidth'),10) || 0)
                + (parseInt(closestHandle.css('marginTop'),10) || 0)
        };

        normValue = this._normValueFromMouse(position);
        this._slide(event, index, normValue);
        return true;

    },

    _mouseStart: function(event) {
        return true;
    },

    _mouseDrag: function(event) {

        var position = { x: event.pageX, y: event.pageY };
        var normValue = this._normValueFromMouse(position);

        this._slide(event, this._handleIndex, normValue);

        return false;

    },

    _mouseStop: function(event) {

        this.handles.removeClass("ui-state-active");
        this._stop(event, this._handleIndex);
        this._change(event, this._handleIndex);
        this._handleIndex = null;
        this._clickOffset = null;

        return false;

    },

    _detectOrientation: function() {
        this.orientation = this.options.orientation == 'vertical' ? 'vertical' : 'horizontal';
    },

    _normValueFromMouse: function(position) {

        var pixelTotal, pixelMouse;
        if ('horizontal' == this.orientation) {
            pixelTotal = this.elementSize.width;
            pixelMouse = position.x - this.elementOffset.left - (this._clickOffset ? this._clickOffset.left : 0);
        } else {
            pixelTotal = this.elementSize.height;
            pixelMouse = position.y - this.elementOffset.top - (this._clickOffset ? this._clickOffset.top : 0);
        }

        var percentMouse = (pixelMouse / pixelTotal);
        if (percentMouse > 1) percentMouse = 1;
        if (percentMouse < 0) percentMouse = 0;
        if ('vertical' == this.orientation)
            percentMouse = 1 - percentMouse;

        var valueTotal = this._valueMax() - this._valueMin(),
            valueMouse = percentMouse * valueTotal,
            valueMouseModStep = valueMouse % this.options.step,
            normValue = this._valueMin() + valueMouse - valueMouseModStep;

        if (valueMouseModStep > (this.options.step / 2))
            normValue += this.options.step;

        // Since JavaScript has problems with large floats, round
        // the final value to 5 digits after the decimal point (see #4124)
        return parseFloat(normValue.toFixed(5));

    },

    _start: function(event, index) {
        var uiHash = {
            handle: this.handles[index],
            value: this.value()
        };
        if (this.options.values && this.options.values.length) {
            uiHash.value = this.values(index);
            uiHash.values = this.values();
        }
        this._trigger("start", event, uiHash);
    },

    _slide: function(event, index, newVal) {

        var handle = this.handles[index];

        if (this.options.values && this.options.values.length) {

            var otherVal = this.values(index ? 0 : 1);

            if ((this.options.values.length == 2 && this.options.range === true) &&
                ((index == 0 && newVal > otherVal) || (index == 1 && newVal < otherVal))){
                 newVal = otherVal;
            }

            if (newVal != this.values(index)) {
                var newValues = this.values();
                newValues[index] = newVal;
                // A slide can be canceled by returning false from the slide callback
                var allowed = this._trigger("slide", event, {
                    handle: this.handles[index],
                    value: newVal,
                    values: newValues
                });
                var otherVal = this.values(index ? 0 : 1);
                if (allowed !== false) {
                    this.values(index, newVal, ( event.type == 'mousedown' && this.options.animate ), true);
                }
            }

        } else {

            if (newVal != this.value()) {
                // A slide can be canceled by returning false from the slide callback
                var allowed = this._trigger("slide", event, {
                    handle: this.handles[index],
                    value: newVal
                });
                if (allowed !== false) {
                    this._setData('value', newVal, ( event.type == 'mousedown' && this.options.animate ));
                }

            }

        }

    },

    _stop: function(event, index) {
        var uiHash = {
            handle: this.handles[index],
            value: this.value()
        };
        if (this.options.values && this.options.values.length) {
            uiHash.value = this.values(index);
            uiHash.values = this.values();
        }
        this._trigger("stop", event, uiHash);
    },

    _change: function(event, index) {
        var uiHash = {
            handle: this.handles[index],
            value: this.value()
        };
        if (this.options.values && this.options.values.length) {
            uiHash.value = this.values(index);
            uiHash.values = this.values();
        }
        this._trigger("change", event, uiHash);
    },

    value: function(newValue) {

        if (arguments.length) {
            this._setData("value", newValue);
            this._change(null, 0);
        }

        return this._value();

    },

    values: function(index, newValue, animated, noPropagation) {

        if (arguments.length > 1) {
            this.options.values[index] = newValue;
            this._refreshValue(animated);
            if(!noPropagation) this._change(null, index);
        }

        if (arguments.length) {
            if (this.options.values && this.options.values.length) {
                return this._values(index);
            } else {
                return this.value();
            }
        } else {
            return this._values();
        }

    },

    _setData: function(key, value, animated) {

        $.widget.prototype._setData.apply(this, arguments);

        switch (key) {
            case 'disabled':
                if (value) {
                    this.handles.filter(".ui-state-focus").blur();
                    this.handles.removeClass("ui-state-hover");
                    this.handles.attr("disabled", "disabled");
                } else {
                    this.handles.removeAttr("disabled");
                }
            case 'orientation':

                this._detectOrientation();

                this.element
                    .removeClass("ui-slider-horizontal ui-slider-vertical")
                    .addClass("ui-slider-" + this.orientation);
                this._refreshValue(animated);
                break;
            case 'value':
                this._refreshValue(animated);
                break;
        }

    },

    _step: function() {
        var step = this.options.step;
        return step;
    },

    _value: function() {

        var val = this.options.value;
        if (val < this._valueMin()) val = this._valueMin();
        if (val > this._valueMax()) val = this._valueMax();

        return val;

    },

    _values: function(index) {

        if (arguments.length) {
            var val = this.options.values[index];
            if (val < this._valueMin()) val = this._valueMin();
            if (val > this._valueMax()) val = this._valueMax();

            return val;
        } else {
            return this.options.values;
        }

    },

    _valueMin: function() {
        var valueMin = this.options.min;
        return valueMin;
    },

    _valueMax: function() {
        var valueMax = this.options.max;
        return valueMax;
    },

    _refreshValue: function(animate) {

        var oRange = this.options.range, o = this.options, self = this;

        if (this.options.values && this.options.values.length) {
            var vp0, vp1;
            this.handles.each(function(i, j) {
                var valPercent = (self.values(i) - self._valueMin()) / (self._valueMax() - self._valueMin()) * 100;
                var _set = {}; _set[self.orientation == 'horizontal' ? 'left' : 'bottom'] = valPercent + '%';
                $(this).stop(1,1)[animate ? 'animate' : 'css'](_set, o.animate);
                if (self.options.range === true) {
                    if (self.orientation == 'horizontal') {
                        (i == 0) && self.range.stop(1,1)[animate ? 'animate' : 'css']({ left: valPercent + '%' }, o.animate);
                        (i == 1) && self.range[animate ? 'animate' : 'css']({ width: (valPercent - lastValPercent) + '%' }, { queue: false, duration: o.animate });
                    } else {
                        (i == 0) && self.range.stop(1,1)[animate ? 'animate' : 'css']({ bottom: (valPercent) + '%' }, o.animate);
                        (i == 1) && self.range[animate ? 'animate' : 'css']({ height: (valPercent - lastValPercent) + '%' }, { queue: false, duration: o.animate });
                    }
                }
                lastValPercent = valPercent;
            });
        } else {
            var value = this.value(),
                valueMin = this._valueMin(),
                valueMax = this._valueMax(),
                valPercent = valueMax != valueMin
                    ? (value - valueMin) / (valueMax - valueMin) * 100
                    : 0;
            var _set = {}; _set[self.orientation == 'horizontal' ? 'left' : 'bottom'] = valPercent + '%';
            this.handle.stop(1,1)[animate ? 'animate' : 'css'](_set, o.animate);

            (oRange == "min") && (this.orientation == "horizontal") && this.range.stop(1,1)[animate ? 'animate' : 'css']({ width: valPercent + '%' }, o.animate);
            (oRange == "max") && (this.orientation == "horizontal") && this.range[animate ? 'animate' : 'css']({ width: (100 - valPercent) + '%' }, { queue: false, duration: o.animate });
            (oRange == "min") && (this.orientation == "vertical") && this.range.stop(1,1)[animate ? 'animate' : 'css']({ height: valPercent + '%' }, o.animate);
            (oRange == "max") && (this.orientation == "vertical") && this.range[animate ? 'animate' : 'css']({ height: (100 - valPercent) + '%' }, { queue: false, duration: o.animate });
        }

    }

}));

$.extend($.ui.slider, {
    getter: "value values",
    version: "1.7.2",
    eventPrefix: "slide",
    defaults: {
        animate: false,
        delay: 0,
        distance: 0,
        max: 100,
        min: 0,
        orientation: 'horizontal',
        range: false,
        step: 1,
        value: 0,
        values: null
    }
});

})(jQuery);
/*
 * jQuery UI Effects 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/Effects/
 */
;jQuery.effects || (function($) {

$.effects = {
    version: "1.7.2",

    // Saves a set of properties in a data storage
    save: function(element, set) {
        for(var i=0; i < set.length; i++) {
            if(set[i] !== null) element.data("ec.storage."+set[i], element[0].style[set[i]]);
        }
    },

    // Restores a set of previously saved properties from a data storage
    restore: function(element, set) {
        for(var i=0; i < set.length; i++) {
            if(set[i] !== null) element.css(set[i], element.data("ec.storage."+set[i]));
        }
    },

    setMode: function(el, mode) {
        if (mode == 'toggle') mode = el.is(':hidden') ? 'show' : 'hide'; // Set for toggle
        return mode;
    },

    getBaseline: function(origin, original) { // Translates a [top,left] array into a baseline value
        // this should be a little more flexible in the future to handle a string & hash
        var y, x;
        switch (origin[0]) {
            case 'top': y = 0; break;
            case 'middle': y = 0.5; break;
            case 'bottom': y = 1; break;
            default: y = origin[0] / original.height;
        };
        switch (origin[1]) {
            case 'left': x = 0; break;
            case 'center': x = 0.5; break;
            case 'right': x = 1; break;
            default: x = origin[1] / original.width;
        };
        return {x: x, y: y};
    },

    // Wraps the element around a wrapper that copies position properties
    createWrapper: function(element) {

        //if the element is already wrapped, return it
        if (element.parent().is('.ui-effects-wrapper'))
            return element.parent();

        //Cache width,height and float properties of the element, and create a wrapper around it
        var props = { width: element.outerWidth(true), height: element.outerHeight(true), 'float': element.css('float') };
        element.wrap('<div class="ui-effects-wrapper" style="font-size:100%;background:transparent;border:none;margin:0;padding:0"></div>');
        var wrapper = element.parent();

        //Transfer the positioning of the element to the wrapper
        if (element.css('position') == 'static') {
            wrapper.css({ position: 'relative' });
            element.css({ position: 'relative'} );
        } else {
            var top = element.css('top'); if(isNaN(parseInt(top,10))) top = 'auto';
            var left = element.css('left'); if(isNaN(parseInt(left,10))) left = 'auto';
            wrapper.css({ position: element.css('position'), top: top, left: left, zIndex: element.css('z-index') }).show();
            element.css({position: 'relative', top: 0, left: 0 });
        }

        wrapper.css(props);
        return wrapper;
    },

    removeWrapper: function(element) {
        if (element.parent().is('.ui-effects-wrapper'))
            return element.parent().replaceWith(element);
        return element;
    },

    setTransition: function(element, list, factor, value) {
        value = value || {};
        $.each(list, function(i, x){
            unit = element.cssUnit(x);
            if (unit[0] > 0) value[x] = unit[0] * factor + unit[1];
        });
        return value;
    },

    //Base function to animate from one class to another in a seamless transition
    animateClass: function(value, duration, easing, callback) {

        var cb = (typeof easing == "function" ? easing : (callback ? callback : null));
        var ea = (typeof easing == "string" ? easing : null);

        return this.each(function() {

            var offset = {}; var that = $(this); var oldStyleAttr = that.attr("style") || '';
            if(typeof oldStyleAttr == 'object') oldStyleAttr = oldStyleAttr["cssText"]; /* Stupidly in IE, style is a object.. */
            if(value.toggle) { that.hasClass(value.toggle) ? value.remove = value.toggle : value.add = value.toggle; }

            //Let's get a style offset
            var oldStyle = $.extend({}, (document.defaultView ? document.defaultView.getComputedStyle(this,null) : this.currentStyle));
            if(value.add) that.addClass(value.add); if(value.remove) that.removeClass(value.remove);
            var newStyle = $.extend({}, (document.defaultView ? document.defaultView.getComputedStyle(this,null) : this.currentStyle));
            if(value.add) that.removeClass(value.add); if(value.remove) that.addClass(value.remove);

            // The main function to form the object for animation
            for(var n in newStyle) {
                if( typeof newStyle[n] != "function" && newStyle[n] /* No functions and null properties */
                && n.indexOf("Moz") == -1 && n.indexOf("length") == -1 /* No mozilla spezific render properties. */
                && newStyle[n] != oldStyle[n] /* Only values that have changed are used for the animation */
                && (n.match(/color/i) || (!n.match(/color/i) && !isNaN(parseInt(newStyle[n],10)))) /* Only things that can be parsed to integers or colors */
                && (oldStyle.position != "static" || (oldStyle.position == "static" && !n.match(/left|top|bottom|right/))) /* No need for positions when dealing with static positions */
                ) offset[n] = newStyle[n];
            }

            that.animate(offset, duration, ea, function() { // Animate the newly constructed offset object
                // Change style attribute back to original. For stupid IE, we need to clear the damn object.
                if(typeof $(this).attr("style") == 'object') { $(this).attr("style")["cssText"] = ""; $(this).attr("style")["cssText"] = oldStyleAttr; } else $(this).attr("style", oldStyleAttr);
                if(value.add) $(this).addClass(value.add); if(value.remove) $(this).removeClass(value.remove);
                if(cb) cb.apply(this, arguments);
            });

        });
    }
};


function _normalizeArguments(a, m) {

    var o = a[1] && a[1].constructor == Object ? a[1] : {}; if(m) o.mode = m;
    var speed = a[1] && a[1].constructor != Object ? a[1] : (o.duration ? o.duration : a[2]); //either comes from options.duration or the secon/third argument
        speed = $.fx.off ? 0 : typeof speed === "number" ? speed : $.fx.speeds[speed] || $.fx.speeds._default;
    var callback = o.callback || ( $.isFunction(a[1]) && a[1] ) || ( $.isFunction(a[2]) && a[2] ) || ( $.isFunction(a[3]) && a[3] );

    return [a[0], o, speed, callback];

}

//Extend the methods of jQuery
$.fn.extend({

    //Save old methods
    _show: $.fn.show,
    _hide: $.fn.hide,
    __toggle: $.fn.toggle,
    _addClass: $.fn.addClass,
    _removeClass: $.fn.removeClass,
    _toggleClass: $.fn.toggleClass,

    // New effect methods
    effect: function(fx, options, speed, callback) {
        return $.effects[fx] ? $.effects[fx].call(this, {method: fx, options: options || {}, duration: speed, callback: callback }) : null;
    },

    show: function() {
        if(!arguments[0] || (arguments[0].constructor == Number || (/(slow|normal|fast)/).test(arguments[0])))
            return this._show.apply(this, arguments);
        else {
            return this.effect.apply(this, _normalizeArguments(arguments, 'show'));
        }
    },

    hide: function() {
        if(!arguments[0] || (arguments[0].constructor == Number || (/(slow|normal|fast)/).test(arguments[0])))
            return this._hide.apply(this, arguments);
        else {
            return this.effect.apply(this, _normalizeArguments(arguments, 'hide'));
        }
    },

    toggle: function(){
        if(!arguments[0] ||
            (arguments[0].constructor == Number || (/(slow|normal|fast)/).test(arguments[0])) ||
            ($.isFunction(arguments[0]) || typeof arguments[0] == 'boolean')) {
            return this.__toggle.apply(this, arguments);
        } else {
            return this.effect.apply(this, _normalizeArguments(arguments, 'toggle'));
        }
    },

    addClass: function(classNames, speed, easing, callback) {
        return speed ? $.effects.animateClass.apply(this, [{ add: classNames },speed,easing,callback]) : this._addClass(classNames);
    },
    removeClass: function(classNames,speed,easing,callback) {
        return speed ? $.effects.animateClass.apply(this, [{ remove: classNames },speed,easing,callback]) : this._removeClass(classNames);
    },
    toggleClass: function(classNames,speed,easing,callback) {
        return ( (typeof speed !== "boolean") && speed ) ? $.effects.animateClass.apply(this, [{ toggle: classNames },speed,easing,callback]) : this._toggleClass(classNames, speed);
    },
    morph: function(remove,add,speed,easing,callback) {
        return $.effects.animateClass.apply(this, [{ add: add, remove: remove },speed,easing,callback]);
    },
    switchClass: function() {
        return this.morph.apply(this, arguments);
    },

    // helper functions
    cssUnit: function(key) {
        var style = this.css(key), val = [];
        $.each( ['em','px','%','pt'], function(i, unit){
            if(style.indexOf(unit) > 0)
                val = [parseFloat(style), unit];
        });
        return val;
    }
});

/*
 * jQuery Color Animations
 * Copyright 2007 John Resig
 * Released under the MIT and GPL licenses.
 */

// We override the animation for all of these color styles
$.each(['backgroundColor', 'borderBottomColor', 'borderLeftColor', 'borderRightColor', 'borderTopColor', 'color', 'outlineColor'], function(i,attr){
        $.fx.step[attr] = function(fx) {
                if ( fx.state == 0 ) {
                        fx.start = getColor( fx.elem, attr );
                        fx.end = getRGB( fx.end );
                }

                fx.elem.style[attr] = "rgb(" + [
                        Math.max(Math.min( parseInt((fx.pos * (fx.end[0] - fx.start[0])) + fx.start[0],10), 255), 0),
                        Math.max(Math.min( parseInt((fx.pos * (fx.end[1] - fx.start[1])) + fx.start[1],10), 255), 0),
                        Math.max(Math.min( parseInt((fx.pos * (fx.end[2] - fx.start[2])) + fx.start[2],10), 255), 0)
                ].join(",") + ")";
            };
});

// Color Conversion functions from highlightFade
// By Blair Mitchelmore
// http://jquery.offput.ca/highlightFade/

// Parse strings looking for color tuples [255,255,255]
function getRGB(color) {
        var result;

        // Check if we're already dealing with an array of colors
        if ( color && color.constructor == Array && color.length == 3 )
                return color;

        // Look for rgb(num,num,num)
        if (result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(color))
                return [parseInt(result[1],10), parseInt(result[2],10), parseInt(result[3],10)];

        // Look for rgb(num%,num%,num%)
        if (result = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*,\s*([0-9]+(?:\.[0-9]+)?)\%\s*\)/.exec(color))
                return [parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55];

        // Look for #a0b1c2
        if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(color))
                return [parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16)];

        // Look for #fff
        if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(color))
                return [parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16)];

        // Look for rgba(0, 0, 0, 0) == transparent in Safari 3
        if (result = /rgba\(0, 0, 0, 0\)/.exec(color))
                return colors['transparent'];

        // Otherwise, we're most likely dealing with a named color
        return colors[$.trim(color).toLowerCase()];
}

function getColor(elem, attr) {
        var color;

        do {
                color = $.curCSS(elem, attr);

                // Keep going until we find an element that has color, or we hit the body
                if ( color != '' && color != 'transparent' || $.nodeName(elem, "body") )
                        break;

                attr = "backgroundColor";
        } while ( elem = elem.parentNode );

        return getRGB(color);
};

// Some named colors to work with
// From Interface by Stefan Petre
// http://interface.eyecon.ro/

var colors = {
    aqua:[0,255,255],
    azure:[240,255,255],
    beige:[245,245,220],
    black:[0,0,0],
    blue:[0,0,255],
    brown:[165,42,42],
    cyan:[0,255,255],
    darkblue:[0,0,139],
    darkcyan:[0,139,139],
    darkgrey:[169,169,169],
    darkgreen:[0,100,0],
    darkkhaki:[189,183,107],
    darkmagenta:[139,0,139],
    darkolivegreen:[85,107,47],
    darkorange:[255,140,0],
    darkorchid:[153,50,204],
    darkred:[139,0,0],
    darksalmon:[233,150,122],
    darkviolet:[148,0,211],
    fuchsia:[255,0,255],
    gold:[255,215,0],
    green:[0,128,0],
    indigo:[75,0,130],
    khaki:[240,230,140],
    lightblue:[173,216,230],
    lightcyan:[224,255,255],
    lightgreen:[144,238,144],
    lightgrey:[211,211,211],
    lightpink:[255,182,193],
    lightyellow:[255,255,224],
    lime:[0,255,0],
    magenta:[255,0,255],
    maroon:[128,0,0],
    navy:[0,0,128],
    olive:[128,128,0],
    orange:[255,165,0],
    pink:[255,192,203],
    purple:[128,0,128],
    violet:[128,0,128],
    red:[255,0,0],
    silver:[192,192,192],
    white:[255,255,255],
    yellow:[255,255,0],
    transparent: [255,255,255]
};

/*
 * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
 *
 * Uses the built in easing capabilities added In jQuery 1.1
 * to offer multiple easing options
 *
 * TERMS OF USE - jQuery Easing
 *
 * Open source under the BSD License.
 *
 * Copyright 2008 George McGinley Smith
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * Neither the name of the author nor the names of contributors may be used to endorse
 * or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

// t: current time, b: begInnIng value, c: change In value, d: duration
$.easing.jswing = $.easing.swing;

$.extend($.easing,
{
    def: 'easeOutQuad',
    swing: function (x, t, b, c, d) {
        //alert($.easing.default);
        return $.easing[$.easing.def](x, t, b, c, d);
    },
    easeInQuad: function (x, t, b, c, d) {
        return c*(t/=d)*t + b;
    },
    easeOutQuad: function (x, t, b, c, d) {
        return -c *(t/=d)*(t-2) + b;
    },
    easeInOutQuad: function (x, t, b, c, d) {
        if ((t/=d/2) < 1) return c/2*t*t + b;
        return -c/2 * ((--t)*(t-2) - 1) + b;
    },
    easeInCubic: function (x, t, b, c, d) {
        return c*(t/=d)*t*t + b;
    },
    easeOutCubic: function (x, t, b, c, d) {
        return c*((t=t/d-1)*t*t + 1) + b;
    },
    easeInOutCubic: function (x, t, b, c, d) {
        if ((t/=d/2) < 1) return c/2*t*t*t + b;
        return c/2*((t-=2)*t*t + 2) + b;
    },
    easeInQuart: function (x, t, b, c, d) {
        return c*(t/=d)*t*t*t + b;
    },
    easeOutQuart: function (x, t, b, c, d) {
        return -c * ((t=t/d-1)*t*t*t - 1) + b;
    },
    easeInOutQuart: function (x, t, b, c, d) {
        if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
        return -c/2 * ((t-=2)*t*t*t - 2) + b;
    },
    easeInQuint: function (x, t, b, c, d) {
        return c*(t/=d)*t*t*t*t + b;
    },
    easeOutQuint: function (x, t, b, c, d) {
        return c*((t=t/d-1)*t*t*t*t + 1) + b;
    },
    easeInOutQuint: function (x, t, b, c, d) {
        if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
        return c/2*((t-=2)*t*t*t*t + 2) + b;
    },
    easeInSine: function (x, t, b, c, d) {
        return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
    },
    easeOutSine: function (x, t, b, c, d) {
        return c * Math.sin(t/d * (Math.PI/2)) + b;
    },
    easeInOutSine: function (x, t, b, c, d) {
        return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
    },
    easeInExpo: function (x, t, b, c, d) {
        return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
    },
    easeOutExpo: function (x, t, b, c, d) {
        return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
    },
    easeInOutExpo: function (x, t, b, c, d) {
        if (t==0) return b;
        if (t==d) return b+c;
        if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
        return c/2 * (-Math.pow(2, -10 * --t) + 2) + b;
    },
    easeInCirc: function (x, t, b, c, d) {
        return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
    },
    easeOutCirc: function (x, t, b, c, d) {
        return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
    },
    easeInOutCirc: function (x, t, b, c, d) {
        if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
        return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
    },
    easeInElastic: function (x, t, b, c, d) {
        var s=1.70158;var p=0;var a=c;
        if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
        if (a < Math.abs(c)) { a=c; var s=p/4; }
        else var s = p/(2*Math.PI) * Math.asin (c/a);
        return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
    },
    easeOutElastic: function (x, t, b, c, d) {
        var s=1.70158;var p=0;var a=c;
        if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
        if (a < Math.abs(c)) { a=c; var s=p/4; }
        else var s = p/(2*Math.PI) * Math.asin (c/a);
        return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
    },
    easeInOutElastic: function (x, t, b, c, d) {
        var s=1.70158;var p=0;var a=c;
        if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) p=d*(.3*1.5);
        if (a < Math.abs(c)) { a=c; var s=p/4; }
        else var s = p/(2*Math.PI) * Math.asin (c/a);
        if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
        return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
    },
    easeInBack: function (x, t, b, c, d, s) {
        if (s == undefined) s = 1.70158;
        return c*(t/=d)*t*((s+1)*t - s) + b;
    },
    easeOutBack: function (x, t, b, c, d, s) {
        if (s == undefined) s = 1.70158;
        return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
    },
    easeInOutBack: function (x, t, b, c, d, s) {
        if (s == undefined) s = 1.70158;
        if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
        return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
    },
    easeInBounce: function (x, t, b, c, d) {
        return c - $.easing.easeOutBounce (x, d-t, 0, c, d) + b;
    },
    easeOutBounce: function (x, t, b, c, d) {
        if ((t/=d) < (1/2.75)) {
            return c*(7.5625*t*t) + b;
        } else if (t < (2/2.75)) {
            return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
        } else if (t < (2.5/2.75)) {
            return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
        } else {
            return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
        }
    },
    easeInOutBounce: function (x, t, b, c, d) {
        if (t < d/2) return $.easing.easeInBounce (x, t*2, 0, c, d) * .5 + b;
        return $.easing.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b;
    }
});

/*
 *
 * TERMS OF USE - EASING EQUATIONS
 *
 * Open source under the BSD License.
 *
 * Copyright 2001 Robert Penner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * Neither the name of the author nor the names of contributors may be used to endorse
 * or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

})(jQuery);
/*
 * jQuery UI Effects Blind 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/Effects/Blind
 *
 * Depends:
 *    effects.core.js
 */
(function($) {

$.effects.blind = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this), props = ['position','top','left'];

        // Set options
        var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
        var direction = o.options.direction || 'vertical'; // Default direction

        // Adjust
        $.effects.save(el, props); el.show(); // Save & Show
        var wrapper = $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
        var ref = (direction == 'vertical') ? 'height' : 'width';
        var distance = (direction == 'vertical') ? wrapper.height() : wrapper.width();
        if(mode == 'show') wrapper.css(ref, 0); // Shift

        // Animation
        var animation = {};
        animation[ref] = mode == 'show' ? distance : 0;

        // Animate
        wrapper.animate(animation, o.duration, o.options.easing, function() {
            if(mode == 'hide') el.hide(); // Hide
            $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
            if(o.callback) o.callback.apply(el[0], arguments); // Callback
            el.dequeue();
        });

    });

};

})(jQuery);
/*
 * jQuery UI Effects Drop 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/Effects/Drop
 *
 * Depends:
 *    effects.core.js
 */
(function($) {

$.effects.drop = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this), props = ['position','top','left','opacity'];

        // Set options
        var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
        var direction = o.options.direction || 'left'; // Default Direction

        // Adjust
        $.effects.save(el, props); el.show(); // Save & Show
        $.effects.createWrapper(el); // Create Wrapper
        var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
        var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
        var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) / 2 : el.outerWidth({margin:true}) / 2);
        if (mode == 'show') el.css('opacity', 0).css(ref, motion == 'pos' ? -distance : distance); // Shift

        // Animation
        var animation = {opacity: mode == 'show' ? 1 : 0};
        animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;

        // Animate
        el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
            if(mode == 'hide') el.hide(); // Hide
            $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
            if(o.callback) o.callback.apply(this, arguments); // Callback
            el.dequeue();
        }});

    });

};

})(jQuery);
/*
 * jQuery UI Effects Highlight 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/Effects/Highlight
 *
 * Depends:
 *    effects.core.js
 */
(function($) {

$.effects.highlight = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this), props = ['backgroundImage','backgroundColor','opacity'];

        // Set options
        var mode = $.effects.setMode(el, o.options.mode || 'show'); // Set Mode
        var color = o.options.color || "#ffff99"; // Default highlight color
        var oldColor = el.css("backgroundColor");

        // Adjust
        $.effects.save(el, props); el.show(); // Save & Show
        el.css({backgroundImage: 'none', backgroundColor: color}); // Shift

        // Animation
        var animation = {backgroundColor: oldColor };
        if (mode == "hide") animation['opacity'] = 0;

        // Animate
        el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
            if(mode == "hide") el.hide();
            $.effects.restore(el, props);
        if (mode == "show" && $.browser.msie) this.style.removeAttribute('filter');
            if(o.callback) o.callback.apply(this, arguments);
            el.dequeue();
        }});

    });

};

})(jQuery);
/*
 * jQuery UI Effects Scale 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/Effects/Scale
 *
 * Depends:
 *    effects.core.js
 */
(function($) {

$.effects.puff = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this);

        // Set options
        var options = $.extend(true, {}, o.options);
        var mode = $.effects.setMode(el, o.options.mode || 'hide'); // Set Mode
        var percent = parseInt(o.options.percent,10) || 150; // Set default puff percent
        options.fade = true; // It's not a puff if it doesn't fade! :)
        var original = {height: el.height(), width: el.width()}; // Save original

        // Adjust
        var factor = percent / 100;
        el.from = (mode == 'hide') ? original : {height: original.height * factor, width: original.width * factor};

        // Animation
        options.from = el.from;
        options.percent = (mode == 'hide') ? percent : 100;
        options.mode = mode;

        // Animate
        el.effect('scale', options, o.duration, o.callback);
        el.dequeue();
    });

};

$.effects.scale = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this);

        // Set options
        var options = $.extend(true, {}, o.options);
        var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
        var percent = parseInt(o.options.percent,10) || (parseInt(o.options.percent,10) == 0 ? 0 : (mode == 'hide' ? 0 : 100)); // Set default scaling percent
        var direction = o.options.direction || 'both'; // Set default axis
        var origin = o.options.origin; // The origin of the scaling
        if (mode != 'effect') { // Set default origin and restore for show/hide
            options.origin = origin || ['middle','center'];
            options.restore = true;
        }
        var original = {height: el.height(), width: el.width()}; // Save original
        el.from = o.options.from || (mode == 'show' ? {height: 0, width: 0} : original); // Default from state

        // Adjust
        var factor = { // Set scaling factor
            y: direction != 'horizontal' ? (percent / 100) : 1,
            x: direction != 'vertical' ? (percent / 100) : 1
        };
        el.to = {height: original.height * factor.y, width: original.width * factor.x}; // Set to state

        if (o.options.fade) { // Fade option to support puff
            if (mode == 'show') {el.from.opacity = 0; el.to.opacity = 1;};
            if (mode == 'hide') {el.from.opacity = 1; el.to.opacity = 0;};
        };

        // Animation
        options.from = el.from; options.to = el.to; options.mode = mode;

        // Animate
        el.effect('size', options, o.duration, o.callback);
        el.dequeue();
    });

};

$.effects.size = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this), props = ['position','top','left','width','height','overflow','opacity'];
        var props1 = ['position','top','left','overflow','opacity']; // Always restore
        var props2 = ['width','height','overflow']; // Copy for children
        var cProps = ['fontSize'];
        var vProps = ['borderTopWidth', 'borderBottomWidth', 'paddingTop', 'paddingBottom'];
        var hProps = ['borderLeftWidth', 'borderRightWidth', 'paddingLeft', 'paddingRight'];

        // Set options
        var mode = $.effects.setMode(el, o.options.mode || 'effect'); // Set Mode
        var restore = o.options.restore || false; // Default restore
        var scale = o.options.scale || 'both'; // Default scale mode
        var origin = o.options.origin; // The origin of the sizing
        var original = {height: el.height(), width: el.width()}; // Save original
        el.from = o.options.from || original; // Default from state
        el.to = o.options.to || original; // Default to state
        // Adjust
        if (origin) { // Calculate baseline shifts
            var baseline = $.effects.getBaseline(origin, original);
            el.from.top = (original.height - el.from.height) * baseline.y;
            el.from.left = (original.width - el.from.width) * baseline.x;
            el.to.top = (original.height - el.to.height) * baseline.y;
            el.to.left = (original.width - el.to.width) * baseline.x;
        };
        var factor = { // Set scaling factor
            from: {y: el.from.height / original.height, x: el.from.width / original.width},
            to: {y: el.to.height / original.height, x: el.to.width / original.width}
        };
        if (scale == 'box' || scale == 'both') { // Scale the css box
            if (factor.from.y != factor.to.y) { // Vertical props scaling
                props = props.concat(vProps);
                el.from = $.effects.setTransition(el, vProps, factor.from.y, el.from);
                el.to = $.effects.setTransition(el, vProps, factor.to.y, el.to);
            };
            if (factor.from.x != factor.to.x) { // Horizontal props scaling
                props = props.concat(hProps);
                el.from = $.effects.setTransition(el, hProps, factor.from.x, el.from);
                el.to = $.effects.setTransition(el, hProps, factor.to.x, el.to);
            };
        };
        if (scale == 'content' || scale == 'both') { // Scale the content
            if (factor.from.y != factor.to.y) { // Vertical props scaling
                props = props.concat(cProps);
                el.from = $.effects.setTransition(el, cProps, factor.from.y, el.from);
                el.to = $.effects.setTransition(el, cProps, factor.to.y, el.to);
            };
        };
        $.effects.save(el, restore ? props : props1); el.show(); // Save & Show
        $.effects.createWrapper(el); // Create Wrapper
        el.css('overflow','hidden').css(el.from); // Shift

        // Animate
        if (scale == 'content' || scale == 'both') { // Scale the children
            vProps = vProps.concat(['marginTop','marginBottom']).concat(cProps); // Add margins/font-size
            hProps = hProps.concat(['marginLeft','marginRight']); // Add margins
            props2 = props.concat(vProps).concat(hProps); // Concat
            el.find("*[width]").each(function(){
                child = $(this);
                if (restore) $.effects.save(child, props2);
                var c_original = {height: child.height(), width: child.width()}; // Save original
                child.from = {height: c_original.height * factor.from.y, width: c_original.width * factor.from.x};
                child.to = {height: c_original.height * factor.to.y, width: c_original.width * factor.to.x};
                if (factor.from.y != factor.to.y) { // Vertical props scaling
                    child.from = $.effects.setTransition(child, vProps, factor.from.y, child.from);
                    child.to = $.effects.setTransition(child, vProps, factor.to.y, child.to);
                };
                if (factor.from.x != factor.to.x) { // Horizontal props scaling
                    child.from = $.effects.setTransition(child, hProps, factor.from.x, child.from);
                    child.to = $.effects.setTransition(child, hProps, factor.to.x, child.to);
                };
                child.css(child.from); // Shift children
                child.animate(child.to, o.duration, o.options.easing, function(){
                    if (restore) $.effects.restore(child, props2); // Restore children
                }); // Animate children
            });
        };

        // Animate
        el.animate(el.to, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
            if(mode == 'hide') el.hide(); // Hide
            $.effects.restore(el, restore ? props : props1); $.effects.removeWrapper(el); // Restore
            if(o.callback) o.callback.apply(this, arguments); // Callback
            el.dequeue();
        }});

    });

};

})(jQuery);
/*
 * jQuery UI Effects Slide 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/Effects/Slide
 *
 * Depends:
 *    effects.core.js
 */
(function($) {

$.effects.slide = function(o) {

    return this.queue(function() {

        // Create element
        var el = $(this), props = ['position','top','left'];

        // Set options
        var mode = $.effects.setMode(el, o.options.mode || 'show'); // Set Mode
        var direction = o.options.direction || 'left'; // Default Direction

        // Adjust
        $.effects.save(el, props); el.show(); // Save & Show
        $.effects.createWrapper(el).css({overflow:'hidden'}); // Create Wrapper
        var ref = (direction == 'up' || direction == 'down') ? 'top' : 'left';
        var motion = (direction == 'up' || direction == 'left') ? 'pos' : 'neg';
        var distance = o.options.distance || (ref == 'top' ? el.outerHeight({margin:true}) : el.outerWidth({margin:true}));
        if (mode == 'show') el.css(ref, motion == 'pos' ? -distance : distance); // Shift

        // Animation
        var animation = {};
        animation[ref] = (mode == 'show' ? (motion == 'pos' ? '+=' : '-=') : (motion == 'pos' ? '-=' : '+=')) + distance;

        // Animate
        el.animate(animation, { queue: false, duration: o.duration, easing: o.options.easing, complete: function() {
            if(mode == 'hide') el.hide(); // Hide
            $.effects.restore(el, props); $.effects.removeWrapper(el); // Restore
            if(o.callback) o.callback.apply(this, arguments); // Callback
            el.dequeue();
        }});

    });

};

})(jQuery);

