(function(a) {
    if (typeof define === "function" && define.amd) {
        define(["jquery"], function(b) {
            return a(b, window)
        })
    } else {
        if (typeof module === "object" && module.exports) {
            module.exports = a(require("jquery"), window)
        } else {
            a(jQuery, window)
        }
    }
}
)(function(v, H) {
    v.migrateVersion = "x.x.x";
    function J(W, U) {
        var S, R = /^(\d+)\.(\d+)\.(\d+)/, T = R.exec(W) || [], V = R.exec(U) || [];
        for (S = 1; S <= 3; S++) {
            if (+T[S] > +V[S]) {
                return 1
            }
            if (+T[S] < +V[S]) {
                return -1
            }
        }
        return 0
    }
    function c(R) {
        return J(v.fn.jquery, R) >= 0
    }
    (function() {
        if (!H.console || !H.console.log) {
            return
        }
        if (!v || !c("x.x.x")) {
            H.console.log("JQMIGRATE: jQuery x.x.x+ REQUIRED")
        }
        if (v.migrateWarnings) {
            H.console.log("JQMIGRATE: Migrate plugin loaded multiple times")
        }
    }
    )();
    var s = {};
    v.migrateDeduplicateWarnings = true;
    v.migrateWarnings = [];
    if (v.migrateTrace === undefined) {
        v.migrateTrace = true
    }
    v.migrateReset = function() {
        s = {};
        v.migrateWarnings.length = 0
    }
    ;
    function I(R) {}
    function t(S, U, R, T) {
        Object.defineProperty(S, U, {
            configurable: true,
            enumerable: true,
            get: function() {
                I(T);
                return R
            },
            set: function(V) {
                I(T);
                R = V
            }
        })
    }
    function w(S, U, R, T) {
        S[U] = function() {
            I(T);
            return R.apply(this, arguments)
        }
    }
    if (H.document.compatMode === "BackCompat") {
        I("jQuery is not compatible with Quirks Mode")
    }
    var N, d = {}, u = v.fn.init, m = v.find, n = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/, B = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g, K = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
    v.fn.init = function(S) {
        var R = Array.prototype.slice.call(arguments);
        if (typeof S === "string" && S === "#") {
            I("jQuery( '#' ) is not a valid selector");
            R[0] = []
        }
        return u.apply(this, R)
    }
    ;
    v.fn.init.prototype = v.fn;
    v.find = function(R) {
        var U = Array.prototype.slice.call(arguments);
        if (typeof R === "string" && n.test(R)) {
            try {
                H.document.querySelector(R)
            } catch (T) {
                R = R.replace(B, function(W, V, Y, X) {
                    return "[" + V + Y + '"' + X + '"]'
                });
                try {
                    H.document.querySelector(R);
                    I("Attribute selector with '#' must be quoted: " + U[0]);
                    U[0] = R
                } catch (S) {
                    I("Attribute selector with '#' was not fixed: " + U[0])
                }
            }
        }
        return m.apply(this, U)
    }
    ;
    for (N in m) {
        if (Object.prototype.hasOwnProperty.call(m, N)) {
            v.find[N] = m[N]
        }
    }
    w(v.fn, "size", function() {
        return this.length
    }, "jQuery.fn.size() is deprecated and removed; use the .length property");
    w(v, "parseJSON", function() {
        return JSON.parse.apply(null, arguments)
    }, "jQuery.parseJSON is deprecated; use JSON.parse");
    w(v, "holdReady", v.holdReady, "jQuery.holdReady is deprecated");
    w(v, "unique", v.uniqueSort, "jQuery.unique is deprecated; use jQuery.uniqueSort");
    t(v.expr, "filters", v.expr.pseudos, "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos");
    t(v.expr, ":", v.expr.pseudos, "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos");
    if (c("x.x.x")) {
        w(v, "trim", function(R) {
            return R == null ? "" : (R + "").replace(K, "")
        }, "jQuery.trim is deprecated; use String.prototype.trim")
    }
    if (c("x.x.x")) {
        w(v, "nodeName", function(S, R) {
            return S.nodeName && S.nodeName.toLowerCase() === R.toLowerCase()
        }, "jQuery.nodeName is deprecated");
        w(v, "isArray", Array.isArray, "jQuery.isArray is deprecated; use Array.isArray")
    }
    if (c("x.x.x")) {
        w(v, "isNumeric", function(S) {
            var R = typeof S;
            return (R === "number" || R === "string") && !isNaN(S - parseFloat(S))
        }, "jQuery.isNumeric() is deprecated");
        v.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(S, R) {
            d["[object " + R + "]"] = R.toLowerCase()
        });
        w(v, "type", function(R) {
            if (R == null) {
                return R + ""
            }
            return typeof R === "object" || typeof R === "function" ? d[Object.prototype.toString.call(R)] || "object" : typeof R
        }, "jQuery.type is deprecated");
        w(v, "isFunction", function(R) {
            return typeof R === "function"
        }, "jQuery.isFunction() is deprecated");
        w(v, "isWindow", function(R) {
            return R != null && R === R.window
        }, "jQuery.isWindow() is deprecated")
    }
    if (v.ajax) {
        var g = v.ajax
          , b = /(=)\?(?=&|$)|\?\?/;
        v.ajax = function() {
            var R = g.apply(this, arguments);
            if (R.promise) {
                w(R, "success", R.done, "jQXHR.success is deprecated and removed");
                w(R, "error", R.fail, "jQXHR.error is deprecated and removed");
                w(R, "complete", R.always, "jQXHR.complete is deprecated and removed")
            }
            return R
        }
        ;
        if (!c("4.0.0")) {
            v.ajaxPrefilter("+json", function(R) {
                if (R.jsonp !== false && (b.test(R.url) || typeof R.data === "string" && (R.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && b.test(R.data))) {
                    I("JSON-to-JSONP auto-promotion is deprecated")
                }
            })
        }
    }
    var Q = v.fn.removeAttr
      , D = v.fn.toggleClass
      , i = /\S+/g;
    v.fn.removeAttr = function(S) {
        var R = this;
        v.each(S.match(i), function(U, T) {
            if (v.expr.match.bool.test(T)) {
                I("jQuery.fn.removeAttr no longer sets boolean properties: " + T);
                R.prop(T, false)
            }
        });
        return Q.apply(this, arguments)
    }
    ;
    v.fn.toggleClass = function(R) {
        if (R !== undefined && typeof R !== "boolean") {
            return D.apply(this, arguments)
        }
        I("jQuery.fn.toggleClass( boolean ) is deprecated");
        return this.each(function() {
            var S = this.getAttribute && this.getAttribute("class") || "";
            if (S) {
                v.data(this, "__className__", S)
            }
            if (this.setAttribute) {
                this.setAttribute("class", S || R === false ? "" : v.data(this, "__className__") || "")
            }
        })
    }
    ;
    function l(R) {
        return R.replace(/-([a-z])/g, function(S, T) {
            return T.toUpperCase()
        })
    }
    var a, r = false, p = /^[a-z]/, G = /^(?:Border(?:Top|Right|Bottom|Left)?(?:Width|)|(?:Margin|Padding)?(?:Top|Right|Bottom|Left)?|(?:Min|Max)?(?:Width|Height))$/;
    if (v.swap) {
        v.each(["height", "width", "reliableMarginRight"], function(S, R) {
            var T = v.cssHooks[R] && v.cssHooks[R].get;
            if (T) {
                v.cssHooks[R].get = function() {
                    var U;
                    r = true;
                    U = T.apply(this, arguments);
                    r = false;
                    return U
                }
            }
        })
    }
    v.swap = function(W, V, X, U) {
        var T, S, R = {};
        if (!r) {
            I("jQuery.swap() is undocumented and deprecated")
        }
        for (S in V) {
            R[S] = W.style[S];
            W.style[S] = V[S]
        }
        T = X.apply(W, U || []);
        for (S in V) {
            W.style[S] = R[S]
        }
        return T
    }
    ;
    if (c("x.x.x") && typeof Proxy !== "undefined") {
        v.cssProps = new Proxy(v.cssProps || {},{
            set: function() {
                I("JQMIGRATE: jQuery.cssProps is deprecated");
                return Reflect.set.apply(this, arguments)
            }
        })
    }
    if (!v.cssNumber) {
        v.cssNumber = {}
    }
    function x(R) {
        return p.test(R) && G.test(R[0].toUpperCase() + R.slice(1))
    }
    a = v.fn.css;
    v.fn.css = function(S, U) {
        var T, R = this;
        if (S && typeof S === "object" && !Array.isArray(S)) {
            v.each(S, function(W, V) {
                v.fn.css.call(R, W, V)
            });
            return this
        }
        if (typeof U === "number") {
            T = l(S);
            if (!x(T) && !v.cssNumber[T]) {
                I('Number-typed values are deprecated for jQuery.fn.css( "' + S + '", value )')
            }
        }
        return a.apply(this, arguments)
    }
    ;
    var y = v.data;
    v.data = function(V, R, W) {
        var U, T, S;
        if (R && typeof R === "object" && arguments.length === 2) {
            U = v.hasData(V) && y.call(this, V);
            T = {};
            for (S in R) {
                if (S !== l(S)) {
                    I("jQuery.data() always sets/gets camelCased names: " + S);
                    U[S] = R[S]
                } else {
                    T[S] = R[S]
                }
            }
            y.call(this, V, T);
            return R
        }
        if (R && typeof R === "string" && R !== l(R)) {
            U = v.hasData(V) && y.call(this, V);
            if (U && R in U) {
                I("jQuery.data() always sets/gets camelCased names: " + R);
                if (arguments.length > 2) {
                    U[R] = W
                }
                return U[R]
            }
        }
        return y.apply(this, arguments)
    }
    ;
    if (v.fx) {
        var L, z, j = v.Tween.prototype.run, P = function(R) {
            return R
        };
        v.Tween.prototype.run = function() {
            if (v.easing[this.easing].length > 1) {
                I("'jQuery.easing." + this.easing.toString() + "' should use only one argument");
                v.easing[this.easing] = P
            }
            j.apply(this, arguments)
        }
        ;
        L = v.fx.interval || 13;
        z = "jQuery.fx.interval is deprecated";
        if (H.requestAnimationFrame) {
            Object.defineProperty(v.fx, "interval", {
                configurable: true,
                enumerable: true,
                get: function() {
                    if (!H.document.hidden) {
                        I(z)
                    }
                    return L
                },
                set: function(R) {
                    I(z);
                    L = R
                }
            })
        }
    }
    var q = v.fn.load
      , C = v.event.add
      , e = v.event.fix;
    v.event.props = [];
    v.event.fixHooks = {};
    t(v.event.props, "concat", v.event.props.concat, "jQuery.event.props.concat() is deprecated and removed");
    v.event.fix = function(R) {
        var U, T = R.type, V = this.fixHooks[T], S = v.event.props;
        if (S.length) {
            I("jQuery.event.props are deprecated and removed: " + S.join());
            while (S.length) {
                v.event.addProp(S.pop())
            }
        }
        if (V && !V._migrated_) {
            V._migrated_ = true;
            I("jQuery.event.fixHooks are deprecated and removed: " + T);
            if ((S = V.props) && S.length) {
                while (S.length) {
                    v.event.addProp(S.pop())
                }
            }
        }
        U = e.call(this, R);
        return V && V.filter ? V.filter(U, R) : U
    }
    ;
    v.event.add = function(S, R) {
        if (S === H && R === "load" && H.document.readyState === "complete") {
            I("jQuery(window).on('load'...) called after load event occurred")
        }
        return C.apply(this, arguments)
    }
    ;
    v.each(["load", "unload", "error"], function(S, R) {
        v.fn[R] = function() {
            var T = Array.prototype.slice.call(arguments, 0);
            if (R === "load" && typeof T[0] === "string") {
                return q.apply(this, T)
            }
            I("jQuery.fn." + R + "() is deprecated");
            T.splice(0, 0, R);
            if (arguments.length) {
                return this.on.apply(this, T)
            }
            this.triggerHandler.apply(this, T);
            return this
        }
    });
    v.each(("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu").split(" "), function(S, R) {
        v.fn[R] = function(U, T) {
            I("jQuery.fn." + R + "() event shorthand is deprecated");
            return arguments.length > 0 ? this.on(R, null, U, T) : this.trigger(R)
        }
    });
    v(function() {
        v(H.document).triggerHandler("ready")
    });
    v.event.special.ready = {
        setup: function() {
            if (this === H.document) {
                I("'ready' event is deprecated")
            }
        }
    };
    v.fn.extend({
        bind: function(R, T, S) {
            I("jQuery.fn.bind() is deprecated");
            return this.on(R, null, T, S)
        },
        unbind: function(R, S) {
            I("jQuery.fn.unbind() is deprecated");
            return this.off(R, null, S)
        },
        delegate: function(R, S, U, T) {
            I("jQuery.fn.delegate() is deprecated");
            return this.on(S, R, U, T)
        },
        undelegate: function(R, S, T) {
            I("jQuery.fn.undelegate() is deprecated");
            return arguments.length === 1 ? this.off(R, "**") : this.off(S, R || "**", T)
        },
        hover: function(R, S) {
            I("jQuery.fn.hover() is deprecated");
            return this.on("mouseenter", R).on("mouseleave", S || R)
        }
    });
    var h = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi
      , o = v.htmlPrefilter
      , M = function(R) {
        var S = H.document.implementation.createHTMLDocument("");
        S.body.innerHTML = R;
        return S.body && S.body.innerHTML
    }
      , O = function(R) {
        var S = R.replace(h, "<$1></$2>");
        if (S !== R && M(R) !== M(S)) {
            I("HTML tags must be properly nested and closed: " + R)
        }
    };
    v.UNSAFE_restoreLegacyHtmlPrefilter = function() {
        v.htmlPrefilter = function(R) {
            O(R);
            return R.replace(h, "<$1></$2>")
        }
    }
    ;
    v.htmlPrefilter = function(R) {
        O(R);
        return o(R)
    }
    ;
    var k = v.fn.offset;
    v.fn.offset = function() {
        var R = this[0];
        if (R && (!R.nodeType || !R.getBoundingClientRect)) {
            I("jQuery.fn.offset() requires a valid DOM element");
            return arguments.length ? this : undefined
        }
        return k.apply(this, arguments)
    }
    ;
    if (v.ajax) {
        var A = v.param;
        v.param = function(S, R) {
            var T = v.ajaxSettings && v.ajaxSettings.traditional;
            if (R === undefined && T) {
                I("jQuery.param() no longer uses jQuery.ajaxSettings.traditional");
                R = T
            }
            return A.call(this, S, R)
        }
    }
    var F = v.fn.andSelf || v.fn.addBack;
    v.fn.andSelf = function() {
        I("jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()");
        return F.apply(this, arguments)
    }
    ;
    if (v.Deferred) {
        var E = v.Deferred
          , f = [["resolve", "done", v.Callbacks("once memory"), v.Callbacks("once memory"), "resolved"], ["reject", "fail", v.Callbacks("once memory"), v.Callbacks("once memory"), "rejected"], ["notify", "progress", v.Callbacks("memory"), v.Callbacks("memory")]];
        v.Deferred = function(S) {
            var R = E()
              , T = R.promise();
            R.pipe = T.pipe = function() {
                var U = arguments;
                I("deferred.pipe() is deprecated");
                return v.Deferred(function(V) {
                    v.each(f, function(X, W) {
                        var Y = typeof U[X] === "function" && U[X];
                        R[W[1]](function() {
                            var Z = Y && Y.apply(this, arguments);
                            if (Z && typeof Z.promise === "function") {
                                Z.promise().done(V.resolve).fail(V.reject).progress(V.notify)
                            } else {
                                V[W[0] + "With"](this === T ? V.promise() : this, Y ? [Z] : arguments)
                            }
                        })
                    });
                    U = null
                }).promise()
            }
            ;
            if (S) {
                S.call(R, R)
            }
            return R
        }
        ;
        v.Deferred.exceptionHook = E.exceptionHook
    }
    return v
});