MMCT TEAM
Server IP : 103.191.208.50  /  Your IP : 216.73.216.53
Web Server : LiteSpeed
System : Linux orion.herosite.pro 4.18.0-553.53.1.lve.el8.x86_64 #1 SMP Wed May 28 17:01:02 UTC 2025 x86_64
User : celkcksm ( 1031)
PHP Version : 7.4.33
Disable Function : show_source, system, shell_exec, passthru, popen, exec
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON
Directory (0755) :  /home/celkcksm/jrslawcollege.com/siteassets/js/

[  Home  ][  C0mmand  ][  Upload File  ]

Current File : /home/celkcksm/jrslawcollege.com/siteassets/js/js-combine.js
! function(h, i, n, a) {
    function l(t, e) {
        this.settings = null, this.options = h.extend({}, l.Defaults, e), this.$element = h(t), this._handlers = {}, this._plugins = {}, this._supress = {}, this._current = null, this._speed = null, this._coordinates = [], this._breakpoint = null, this._width = null, this._items = [], this._clones = [], this._mergers = [], this._widths = [], this._invalidated = {}, this._pipe = [], this._drag = {
            time: null,
            target: null,
            pointer: null,
            stage: {
                start: null,
                current: null
            },
            direction: null
        }, this._states = {
            current: {},
            tags: {
                initializing: ["busy"],
                animating: ["busy"],
                dragging: ["interacting"]
            }
        }, h.each(["onResize", "onThrottledResize"], h.proxy(function(t, e) {
            this._handlers[e] = h.proxy(this[e], this)
        }, this)), h.each(l.Plugins, h.proxy(function(t, e) {
            this._plugins[t.charAt(0).toLowerCase() + t.slice(1)] = new e(this)
        }, this)), h.each(l.Workers, h.proxy(function(t, e) {
            this._pipe.push({
                filter: e.filter,
                run: h.proxy(e.run, this)
            })
        }, this)), this.setup(), this.initialize()
    }
    l.Defaults = {
        items: 3,
        loop: !1,
        center: !1,
        rewind: !1,
        checkVisibility: !0,
        mouseDrag: !0,
        touchDrag: !0,
        pullDrag: !0,
        freeDrag: !1,
        margin: 0,
        stagePadding: 0,
        merge: !1,
        mergeFit: !0,
        autoWidth: !1,
        startPosition: 0,
        rtl: !1,
        smartSpeed: 250,
        fluidSpeed: !1,
        dragEndSpeed: !1,
        responsive: {},
        responsiveRefreshRate: 200,
        responsiveBaseElement: i,
        fallbackEasing: "swing",
        slideTransition: "",
        info: !1,
        nestedItemSelector: !1,
        itemElement: "div",
        stageElement: "div",
        refreshClass: "owl-refresh",
        loadedClass: "owl-loaded",
        loadingClass: "owl-loading",
        rtlClass: "owl-rtl",
        responsiveClass: "owl-responsive",
        dragClass: "owl-drag",
        itemClass: "owl-item",
        stageClass: "owl-stage",
        stageOuterClass: "owl-stage-outer",
        grabClass: "owl-grab"
    }, l.Width = {
        Default: "default",
        Inner: "inner",
        Outer: "outer"
    }, l.Type = {
        Event: "event",
        State: "state"
    }, l.Plugins = {}, l.Workers = [{
        filter: ["width", "settings"],
        run: function() {
            this._width = this.$element.width()
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function(t) {
            t.current = this._items && this._items[this.relative(this._current)]
        }
    }, {
        filter: ["items", "settings"],
        run: function() {
            this.$stage.children(".cloned").remove()
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function(t) {
            var e = this.settings.margin || "",
                i = !this.settings.autoWidth,
                s = this.settings.rtl,
                n = {
                    width: "auto",
                    "margin-left": s ? e : "",
                    "margin-right": s ? "" : e
                };
            i || this.$stage.children().css(n), t.css = n
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function(t) {
            var e = (this.width() / this.settings.items).toFixed(3) - this.settings.margin,
                i = null,
                s = this._items.length,
                n = !this.settings.autoWidth,
                o = [];
            for (t.items = {
                    merge: !1,
                    width: e
                }; s--;) i = this._mergers[s], i = this.settings.mergeFit && Math.min(i, this.settings.items) || i, t.items.merge = 1 < i || t.items.merge, o[s] = n ? e * i : this._items[s].width();
            this._widths = o
        }
    }, {
        filter: ["items", "settings"],
        run: function() {
            var t = [],
                e = this._items,
                i = this.settings,
                s = Math.max(2 * i.items, 4),
                n = 2 * Math.ceil(e.length / 2),
                o = i.loop && e.length ? i.rewind ? s : Math.max(s, n) : 0,
                r = "",
                a = "";
            for (o /= 2; 0 < o;) t.push(this.normalize(t.length / 2, !0)), r += e[t[t.length - 1]][0].outerHTML, t.push(this.normalize(e.length - 1 - (t.length - 1) / 2, !0)), a = e[t[t.length - 1]][0].outerHTML + a, --o;
            this._clones = t, h(r).addClass("cloned").appendTo(this.$stage), h(a).addClass("cloned").prependTo(this.$stage)
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function() {
            for (var t = this.settings.rtl ? 1 : -1, e = this._clones.length + this._items.length, i = -1, s = 0, n = 0, o = []; ++i < e;) s = o[i - 1] || 0, n = this._widths[this.relative(i)] + this.settings.margin, o.push(s + n * t);
            this._coordinates = o
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function() {
            var t = this.settings.stagePadding,
                e = this._coordinates,
                i = {
                    width: Math.ceil(Math.abs(e[e.length - 1])) + 2 * t,
                    "padding-left": t || "",
                    "padding-right": t || ""
                };
            this.$stage.css(i)
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function(t) {
            var e = this._coordinates.length,
                i = !this.settings.autoWidth,
                s = this.$stage.children();
            if (i && t.items.merge)
                for (; e--;) t.css.width = this._widths[this.relative(e)], s.eq(e).css(t.css);
            else i && (t.css.width = t.items.width, s.css(t.css))
        }
    }, {
        filter: ["items"],
        run: function() {
            this._coordinates.length < 1 && this.$stage.removeAttr("style")
        }
    }, {
        filter: ["width", "items", "settings"],
        run: function(t) {
            t.current = t.current ? this.$stage.children().index(t.current) : 0, t.current = Math.max(this.minimum(), Math.min(this.maximum(), t.current)), this.reset(t.current)
        }
    }, {
        filter: ["position"],
        run: function() {
            this.animate(this.coordinates(this._current))
        }
    }, {
        filter: ["width", "position", "items", "settings"],
        run: function() {
            var t, e, i, s, n = this.settings.rtl ? 1 : -1,
                o = 2 * this.settings.stagePadding,
                r = this.coordinates(this.current()) + o,
                a = r + this.width() * n,
                h = [];
            for (i = 0, s = this._coordinates.length; i < s; i++) t = this._coordinates[i - 1] || 0, e = Math.abs(this._coordinates[i]) + o * n, (this.op(t, "<=", r) && this.op(t, ">", a) || this.op(e, "<", r) && this.op(e, ">", a)) && h.push(i);
            this.$stage.children(".active").removeClass("active"), this.$stage.children(":eq(" + h.join("), :eq(") + ")").addClass("active"), this.$stage.children(".center").removeClass("center"), this.settings.center && this.$stage.children().eq(this.current()).addClass("center")
        }
    }], l.prototype.initializeStage = function() {
        this.$stage = this.$element.find("." + this.settings.stageClass), this.$stage.length || (this.$element.addClass(this.options.loadingClass), this.$stage = h("<" + this.settings.stageElement + ">", {
            class: this.settings.stageClass
        }).wrap(h("<div/>", {
            class: this.settings.stageOuterClass
        })), this.$element.append(this.$stage.parent()))
    }, l.prototype.initializeItems = function() {
        var t = this.$element.find(".owl-item");
        if (t.length) return this._items = t.get().map(function(t) {
            return h(t)
        }), this._mergers = this._items.map(function() {
            return 1
        }), void this.refresh();
        this.replace(this.$element.children().not(this.$stage.parent())), this.isVisible() ? this.refresh() : this.invalidate("width"), this.$element.removeClass(this.options.loadingClass).addClass(this.options.loadedClass)
    }, l.prototype.initialize = function() {
        var t, e, i;
        this.enter("initializing"), this.trigger("initialize"), this.$element.toggleClass(this.settings.rtlClass, this.settings.rtl), this.settings.autoWidth && !this.is("pre-loading") && (t = this.$element.find("img"), e = this.settings.nestedItemSelector ? "." + this.settings.nestedItemSelector : a, i = this.$element.children(e).width(), t.length && i <= 0 && this.preloadAutoWidthImages(t));
        this.initializeStage(), this.initializeItems(), this.registerEventHandlers(), this.leave("initializing"), this.trigger("initialized")
    }, l.prototype.isVisible = function() {
        return !this.settings.checkVisibility || this.$element.is(":visible")
    }, l.prototype.setup = function() {
        var e = this.viewport(),
            t = this.options.responsive,
            i = -1,
            s = null;
        t ? (h.each(t, function(t) {
            t <= e && i < t && (i = Number(t))
        }), "function" == typeof(s = h.extend({}, this.options, t[i])).stagePadding && (s.stagePadding = s.stagePadding()), delete s.responsive, s.responsiveClass && this.$element.attr("class", this.$element.attr("class").replace(new RegExp("(" + this.options.responsiveClass + "-)\\S+\\s", "g"), "$1" + i))) : s = h.extend({}, this.options), this.trigger("change", {
            property: {
                name: "settings",
                value: s
            }
        }), this._breakpoint = i, this.settings = s, this.invalidate("settings"), this.trigger("changed", {
            property: {
                name: "settings",
                value: this.settings
            }
        })
    }, l.prototype.optionsLogic = function() {
        this.settings.autoWidth && (this.settings.stagePadding = !1, this.settings.merge = !1)
    }, l.prototype.prepare = function(t) {
        var e = this.trigger("prepare", {
            content: t
        });
        return e.data || (e.data = h("<" + this.settings.itemElement + "/>").addClass(this.options.itemClass).append(t)), this.trigger("prepared", {
            content: e.data
        }), e.data
    }, l.prototype.update = function() {
        for (var t = 0, e = this._pipe.length, i = h.proxy(function(t) {
                return this[t]
            }, this._invalidated), s = {}; t < e;)(this._invalidated.all || 0 < h.grep(this._pipe[t].filter, i).length) && this._pipe[t].run(s), t++;
        this._invalidated = {}, this.is("valid") || this.enter("valid")
    }, l.prototype.width = function(t) {
        switch (t = t || l.Width.Default) {
            case l.Width.Inner:
            case l.Width.Outer:
                return this._width;
            default:
                return this._width - 2 * this.settings.stagePadding + this.settings.margin
        }
    }, l.prototype.refresh = function() {
        this.enter("refreshing"), this.trigger("refresh"), this.setup(), this.optionsLogic(), this.$element.addClass(this.options.refreshClass), this.update(), this.$element.removeClass(this.options.refreshClass), this.leave("refreshing"), this.trigger("refreshed")
    }, l.prototype.onThrottledResize = function() {
        i.clearTimeout(this.resizeTimer), this.resizeTimer = i.setTimeout(this._handlers.onResize, this.settings.responsiveRefreshRate)
    }, l.prototype.onResize = function() {
        return !!this._items.length && (this._width !== this.$element.width() && (!!this.isVisible() && (this.enter("resizing"), this.trigger("resize").isDefaultPrevented() ? (this.leave("resizing"), !1) : (this.invalidate("width"), this.refresh(), this.leave("resizing"), void this.trigger("resized")))))
    }, l.prototype.registerEventHandlers = function() {
        h.support.transition && this.$stage.on(h.support.transition.end + ".owl.core", h.proxy(this.onTransitionEnd, this)), !1 !== this.settings.responsive && this.on(i, "resize", this._handlers.onThrottledResize), this.settings.mouseDrag && (this.$element.addClass(this.options.dragClass), this.$stage.on("mousedown.owl.core", h.proxy(this.onDragStart, this)), this.$stage.on("dragstart.owl.core selectstart.owl.core", function() {
            return !1
        })), this.settings.touchDrag && (this.$stage.on("touchstart.owl.core", h.proxy(this.onDragStart, this)), this.$stage.on("touchcancel.owl.core", h.proxy(this.onDragEnd, this)))
    }, l.prototype.onDragStart = function(t) {
        var e = null;
        3 !== t.which && (e = h.support.transform ? {
            x: (e = this.$stage.css("transform").replace(/.*\(|\)| /g, "").split(","))[16 === e.length ? 12 : 4],
            y: e[16 === e.length ? 13 : 5]
        } : (e = this.$stage.position(), {
            x: this.settings.rtl ? e.left + this.$stage.width() - this.width() + this.settings.margin : e.left,
            y: e.top
        }), this.is("animating") && (h.support.transform ? this.animate(e.x) : this.$stage.stop(), this.invalidate("position")), this.$element.toggleClass(this.options.grabClass, "mousedown" === t.type), this.speed(0), this._drag.time = (new Date).getTime(), this._drag.target = h(t.target), this._drag.stage.start = e, this._drag.stage.current = e, this._drag.pointer = this.pointer(t), h(n).on("mouseup.owl.core touchend.owl.core", h.proxy(this.onDragEnd, this)), h(n).one("mousemove.owl.core touchmove.owl.core", h.proxy(function(t) {
            var e = this.difference(this._drag.pointer, this.pointer(t));
            h(n).on("mousemove.owl.core touchmove.owl.core", h.proxy(this.onDragMove, this)), Math.abs(e.x) < Math.abs(e.y) && this.is("valid") || (t.preventDefault(), this.enter("dragging"), this.trigger("drag"))
        }, this)))
    }, l.prototype.onDragMove = function(t) {
        var e = null,
            i = null,
            s = null,
            n = this.difference(this._drag.pointer, this.pointer(t)),
            o = this.difference(this._drag.stage.start, n);
        this.is("dragging") && (t.preventDefault(), this.settings.loop ? (e = this.coordinates(this.minimum()), i = this.coordinates(this.maximum() + 1) - e, o.x = ((o.x - e) % i + i) % i + e) : (e = this.settings.rtl ? this.coordinates(this.maximum()) : this.coordinates(this.minimum()), i = this.settings.rtl ? this.coordinates(this.minimum()) : this.coordinates(this.maximum()), s = this.settings.pullDrag ? -1 * n.x / 5 : 0, o.x = Math.max(Math.min(o.x, e + s), i + s)), this._drag.stage.current = o, this.animate(o.x))
    }, l.prototype.onDragEnd = function(t) {
        var e = this.difference(this._drag.pointer, this.pointer(t)),
            i = this._drag.stage.current,
            s = 0 < e.x ^ this.settings.rtl ? "left" : "right";
        h(n).off(".owl.core"), this.$element.removeClass(this.options.grabClass), (0 !== e.x && this.is("dragging") || !this.is("valid")) && (this.speed(this.settings.dragEndSpeed || this.settings.smartSpeed), this.current(this.closest(i.x, 0 !== e.x ? s : this._drag.direction)), this.invalidate("position"), this.update(), this._drag.direction = s, (3 < Math.abs(e.x) || 300 < (new Date).getTime() - this._drag.time) && this._drag.target.one("click.owl.core", function() {
            return !1
        })), this.is("dragging") && (this.leave("dragging"), this.trigger("dragged"))
    }, l.prototype.closest = function(i, s) {
        var n = -1,
            o = this.width(),
            r = this.coordinates();
        return this.settings.freeDrag || h.each(r, h.proxy(function(t, e) {
            return "left" === s && e - 30 < i && i < e + 30 ? n = t : "right" === s && e - o - 30 < i && i < e - o + 30 ? n = t + 1 : this.op(i, "<", e) && this.op(i, ">", r[t + 1] !== a ? r[t + 1] : e - o) && (n = "left" === s ? t + 1 : t), -1 === n
        }, this)), this.settings.loop || (this.op(i, ">", r[this.minimum()]) ? n = i = this.minimum() : this.op(i, "<", r[this.maximum()]) && (n = i = this.maximum())), n
    }, l.prototype.animate = function(t) {
        var e = 0 < this.speed();
        this.is("animating") && this.onTransitionEnd(), e && (this.enter("animating"), this.trigger("translate")), h.support.transform3d && h.support.transition ? this.$stage.css({
            transform: "translate3d(" + t + "px,0px,0px)",
            transition: this.speed() / 1e3 + "s" + (this.settings.slideTransition ? " " + this.settings.slideTransition : "")
        }) : e ? this.$stage.animate({
            left: t + "px"
        }, this.speed(), this.settings.fallbackEasing, h.proxy(this.onTransitionEnd, this)) : this.$stage.css({
            left: t + "px"
        })
    }, l.prototype.is = function(t) {
        return this._states.current[t] && 0 < this._states.current[t]
    }, l.prototype.current = function(t) {
        if (t === a) return this._current;
        if (0 === this._items.length) return a;
        if (t = this.normalize(t), this._current !== t) {
            var e = this.trigger("change", {
                property: {
                    name: "position",
                    value: t
                }
            });
            e.data !== a && (t = this.normalize(e.data)), this._current = t, this.invalidate("position"), this.trigger("changed", {
                property: {
                    name: "position",
                    value: this._current
                }
            })
        }
        return this._current
    }, l.prototype.invalidate = function(t) {
        return "string" === h.type(t) && (this._invalidated[t] = !0, this.is("valid") && this.leave("valid")), h.map(this._invalidated, function(t, e) {
            return e
        })
    }, l.prototype.reset = function(t) {
        (t = this.normalize(t)) !== a && (this._speed = 0, this._current = t, this.suppress(["translate", "translated"]), this.animate(this.coordinates(t)), this.release(["translate", "translated"]))
    }, l.prototype.normalize = function(t, e) {
        var i = this._items.length,
            s = e ? 0 : this._clones.length;
        return !this.isNumeric(t) || i < 1 ? t = a : (t < 0 || i + s <= t) && (t = ((t - s / 2) % i + i) % i + s / 2), t
    }, l.prototype.relative = function(t) {
        return t -= this._clones.length / 2, this.normalize(t, !0)
    }, l.prototype.maximum = function(t) {
        var e, i, s, n = this.settings,
            o = this._coordinates.length;
        if (n.loop) o = this._clones.length / 2 + this._items.length - 1;
        else if (n.autoWidth || n.merge) {
            if (e = this._items.length)
                for (i = this._items[--e].width(), s = this.$element.width(); e-- && !(s < (i += this._items[e].width() + this.settings.margin)););
            o = e + 1
        } else o = n.center ? this._items.length - 1 : this._items.length - n.items;
        return t && (o -= this._clones.length / 2), Math.max(o, 0)
    }, l.prototype.minimum = function(t) {
        return t ? 0 : this._clones.length / 2
    }, l.prototype.items = function(t) {
        return t === a ? this._items.slice() : (t = this.normalize(t, !0), this._items[t])
    }, l.prototype.mergers = function(t) {
        return t === a ? this._mergers.slice() : (t = this.normalize(t, !0), this._mergers[t])
    }, l.prototype.clones = function(i) {
        function s(t) {
            return t % 2 == 0 ? n + t / 2 : e - (t + 1) / 2
        }
        var e = this._clones.length / 2,
            n = e + this._items.length;
        return i === a ? h.map(this._clones, function(t, e) {
            return s(e)
        }) : h.map(this._clones, function(t, e) {
            return t === i ? s(e) : null
        })
    }, l.prototype.speed = function(t) {
        return t !== a && (this._speed = t), this._speed
    }, l.prototype.coordinates = function(t) {
        var e, i = 1,
            s = t - 1;
        return t === a ? h.map(this._coordinates, h.proxy(function(t, e) {
            return this.coordinates(e)
        }, this)) : (this.settings.center ? (this.settings.rtl && (i = -1, s = t + 1), e = this._coordinates[t], e += (this.width() - e + (this._coordinates[s] || 0)) / 2 * i) : e = this._coordinates[s] || 0, e = Math.ceil(e))
    }, l.prototype.duration = function(t, e, i) {
        return 0 === i ? 0 : Math.min(Math.max(Math.abs(e - t), 1), 6) * Math.abs(i || this.settings.smartSpeed)
    }, l.prototype.to = function(t, e) {
        var i = this.current(),
            s = null,
            n = t - this.relative(i),
            o = (0 < n) - (n < 0),
            r = this._items.length,
            a = this.minimum(),
            h = this.maximum();
        this.settings.loop ? (!this.settings.rewind && Math.abs(n) > r / 2 && (n += -1 * o * r), (s = (((t = i + n) - a) % r + r) % r + a) !== t && s - n <= h && 0 < s - n && (i = s - n, t = s, this.reset(i))) : t = this.settings.rewind ? (t % (h += 1) + h) % h : Math.max(a, Math.min(h, t)), this.speed(this.duration(i, t, e)), this.current(t), this.isVisible() && this.update()
    }, l.prototype.next = function(t) {
        t = t || !1, this.to(this.relative(this.current()) + 1, t)
    }, l.prototype.prev = function(t) {
        t = t || !1, this.to(this.relative(this.current()) - 1, t)
    }, l.prototype.onTransitionEnd = function(t) {
        if (t !== a && (t.stopPropagation(), (t.target || t.srcElement || t.originalTarget) !== this.$stage.get(0))) return !1;
        this.leave("animating"), this.trigger("translated")
    }, l.prototype.viewport = function() {
        var t;
        return this.options.responsiveBaseElement !== i ? t = h(this.options.responsiveBaseElement).width() : i.innerWidth ? t = i.innerWidth : n.documentElement && n.documentElement.clientWidth ? t = n.documentElement.clientWidth : console.warn("Can not detect viewport width."), t
    }, l.prototype.replace = function(t) {
        this.$stage.empty(), this._items = [], t = t && (t instanceof jQuery ? t : h(t)), this.settings.nestedItemSelector && (t = t.find("." + this.settings.nestedItemSelector)), t.filter(function() {
            return 1 === this.nodeType
        }).each(h.proxy(function(t, e) {
            e = this.prepare(e), this.$stage.append(e), this._items.push(e), this._mergers.push(+e.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)
        }, this)), this.reset(this.isNumeric(this.settings.startPosition) ? this.settings.startPosition : 0), this.invalidate("items")
    }, l.prototype.add = function(t, e) {
        var i = this.relative(this._current);
        e = e === a ? this._items.length : this.normalize(e, !0), t = t instanceof jQuery ? t : h(t), this.trigger("add", {
            content: t,
            position: e
        }), t = this.prepare(t), 0 === this._items.length || e === this._items.length ? (0 === this._items.length && this.$stage.append(t), 0 !== this._items.length && this._items[e - 1].after(t), this._items.push(t), this._mergers.push(+t.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)) : (this._items[e].before(t), this._items.splice(e, 0, t), this._mergers.splice(e, 0, +t.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)), this._items[i] && this.reset(this._items[i].index()), this.invalidate("items"), this.trigger("added", {
            content: t,
            position: e
        })
    }, l.prototype.remove = function(t) {
        (t = this.normalize(t, !0)) !== a && (this.trigger("remove", {
            content: this._items[t],
            position: t
        }), this._items[t].remove(), this._items.splice(t, 1), this._mergers.splice(t, 1), this.invalidate("items"), this.trigger("removed", {
            content: null,
            position: t
        }))
    }, l.prototype.preloadAutoWidthImages = function(t) {
        t.each(h.proxy(function(t, e) {
            this.enter("pre-loading"), e = h(e), h(new Image).one("load", h.proxy(function(t) {
                e.attr("src", t.target.src), e.css("opacity", 1), this.leave("pre-loading"), this.is("pre-loading") || this.is("initializing") || this.refresh()
            }, this)).attr("src", e.attr("src") || e.attr("data-src") || e.attr("data-src-retina"))
        }, this))
    }, l.prototype.destroy = function() {
        for (var t in this.$element.off(".owl.core"), this.$stage.off(".owl.core"), h(n).off(".owl.core"), !1 !== this.settings.responsive && (i.clearTimeout(this.resizeTimer), this.off(i, "resize", this._handlers.onThrottledResize)), this._plugins) this._plugins[t].destroy();
        this.$stage.children(".cloned").remove(), this.$stage.unwrap(), this.$stage.children().contents().unwrap(), this.$stage.children().unwrap(), this.$stage.remove(), this.$element.removeClass(this.options.refreshClass).removeClass(this.options.loadingClass).removeClass(this.options.loadedClass).removeClass(this.options.rtlClass).removeClass(this.options.dragClass).removeClass(this.options.grabClass).attr("class", this.$element.attr("class").replace(new RegExp(this.options.responsiveClass + "-\\S+\\s", "g"), "")).removeData("owl.carousel")
    }, l.prototype.op = function(t, e, i) {
        var s = this.settings.rtl;
        switch (e) {
            case "<":
                return s ? i < t : t < i;
            case ">":
                return s ? t < i : i < t;
            case ">=":
                return s ? t <= i : i <= t;
            case "<=":
                return s ? i <= t : t <= i
        }
    }, l.prototype.on = function(t, e, i, s) {
        t.addEventListener ? t.addEventListener(e, i, s) : t.attachEvent && t.attachEvent("on" + e, i)
    }, l.prototype.off = function(t, e, i, s) {
        t.removeEventListener ? t.removeEventListener(e, i, s) : t.detachEvent && t.detachEvent("on" + e, i)
    }, l.prototype.trigger = function(t, e, i, s, n) {
        var o = {
                item: {
                    count: this._items.length,
                    index: this.current()
                }
            },
            r = h.camelCase(h.grep(["on", t, i], function(t) {
                return t
            }).join("-").toLowerCase()),
            a = h.Event([t, "owl", i || "carousel"].join(".").toLowerCase(), h.extend({
                relatedTarget: this
            }, o, e));
        return this._supress[t] || (h.each(this._plugins, function(t, e) {
            e.onTrigger && e.onTrigger(a)
        }), this.register({
            type: l.Type.Event,
            name: t
        }), this.$element.trigger(a), this.settings && "function" == typeof this.settings[r] && this.settings[r].call(this, a)), a
    }, l.prototype.enter = function(t) {
        h.each([t].concat(this._states.tags[t] || []), h.proxy(function(t, e) {
            this._states.current[e] === a && (this._states.current[e] = 0), this._states.current[e]++
        }, this))
    }, l.prototype.leave = function(t) {
        h.each([t].concat(this._states.tags[t] || []), h.proxy(function(t, e) {
            this._states.current[e]--
        }, this))
    }, l.prototype.register = function(i) {
        if (i.type === l.Type.Event) {
            if (h.event.special[i.name] || (h.event.special[i.name] = {}), !h.event.special[i.name].owl) {
                var e = h.event.special[i.name]._default;
                h.event.special[i.name]._default = function(t) {
                    return !e || !e.apply || t.namespace && -1 !== t.namespace.indexOf("owl") ? t.namespace && -1 < t.namespace.indexOf("owl") : e.apply(this, arguments)
                }, h.event.special[i.name].owl = !0
            }
        } else i.type === l.Type.State && (this._states.tags[i.name] ? this._states.tags[i.name] = this._states.tags[i.name].concat(i.tags) : this._states.tags[i.name] = i.tags, this._states.tags[i.name] = h.grep(this._states.tags[i.name], h.proxy(function(t, e) {
            return h.inArray(t, this._states.tags[i.name]) === e
        }, this)))
    }, l.prototype.suppress = function(t) {
        h.each(t, h.proxy(function(t, e) {
            this._supress[e] = !0
        }, this))
    }, l.prototype.release = function(t) {
        h.each(t, h.proxy(function(t, e) {
            delete this._supress[e]
        }, this))
    }, l.prototype.pointer = function(t) {
        var e = {
            x: null,
            y: null
        };
        return (t = (t = t.originalEvent || t || i.event).touches && t.touches.length ? t.touches[0] : t.changedTouches && t.changedTouches.length ? t.changedTouches[0] : t).pageX ? (e.x = t.pageX, e.y = t.pageY) : (e.x = t.clientX, e.y = t.clientY), e
    }, l.prototype.isNumeric = function(t) {
        return !isNaN(parseFloat(t))
    }, l.prototype.difference = function(t, e) {
        return {
            x: t.x - e.x,
            y: t.y - e.y
        }
    }, h.fn.owlCarousel = function(e) {
        var s = Array.prototype.slice.call(arguments, 1);
        return this.each(function() {
            var t = h(this),
                i = t.data("owl.carousel");
            i || (i = new l(this, "object" == typeof e && e), t.data("owl.carousel", i), h.each(["next", "prev", "to", "destroy", "refresh", "replace", "add", "remove"], function(t, e) {
                i.register({
                    type: l.Type.Event,
                    name: e
                }), i.$element.on(e + ".owl.carousel.core", h.proxy(function(t) {
                    t.namespace && t.relatedTarget !== this && (this.suppress([e]), i[e].apply(this, [].slice.call(arguments, 1)), this.release([e]))
                }, i))
            })), "string" == typeof e && "_" !== e.charAt(0) && i[e].apply(i, s)
        })
    }, h.fn.owlCarousel.Constructor = l
}(window.Zepto || window.jQuery, window, document),
function(e, i) {
    var s = function(t) {
        this._core = t, this._interval = null, this._visible = null, this._handlers = {
            "initialized.owl.carousel": e.proxy(function(t) {
                t.namespace && this._core.settings.autoRefresh && this.watch()
            }, this)
        }, this._core.options = e.extend({}, s.Defaults, this._core.options), this._core.$element.on(this._handlers)
    };
    s.Defaults = {
        autoRefresh: !0,
        autoRefreshInterval: 500
    }, s.prototype.watch = function() {
        this._interval || (this._visible = this._core.isVisible(), this._interval = i.setInterval(e.proxy(this.refresh, this), this._core.settings.autoRefreshInterval))
    }, s.prototype.refresh = function() {
        this._core.isVisible() !== this._visible && (this._visible = !this._visible, this._core.$element.toggleClass("owl-hidden", !this._visible), this._visible && this._core.invalidate("width") && this._core.refresh())
    }, s.prototype.destroy = function() {
        var t, e;
        for (t in i.clearInterval(this._interval), this._handlers) this._core.$element.off(t, this._handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, e.fn.owlCarousel.Constructor.Plugins.AutoRefresh = s
}(window.Zepto || window.jQuery, window, document),
function(a, o) {
    var e = function(t) {
        this._core = t, this._loaded = [], this._handlers = {
            "initialized.owl.carousel change.owl.carousel resized.owl.carousel": a.proxy(function(t) {
                if (t.namespace && this._core.settings && this._core.settings.lazyLoad && (t.property && "position" == t.property.name || "initialized" == t.type)) {
                    var e = this._core.settings,
                        i = e.center && Math.ceil(e.items / 2) || e.items,
                        s = e.center && -1 * i || 0,
                        n = (t.property && void 0 !== t.property.value ? t.property.value : this._core.current()) + s,
                        o = this._core.clones().length,
                        r = a.proxy(function(t, e) {
                            this.load(e)
                        }, this);
                    for (0 < e.lazyLoadEager && (i += e.lazyLoadEager, e.loop && (n -= e.lazyLoadEager, i++)); s++ < i;) this.load(o / 2 + this._core.relative(n)), o && a.each(this._core.clones(this._core.relative(n)), r), n++
                }
            }, this)
        }, this._core.options = a.extend({}, e.Defaults, this._core.options), this._core.$element.on(this._handlers)
    };
    e.Defaults = {
        lazyLoad: !1,
        lazyLoadEager: 0
    }, e.prototype.load = function(t) {
        var e = this._core.$stage.children().eq(t),
            i = e && e.find(".owl-lazy");
        !i || -1 < a.inArray(e.get(0), this._loaded) || (i.each(a.proxy(function(t, e) {
            var i, s = a(e),
                n = 1 < o.devicePixelRatio && s.attr("data-src-retina") || s.attr("data-src") || s.attr("data-srcset");
            this._core.trigger("load", {
                element: s,
                url: n
            }, "lazy"), s.is("img") ? s.one("load.owl.lazy", a.proxy(function() {
                s.css("opacity", 1), this._core.trigger("loaded", {
                    element: s,
                    url: n
                }, "lazy")
            }, this)).attr("src", n) : s.is("source") ? s.one("load.owl.lazy", a.proxy(function() {
                this._core.trigger("loaded", {
                    element: s,
                    url: n
                }, "lazy")
            }, this)).attr("srcset", n) : ((i = new Image).onload = a.proxy(function() {
                s.css({
                    "background-image": 'url("' + n + '")',
                    opacity: "1"
                }), this._core.trigger("loaded", {
                    element: s,
                    url: n
                }, "lazy")
            }, this), i.src = n)
        }, this)), this._loaded.push(e.get(0)))
    }, e.prototype.destroy = function() {
        var t, e;
        for (t in this.handlers) this._core.$element.off(t, this.handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.Lazy = e
}(window.Zepto || window.jQuery, window, document),
function(r, i) {
    var s = function(t) {
        this._core = t, this._previousHeight = null, this._handlers = {
            "initialized.owl.carousel refreshed.owl.carousel": r.proxy(function(t) {
                t.namespace && this._core.settings.autoHeight && this.update()
            }, this),
            "changed.owl.carousel": r.proxy(function(t) {
                t.namespace && this._core.settings.autoHeight && "position" === t.property.name && this.update()
            }, this),
            "loaded.owl.lazy": r.proxy(function(t) {
                t.namespace && this._core.settings.autoHeight && t.element.closest("." + this._core.settings.itemClass).index() === this._core.current() && this.update()
            }, this)
        }, this._core.options = r.extend({}, s.Defaults, this._core.options), this._core.$element.on(this._handlers), this._intervalId = null;
        var e = this;
        r(i).on("load", function() {
            e._core.settings.autoHeight && e.update()
        }), r(i).resize(function() {
            e._core.settings.autoHeight && (null != e._intervalId && clearTimeout(e._intervalId), e._intervalId = setTimeout(function() {
                e.update()
            }, 250))
        })
    };
    s.Defaults = {
        autoHeight: !1,
        autoHeightClass: "owl-height"
    }, s.prototype.update = function() {
        var t = this._core._current,
            e = t + this._core.settings.items,
            i = this._core.settings.lazyLoad,
            s = this._core.$stage.children().toArray().slice(t, e),
            n = [],
            o = 0;
        r.each(s, function(t, e) {
            n.push(r(e).height())
        }), (o = Math.max.apply(null, n)) <= 1 && i && this._previousHeight && (o = this._previousHeight), this._previousHeight = o, this._core.$stage.parent().height(o).addClass(this._core.settings.autoHeightClass)
    }, s.prototype.destroy = function() {
        var t, e;
        for (t in this._handlers) this._core.$element.off(t, this._handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, r.fn.owlCarousel.Constructor.Plugins.AutoHeight = s
}(window.Zepto || window.jQuery, window, document),
function(c, e) {
    var i = function(t) {
        this._core = t, this._videos = {}, this._playing = null, this._handlers = {
            "initialized.owl.carousel": c.proxy(function(t) {
                t.namespace && this._core.register({
                    type: "state",
                    name: "playing",
                    tags: ["interacting"]
                })
            }, this),
            "resize.owl.carousel": c.proxy(function(t) {
                t.namespace && this._core.settings.video && this.isInFullScreen() && t.preventDefault()
            }, this),
            "refreshed.owl.carousel": c.proxy(function(t) {
                t.namespace && this._core.is("resizing") && this._core.$stage.find(".cloned .owl-video-frame").remove()
            }, this),
            "changed.owl.carousel": c.proxy(function(t) {
                t.namespace && "position" === t.property.name && this._playing && this.stop()
            }, this),
            "prepared.owl.carousel": c.proxy(function(t) {
                if (t.namespace) {
                    var e = c(t.content).find(".owl-video");
                    e.length && (e.css("display", "none"), this.fetch(e, c(t.content)))
                }
            }, this)
        }, this._core.options = c.extend({}, i.Defaults, this._core.options), this._core.$element.on(this._handlers), this._core.$element.on("click.owl.video", ".owl-video-play-icon", c.proxy(function(t) {
            this.play(t)
        }, this))
    };
    i.Defaults = {
        video: !1,
        videoHeight: !1,
        videoWidth: !1
    }, i.prototype.fetch = function(t, e) {
        var i = t.attr("data-vimeo-id") ? "vimeo" : t.attr("data-vzaar-id") ? "vzaar" : "youtube",
            s = t.attr("data-vimeo-id") || t.attr("data-youtube-id") || t.attr("data-vzaar-id"),
            n = t.attr("data-width") || this._core.settings.videoWidth,
            o = t.attr("data-height") || this._core.settings.videoHeight,
            r = t.attr("href");
        if (!r) throw new Error("Missing video URL.");
        if (-1 < (s = r.match(/(http:|https:|)\/\/(player.|www.|app.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com|be\-nocookie\.com)|vzaar\.com)\/(video\/|videos\/|embed\/|channels\/.+\/|groups\/.+\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/))[3].indexOf("youtu")) i = "youtube";
        else if (-1 < s[3].indexOf("vimeo")) i = "vimeo";
        else {
            if (!(-1 < s[3].indexOf("vzaar"))) throw new Error("Video URL not supported.");
            i = "vzaar"
        }
        s = s[6], this._videos[r] = {
            type: i,
            id: s,
            width: n,
            height: o
        }, e.attr("data-video", r), this.thumbnail(t, this._videos[r])
    }, i.prototype.thumbnail = function(e, t) {
        function i(t) {
            s = l.lazyLoad ? c("<div/>", {
                class: "owl-video-tn " + h,
                srcType: t
            }) : c("<div/>", {
                class: "owl-video-tn",
                style: "opacity:1;background-image:url(" + t + ")"
            }), e.after(s), e.after('<div class="owl-video-play-icon"></div>')
        }
        var s, n, o = t.width && t.height ? "width:" + t.width + "px;height:" + t.height + "px;" : "",
            r = e.find("img"),
            a = "src",
            h = "",
            l = this._core.settings;
        if (e.wrap(c("<div/>", {
                class: "owl-video-wrapper",
                style: o
            })), this._core.settings.lazyLoad && (a = "data-src", h = "owl-lazy"), r.length) return i(r.attr(a)), r.remove(), !1;
        "youtube" === t.type ? (n = "//img.youtube.com/vi/" + t.id + "/hqdefault.jpg", i(n)) : "vimeo" === t.type ? c.ajax({
            type: "GET",
            url: "//vimeo.com/api/v2/video/" + t.id + ".json",
            jsonp: "callback",
            dataType: "jsonp",
            success: function(t) {
                n = t[0].thumbnail_large, i(n)
            }
        }) : "vzaar" === t.type && c.ajax({
            type: "GET",
            url: "//vzaar.com/api/videos/" + t.id + ".json",
            jsonp: "callback",
            dataType: "jsonp",
            success: function(t) {
                n = t.framegrab_url, i(n)
            }
        })
    }, i.prototype.stop = function() {
        this._core.trigger("stop", null, "video"), this._playing.find(".owl-video-frame").remove(), this._playing.removeClass("owl-video-playing"), this._playing = null, this._core.leave("playing"), this._core.trigger("stopped", null, "video")
    }, i.prototype.play = function(t) {
        var e, i = c(t.target).closest("." + this._core.settings.itemClass),
            s = this._videos[i.attr("data-video")],
            n = s.width || "100%",
            o = s.height || this._core.$stage.height();
        this._playing || (this._core.enter("playing"), this._core.trigger("play", null, "video"), i = this._core.items(this._core.relative(i.index())), this._core.reset(i.index()), (e = c('<iframe frameborder="0" allowfullscreen mozallowfullscreen webkitAllowFullScreen ></iframe>')).attr("height", o), e.attr("width", n), "youtube" === s.type ? e.attr("src", "//www.youtube.com/embed/" + s.id + "?autoplay=1&rel=0&v=" + s.id) : "vimeo" === s.type ? e.attr("src", "//player.vimeo.com/video/" + s.id + "?autoplay=1") : "vzaar" === s.type && e.attr("src", "//view.vzaar.com/" + s.id + "/player?autoplay=true"), c(e).wrap('<div class="owl-video-frame" />').insertAfter(i.find(".owl-video")), this._playing = i.addClass("owl-video-playing"))
    }, i.prototype.isInFullScreen = function() {
        var t = e.fullscreenElement || e.mozFullScreenElement || e.webkitFullscreenElement;
        return t && c(t).parent().hasClass("owl-video-frame")
    }, i.prototype.destroy = function() {
        var t, e;
        for (t in this._core.$element.off("click.owl.video"), this._handlers) this._core.$element.off(t, this._handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, c.fn.owlCarousel.Constructor.Plugins.Video = i
}(window.Zepto || window.jQuery, (window, document)),
function(r) {
    var e = function(t) {
        this.core = t, this.core.options = r.extend({}, e.Defaults, this.core.options), this.swapping = !0, this.previous = void 0, this.next = void 0, this.handlers = {
            "change.owl.carousel": r.proxy(function(t) {
                t.namespace && "position" == t.property.name && (this.previous = this.core.current(), this.next = t.property.value)
            }, this),
            "drag.owl.carousel dragged.owl.carousel translated.owl.carousel": r.proxy(function(t) {
                t.namespace && (this.swapping = "translated" == t.type)
            }, this),
            "translate.owl.carousel": r.proxy(function(t) {
                t.namespace && this.swapping && (this.core.options.animateOut || this.core.options.animateIn) && this.swap()
            }, this)
        }, this.core.$element.on(this.handlers)
    };
    e.Defaults = {
        animateOut: !1,
        animateIn: !1
    }, e.prototype.swap = function() {
        if (1 === this.core.settings.items && r.support.animation && r.support.transition) {
            this.core.speed(0);
            var t, e = r.proxy(this.clear, this),
                i = this.core.$stage.children().eq(this.previous),
                s = this.core.$stage.children().eq(this.next),
                n = this.core.settings.animateIn,
                o = this.core.settings.animateOut;
            this.core.current() !== this.previous && (o && (t = this.core.coordinates(this.previous) - this.core.coordinates(this.next), i.one(r.support.animation.end, e).css({
                left: t + "px"
            }).addClass("animated owl-animated-out").addClass(o)), n && s.one(r.support.animation.end, e).addClass("animated owl-animated-in").addClass(n))
        }
    }, e.prototype.clear = function(t) {
        r(t.target).css({
            left: ""
        }).removeClass("animated owl-animated-out owl-animated-in").removeClass(this.core.settings.animateIn).removeClass(this.core.settings.animateOut), this.core.onTransitionEnd()
    }, e.prototype.destroy = function() {
        var t, e;
        for (t in this.handlers) this.core.$element.off(t, this.handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, r.fn.owlCarousel.Constructor.Plugins.Animate = e
}(window.Zepto || window.jQuery, (window, document)),
function(s, n, e) {
    var i = function(t) {
        this._core = t, this._call = null, this._time = 0, this._timeout = 0, this._paused = !0, this._handlers = {
            "changed.owl.carousel": s.proxy(function(t) {
                t.namespace && "settings" === t.property.name ? this._core.settings.autoplay ? this.play() : this.stop() : t.namespace && "position" === t.property.name && this._paused && (this._time = 0)
            }, this),
            "initialized.owl.carousel": s.proxy(function(t) {
                t.namespace && this._core.settings.autoplay && this.play()
            }, this),
            "play.owl.autoplay": s.proxy(function(t, e, i) {
                t.namespace && this.play(e, i)
            }, this),
            "stop.owl.autoplay": s.proxy(function(t) {
                t.namespace && this.stop()
            }, this),
            "mouseover.owl.autoplay": s.proxy(function() {
                this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.pause()
            }, this),
            "mouseleave.owl.autoplay": s.proxy(function() {
                this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.play()
            }, this),
            "touchstart.owl.core": s.proxy(function() {
                this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.pause()
            }, this),
            "touchend.owl.core": s.proxy(function() {
                this._core.settings.autoplayHoverPause && this.play()
            }, this)
        }, this._core.$element.on(this._handlers), this._core.options = s.extend({}, i.Defaults, this._core.options)
    };
    i.Defaults = {
        autoplay: !1,
        autoplayTimeout: 5e3,
        autoplayHoverPause: !1,
        autoplaySpeed: !1
    }, i.prototype._next = function(t) {
        this._call = n.setTimeout(s.proxy(this._next, this, t), this._timeout * (Math.round(this.read() / this._timeout) + 1) - this.read()), this._core.is("interacting") || e.hidden || this._core.next(t || this._core.settings.autoplaySpeed)
    }, i.prototype.read = function() {
        return (new Date).getTime() - this._time
    }, i.prototype.play = function(t, e) {
        var i;
        this._core.is("rotating") || this._core.enter("rotating"), t = t || this._core.settings.autoplayTimeout, i = Math.min(this._time % (this._timeout || t), t), this._paused ? (this._time = this.read(), this._paused = !1) : n.clearTimeout(this._call), this._time += this.read() % t - i, this._timeout = t, this._call = n.setTimeout(s.proxy(this._next, this, e), t - i)
    }, i.prototype.stop = function() {
        this._core.is("rotating") && (this._time = 0, this._paused = !0, n.clearTimeout(this._call), this._core.leave("rotating"))
    }, i.prototype.pause = function() {
        this._core.is("rotating") && !this._paused && (this._time = this.read(), this._paused = !0, n.clearTimeout(this._call))
    }, i.prototype.destroy = function() {
        var t, e;
        for (t in this.stop(), this._handlers) this._core.$element.off(t, this._handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, s.fn.owlCarousel.Constructor.Plugins.autoplay = i
}(window.Zepto || window.jQuery, window, document),
function(o) {
    "use strict";
    var e = function(t) {
        this._core = t, this._initialized = !1, this._pages = [], this._controls = {}, this._templates = [], this.$element = this._core.$element, this._overrides = {
            next: this._core.next,
            prev: this._core.prev,
            to: this._core.to
        }, this._handlers = {
            "prepared.owl.carousel": o.proxy(function(t) {
                t.namespace && this._core.settings.dotsData && this._templates.push('<div class="' + this._core.settings.dotClass + '">' + o(t.content).find("[data-dot]").addBack("[data-dot]").attr("data-dot") + "</div>")
            }, this),
            "added.owl.carousel": o.proxy(function(t) {
                t.namespace && this._core.settings.dotsData && this._templates.splice(t.position, 0, this._templates.pop())
            }, this),
            "remove.owl.carousel": o.proxy(function(t) {
                t.namespace && this._core.settings.dotsData && this._templates.splice(t.position, 1)
            }, this),
            "changed.owl.carousel": o.proxy(function(t) {
                t.namespace && "position" == t.property.name && this.draw()
            }, this),
            "initialized.owl.carousel": o.proxy(function(t) {
                t.namespace && !this._initialized && (this._core.trigger("initialize", null, "navigation"), this.initialize(), this.update(), this.draw(), this._initialized = !0, this._core.trigger("initialized", null, "navigation"))
            }, this),
            "refreshed.owl.carousel": o.proxy(function(t) {
                t.namespace && this._initialized && (this._core.trigger("refresh", null, "navigation"), this.update(), this.draw(), this._core.trigger("refreshed", null, "navigation"))
            }, this)
        }, this._core.options = o.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers)
    };
    e.Defaults = {
        nav: !1,
        navText: ['<span aria-label="Previous">&#x2039;</span>', '<span aria-label="Next">&#x203a;</span>'],
        navSpeed: !1,
        navElement: 'button type="button" role="presentation"',
        navContainer: !1,
        navContainerClass: "owl-nav",
        navClass: ["owl-prev", "owl-next"],
        slideBy: 1,
        dotClass: "owl-dot",
        dotsClass: "owl-dots",
        dots: !0,
        dotsEach: !1,
        dotsData: !1,
        dotsSpeed: !1,
        dotsContainer: !1
    }, e.prototype.initialize = function() {
        var t, i = this._core.settings;
        for (t in this._controls.$relative = (i.navContainer ? o(i.navContainer) : o("<div>").addClass(i.navContainerClass).appendTo(this.$element)).addClass("disabled"), this._controls.$previous = o("<" + i.navElement + ">").addClass(i.navClass[0]).html(i.navText[0]).prependTo(this._controls.$relative).on("click", o.proxy(function(t) {
                this.prev(i.navSpeed)
            }, this)), this._controls.$next = o("<" + i.navElement + ">").addClass(i.navClass[1]).html(i.navText[1]).appendTo(this._controls.$relative).on("click", o.proxy(function(t) {
                this.next(i.navSpeed)
            }, this)), i.dotsData || (this._templates = [o('<button role="button">').addClass(i.dotClass).append(o("<span>")).prop("outerHTML")]), this._controls.$absolute = (i.dotsContainer ? o(i.dotsContainer) : o("<div>").addClass(i.dotsClass).appendTo(this.$element)).addClass("disabled"), this._controls.$absolute.on("click", "button", o.proxy(function(t) {
                var e = o(t.target).parent().is(this._controls.$absolute) ? o(t.target).index() : o(t.target).parent().index();
                t.preventDefault(), this.to(e, i.dotsSpeed)
            }, this)), this._overrides) this._core[t] = o.proxy(this[t], this)
    }, e.prototype.destroy = function() {
        var t, e, i, s, n;
        for (t in n = this._core.settings, this._handlers) this.$element.off(t, this._handlers[t]);
        for (e in this._controls) "$relative" === e && n.navContainer ? this._controls[e].html("") : this._controls[e].remove();
        for (s in this.overides) this._core[s] = this._overrides[s];
        for (i in Object.getOwnPropertyNames(this)) "function" != typeof this[i] && (this[i] = null)
    }, e.prototype.update = function() {
        var t, e, i = this._core.clones().length / 2,
            s = i + this._core.items().length,
            n = this._core.maximum(!0),
            o = this._core.settings,
            r = o.center || o.autoWidth || o.dotsData ? 1 : o.dotsEach || o.items;
        if ("page" !== o.slideBy && (o.slideBy = Math.min(o.slideBy, o.items)), o.dots || "page" == o.slideBy)
            for (this._pages = [], t = i, e = 0; t < s; t++) {
                if (r <= e || 0 === e) {
                    if (this._pages.push({
                            start: Math.min(n, t - i),
                            end: t - i + r - 1
                        }), Math.min(n, t - i) === n) break;
                    e = 0, 0
                }
                e += this._core.mergers(this._core.relative(t))
            }
    }, e.prototype.draw = function() {
        var t, e = this._core.settings,
            i = this._core.items().length <= e.items,
            s = this._core.relative(this._core.current()),
            n = e.loop || e.rewind;
        this._controls.$relative.toggleClass("disabled", !e.nav || i), e.nav && (this._controls.$previous.toggleClass("disabled", !n && s <= this._core.minimum(!0)), this._controls.$next.toggleClass("disabled", !n && s >= this._core.maximum(!0))), this._controls.$absolute.toggleClass("disabled", !e.dots || i), e.dots && (t = this._pages.length - this._controls.$absolute.children().length, e.dotsData && 0 != t ? this._controls.$absolute.html(this._templates.join("")) : 0 < t ? this._controls.$absolute.append(new Array(1 + t).join(this._templates[0])) : t < 0 && this._controls.$absolute.children().slice(t).remove(), this._controls.$absolute.find(".active").removeClass("active"), this._controls.$absolute.children().eq(o.inArray(this.current(), this._pages)).addClass("active"))
    }, e.prototype.onTrigger = function(t) {
        var e = this._core.settings;
        t.page = {
            index: o.inArray(this.current(), this._pages),
            count: this._pages.length,
            size: e && (e.center || e.autoWidth || e.dotsData ? 1 : e.dotsEach || e.items)
        }
    }, e.prototype.current = function() {
        var i = this._core.relative(this._core.current());
        return o.grep(this._pages, o.proxy(function(t, e) {
            return t.start <= i && t.end >= i
        }, this)).pop()
    }, e.prototype.getPosition = function(t) {
        var e, i, s = this._core.settings;
        return "page" == s.slideBy ? (e = o.inArray(this.current(), this._pages), i = this._pages.length, t ? ++e : --e, e = this._pages[(e % i + i) % i].start) : (e = this._core.relative(this._core.current()), i = this._core.items().length, t ? e += s.slideBy : e -= s.slideBy), e
    }, e.prototype.next = function(t) {
        o.proxy(this._overrides.to, this._core)(this.getPosition(!0), t)
    }, e.prototype.prev = function(t) {
        o.proxy(this._overrides.to, this._core)(this.getPosition(!1), t)
    }, e.prototype.to = function(t, e, i) {
        var s;
        !i && this._pages.length ? (s = this._pages.length, o.proxy(this._overrides.to, this._core)(this._pages[(t % s + s) % s].start, e)) : o.proxy(this._overrides.to, this._core)(t, e)
    }, o.fn.owlCarousel.Constructor.Plugins.Navigation = e
}(window.Zepto || window.jQuery, (window, document)),
function(s, n) {
    "use strict";
    var e = function(t) {
        this._core = t, this._hashes = {}, this.$element = this._core.$element, this._handlers = {
            "initialized.owl.carousel": s.proxy(function(t) {
                t.namespace && "URLHash" === this._core.settings.startPosition && s(n).trigger("hashchange.owl.navigation")
            }, this),
            "prepared.owl.carousel": s.proxy(function(t) {
                if (t.namespace) {
                    var e = s(t.content).find("[data-hash]").addBack("[data-hash]").attr("data-hash");
                    if (!e) return;
                    this._hashes[e] = t.content
                }
            }, this),
            "changed.owl.carousel": s.proxy(function(t) {
                if (t.namespace && "position" === t.property.name) {
                    var i = this._core.items(this._core.relative(this._core.current())),
                        e = s.map(this._hashes, function(t, e) {
                            return t === i ? e : null
                        }).join();
                    if (!e || n.location.hash.slice(1) === e) return;
                    n.location.hash = e
                }
            }, this)
        }, this._core.options = s.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers), s(n).on("hashchange.owl.navigation", s.proxy(function(t) {
            var e = n.location.hash.substring(1),
                i = this._core.$stage.children(),
                s = this._hashes[e] && i.index(this._hashes[e]);
            void 0 !== s && s !== this._core.current() && this._core.to(this._core.relative(s), !1, !0)
        }, this))
    };
    e.Defaults = {
        URLhashListener: !1
    }, e.prototype.destroy = function() {
        var t, e;
        for (t in s(n).off("hashchange.owl.navigation"), this._handlers) this._core.$element.off(t, this._handlers[t]);
        for (e in Object.getOwnPropertyNames(this)) "function" != typeof this[e] && (this[e] = null)
    }, s.fn.owlCarousel.Constructor.Plugins.Hash = e
}(window.Zepto || window.jQuery, window, document),
function(n, o) {
    var r = n("<support>").get(0).style,
        a = "Webkit Moz O ms".split(" "),
        t = {
            transition: {
                end: {
                    WebkitTransition: "webkitTransitionEnd",
                    MozTransition: "transitionend",
                    OTransition: "oTransitionEnd",
                    transition: "transitionend"
                }
            },
            animation: {
                end: {
                    WebkitAnimation: "webkitAnimationEnd",
                    MozAnimation: "animationend",
                    OAnimation: "oAnimationEnd",
                    animation: "animationend"
                }
            }
        },
        e = function() {
            return !!h("transform")
        },
        i = function() {
            return !!h("perspective")
        },
        s = function() {
            return !!h("animation")
        };

    function h(t, i) {
        var s = !1,
            e = t.charAt(0).toUpperCase() + t.slice(1);
        return n.each((t + " " + a.join(e + " ") + e).split(" "), function(t, e) {
            if (r[e] !== o) return s = !i || e, !1
        }), s
    }

    function l(t) {
        return h(t, !0)
    }! function() {
        return !!h("transition")
    }() || (n.support.transition = new String(l("transition")), n.support.transition.end = t.transition.end[n.support.transition]), s() && (n.support.animation = new String(l("animation")), n.support.animation.end = t.animation.end[n.support.animation]), e() && (n.support.transform = new String(l("transform")), n.support.transform3d = i())
}(window.Zepto || window.jQuery, (window, void document));

! function(t, e) {
    "object" == typeof exports && "undefined" != typeof module ? e(exports, require("jquery"), require("popper.js")) : "function" == typeof define && define.amd ? define(["exports", "jquery", "popper.js"], e) : e((t = t || self).bootstrap = {}, t.jQuery, t.Popper)
}(this, function(t, g, u) {
    "use strict";

    function i(t, e) {
        for (var n = 0; n < e.length; n++) {
            var i = e[n];
            i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(t, i.key, i)
        }
    }

    function s(t, e, n) {
        return e && i(t.prototype, e), n && i(t, n), t
    }

    function r(o) {
        for (var t = 1; t < arguments.length; t++) {
            var s = null != arguments[t] ? arguments[t] : {},
                e = Object.keys(s);
            "function" == typeof Object.getOwnPropertySymbols && (e = e.concat(Object.getOwnPropertySymbols(s).filter(function(t) {
                return Object.getOwnPropertyDescriptor(s, t).enumerable
            }))), e.forEach(function(t) {
                var e, n, i;
                e = o, i = s[n = t], n in e ? Object.defineProperty(e, n, {
                    value: i,
                    enumerable: !0,
                    configurable: !0,
                    writable: !0
                }) : e[n] = i
            })
        }
        return o
    }
    g = g && g.hasOwnProperty("default") ? g.default : g, u = u && u.hasOwnProperty("default") ? u.default : u;
    var e = "transitionend";
    var _ = {
        TRANSITION_END: "bsTransitionEnd",
        getUID: function(t) {
            for (; t += ~~(1e6 * Math.random()), document.getElementById(t););
            return t
        },
        getSelectorFromElement: function(t) {
            var e = t.getAttribute("data-target");
            if (!e || "#" === e) {
                var n = t.getAttribute("href");
                e = n && "#" !== n ? n.trim() : ""
            }
            try {
                return document.querySelector(e) ? e : null
            } catch (t) {
                return null
            }
        },
        getTransitionDurationFromElement: function(t) {
            if (!t) return 0;
            var e = g(t).css("transition-duration"),
                n = g(t).css("transition-delay"),
                i = parseFloat(e),
                o = parseFloat(n);
            return i || o ? (e = e.split(",")[0], n = n.split(",")[0], 1e3 * (parseFloat(e) + parseFloat(n))) : 0
        },
        reflow: function(t) {
            return t.offsetHeight
        },
        triggerTransitionEnd: function(t) {
            g(t).trigger(e)
        },
        supportsTransitionEnd: function() {
            return Boolean(e)
        },
        isElement: function(t) {
            return (t[0] || t).nodeType
        },
        typeCheckConfig: function(t, e, n) {
            for (var i in n)
                if (Object.prototype.hasOwnProperty.call(n, i)) {
                    var o = n[i],
                        s = e[i],
                        r = s && _.isElement(s) ? "element" : {}.toString.call(s).match(/\s([a-z]+)/i)[1].toLowerCase();
                    if (!new RegExp(o).test(r)) throw new Error(t.toUpperCase() + ': Option "' + i + '" provided type "' + r + '" but expected type "' + o + '".')
                }
        },
        findShadowRoot: function(t) {
            if (!document.documentElement.attachShadow) return null;
            if ("function" != typeof t.getRootNode) return t instanceof ShadowRoot ? t : t.parentNode ? _.findShadowRoot(t.parentNode) : null;
            var e = t.getRootNode();
            return e instanceof ShadowRoot ? e : null
        }
    };
    g.fn.emulateTransitionEnd = function(t) {
        var e = this,
            n = !1;
        return g(this).one(_.TRANSITION_END, function() {
            n = !0
        }), setTimeout(function() {
            n || _.triggerTransitionEnd(e)
        }, t), this
    }, g.event.special[_.TRANSITION_END] = {
        bindType: e,
        delegateType: e,
        handle: function(t) {
            if (g(t.target).is(this)) return t.handleObj.handler.apply(this, arguments)
        }
    };
    var n, o = "alert",
        a = "bs.alert",
        l = "." + a,
        c = g.fn[o],
        h = {
            CLOSE: "close" + l,
            CLOSED: "closed" + l,
            CLICK_DATA_API: "click" + l + ".data-api"
        },
        f = ((n = d.prototype).close = function(t) {
            var e = this._element;
            t && (e = this._getRootElement(t)), this._triggerCloseEvent(e).isDefaultPrevented() || this._removeElement(e)
        }, n.dispose = function() {
            g.removeData(this._element, a), this._element = null
        }, n._getRootElement = function(t) {
            var e = _.getSelectorFromElement(t),
                n = !1;
            return e && (n = document.querySelector(e)), n = n || g(t).closest(".alert")[0]
        }, n._triggerCloseEvent = function(t) {
            var e = g.Event(h.CLOSE);
            return g(t).trigger(e), e
        }, n._removeElement = function(e) {
            var n = this;
            if (g(e).removeClass("show"), g(e).hasClass("fade")) {
                var t = _.getTransitionDurationFromElement(e);
                g(e).one(_.TRANSITION_END, function(t) {
                    return n._destroyElement(e, t)
                }).emulateTransitionEnd(t)
            } else this._destroyElement(e)
        }, n._destroyElement = function(t) {
            g(t).detach().trigger(h.CLOSED).remove()
        }, d._jQueryInterface = function(n) {
            return this.each(function() {
                var t = g(this),
                    e = t.data(a);
                e || (e = new d(this), t.data(a, e)), "close" === n && e[n](this)
            })
        }, d._handleDismiss = function(e) {
            return function(t) {
                t && t.preventDefault(), e.close(this)
            }
        }, s(d, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }]), d);

    function d(t) {
        this._element = t
    }
    g(document).on(h.CLICK_DATA_API, '[data-dismiss="alert"]', f._handleDismiss(new f)), g.fn[o] = f._jQueryInterface, g.fn[o].Constructor = f, g.fn[o].noConflict = function() {
        return g.fn[o] = c, f._jQueryInterface
    };
    var m, p = "button",
        v = "bs.button",
        E = "." + v,
        y = ".data-api",
        C = g.fn[p],
        T = "active",
        S = '[data-toggle^="button"]',
        b = ".btn",
        I = {
            CLICK_DATA_API: "click" + E + y,
            FOCUS_BLUR_DATA_API: "focus" + E + y + " blur" + E + y
        },
        D = ((m = w.prototype).toggle = function() {
            var t = !0,
                e = !0,
                n = g(this._element).closest('[data-toggle="buttons"]')[0];
            if (n) {
                var i = this._element.querySelector('input:not([type="hidden"])');
                if (i) {
                    if ("radio" === i.type)
                        if (i.checked && this._element.classList.contains(T)) t = !1;
                        else {
                            var o = n.querySelector(".active");
                            o && g(o).removeClass(T)
                        }
                    if (t) {
                        if (i.hasAttribute("disabled") || n.hasAttribute("disabled") || i.classList.contains("disabled") || n.classList.contains("disabled")) return;
                        i.checked = !this._element.classList.contains(T), g(i).trigger("change")
                    }
                    i.focus(), e = !1
                }
            }
            e && this._element.setAttribute("aria-pressed", !this._element.classList.contains(T)), t && g(this._element).toggleClass(T)
        }, m.dispose = function() {
            g.removeData(this._element, v), this._element = null
        }, w._jQueryInterface = function(e) {
            return this.each(function() {
                var t = g(this).data(v);
                t || (t = new w(this), g(this).data(v, t)), "toggle" === e && t[e]()
            })
        }, s(w, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }]), w);

    function w(t) {
        this._element = t
    }
    g(document).on(I.CLICK_DATA_API, S, function(t) {
        t.preventDefault();
        var e = t.target;
        g(e).hasClass("btn") || (e = g(e).closest(b)), D._jQueryInterface.call(g(e), "toggle")
    }).on(I.FOCUS_BLUR_DATA_API, S, function(t) {
        var e = g(t.target).closest(b)[0];
        g(e).toggleClass("focus", /^focus(in)?$/.test(t.type))
    }), g.fn[p] = D._jQueryInterface, g.fn[p].Constructor = D, g.fn[p].noConflict = function() {
        return g.fn[p] = C, D._jQueryInterface
    };
    var A, N = "carousel",
        O = "bs.carousel",
        k = "." + O,
        P = ".data-api",
        L = g.fn[N],
        j = {
            interval: 5e3,
            keyboard: !0,
            slide: !1,
            pause: "hover",
            wrap: !0,
            touch: !0
        },
        H = {
            interval: "(number|boolean)",
            keyboard: "boolean",
            slide: "(boolean|string)",
            pause: "(string|boolean)",
            wrap: "boolean",
            touch: "boolean"
        },
        R = "next",
        x = "prev",
        F = {
            SLIDE: "slide" + k,
            SLID: "slid" + k,
            KEYDOWN: "keydown" + k,
            MOUSEENTER: "mouseenter" + k,
            MOUSELEAVE: "mouseleave" + k,
            TOUCHSTART: "touchstart" + k,
            TOUCHMOVE: "touchmove" + k,
            TOUCHEND: "touchend" + k,
            POINTERDOWN: "pointerdown" + k,
            POINTERUP: "pointerup" + k,
            DRAG_START: "dragstart" + k,
            LOAD_DATA_API: "load" + k + P,
            CLICK_DATA_API: "click" + k + P
        },
        U = "active",
        W = ".active.carousel-item",
        q = {
            TOUCH: "touch",
            PEN: "pen"
        },
        M = ((A = K.prototype).next = function() {
            this._isSliding || this._slide(R)
        }, A.nextWhenVisible = function() {
            !document.hidden && g(this._element).is(":visible") && "hidden" !== g(this._element).css("visibility") && this.next()
        }, A.prev = function() {
            this._isSliding || this._slide(x)
        }, A.pause = function(t) {
            t || (this._isPaused = !0), this._element.querySelector(".carousel-item-next, .carousel-item-prev") && (_.triggerTransitionEnd(this._element), this.cycle(!0)), clearInterval(this._interval), this._interval = null
        }, A.cycle = function(t) {
            t || (this._isPaused = !1), this._interval && (clearInterval(this._interval), this._interval = null), this._config.interval && !this._isPaused && (this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval))
        }, A.to = function(t) {
            var e = this;
            this._activeElement = this._element.querySelector(W);
            var n = this._getItemIndex(this._activeElement);
            if (!(t > this._items.length - 1 || t < 0))
                if (this._isSliding) g(this._element).one(F.SLID, function() {
                    return e.to(t)
                });
                else {
                    if (n === t) return this.pause(), void this.cycle();
                    var i = n < t ? R : x;
                    this._slide(i, this._items[t])
                }
        }, A.dispose = function() {
            g(this._element).off(k), g.removeData(this._element, O), this._items = null, this._config = null, this._element = null, this._interval = null, this._isPaused = null, this._isSliding = null, this._activeElement = null, this._indicatorsElement = null
        }, A._getConfig = function(t) {
            return t = r({}, j, t), _.typeCheckConfig(N, t, H), t
        }, A._handleSwipe = function() {
            var t = Math.abs(this.touchDeltaX);
            if (!(t <= 40)) {
                var e = t / this.touchDeltaX;
                0 < e && this.prev(), e < 0 && this.next()
            }
        }, A._addEventListeners = function() {
            var e = this;
            this._config.keyboard && g(this._element).on(F.KEYDOWN, function(t) {
                return e._keydown(t)
            }), "hover" === this._config.pause && g(this._element).on(F.MOUSEENTER, function(t) {
                return e.pause(t)
            }).on(F.MOUSELEAVE, function(t) {
                return e.cycle(t)
            }), this._config.touch && this._addTouchEventListeners()
        }, A._addTouchEventListeners = function() {
            var n = this;
            if (this._touchSupported) {
                var e = function(t) {
                        n._pointerEvent && q[t.originalEvent.pointerType.toUpperCase()] ? n.touchStartX = t.originalEvent.clientX : n._pointerEvent || (n.touchStartX = t.originalEvent.touches[0].clientX)
                    },
                    i = function(t) {
                        n._pointerEvent && q[t.originalEvent.pointerType.toUpperCase()] && (n.touchDeltaX = t.originalEvent.clientX - n.touchStartX), n._handleSwipe(), "hover" === n._config.pause && (n.pause(), n.touchTimeout && clearTimeout(n.touchTimeout), n.touchTimeout = setTimeout(function(t) {
                            return n.cycle(t)
                        }, 500 + n._config.interval))
                    };
                g(this._element.querySelectorAll(".carousel-item img")).on(F.DRAG_START, function(t) {
                    return t.preventDefault()
                }), this._pointerEvent ? (g(this._element).on(F.POINTERDOWN, function(t) {
                    return e(t)
                }), g(this._element).on(F.POINTERUP, function(t) {
                    return i(t)
                }), this._element.classList.add("pointer-event")) : (g(this._element).on(F.TOUCHSTART, function(t) {
                    return e(t)
                }), g(this._element).on(F.TOUCHMOVE, function(t) {
                    var e;
                    (e = t).originalEvent.touches && 1 < e.originalEvent.touches.length ? n.touchDeltaX = 0 : n.touchDeltaX = e.originalEvent.touches[0].clientX - n.touchStartX
                }), g(this._element).on(F.TOUCHEND, function(t) {
                    return i(t)
                }))
            }
        }, A._keydown = function(t) {
            if (!/input|textarea/i.test(t.target.tagName)) switch (t.which) {
                case 37:
                    t.preventDefault(), this.prev();
                    break;
                case 39:
                    t.preventDefault(), this.next()
            }
        }, A._getItemIndex = function(t) {
            return this._items = t && t.parentNode ? [].slice.call(t.parentNode.querySelectorAll(".carousel-item")) : [], this._items.indexOf(t)
        }, A._getItemByDirection = function(t, e) {
            var n = t === R,
                i = t === x,
                o = this._getItemIndex(e),
                s = this._items.length - 1;
            if ((i && 0 === o || n && o === s) && !this._config.wrap) return e;
            var r = (o + (t === x ? -1 : 1)) % this._items.length;
            return -1 == r ? this._items[this._items.length - 1] : this._items[r]
        }, A._triggerSlideEvent = function(t, e) {
            var n = this._getItemIndex(t),
                i = this._getItemIndex(this._element.querySelector(W)),
                o = g.Event(F.SLIDE, {
                    relatedTarget: t,
                    direction: e,
                    from: i,
                    to: n
                });
            return g(this._element).trigger(o), o
        }, A._setActiveIndicatorElement = function(t) {
            if (this._indicatorsElement) {
                var e = [].slice.call(this._indicatorsElement.querySelectorAll(".active"));
                g(e).removeClass(U);
                var n = this._indicatorsElement.children[this._getItemIndex(t)];
                n && g(n).addClass(U)
            }
        }, A._slide = function(t, e) {
            var n, i, o, s = this,
                r = this._element.querySelector(W),
                a = this._getItemIndex(r),
                l = e || r && this._getItemByDirection(t, r),
                c = this._getItemIndex(l),
                h = Boolean(this._interval);
            if (o = t === R ? (n = "carousel-item-left", i = "carousel-item-next", "left") : (n = "carousel-item-right", i = "carousel-item-prev", "right"), l && g(l).hasClass(U)) this._isSliding = !1;
            else if (!this._triggerSlideEvent(l, o).isDefaultPrevented() && r && l) {
                this._isSliding = !0, h && this.pause(), this._setActiveIndicatorElement(l);
                var u = g.Event(F.SLID, {
                    relatedTarget: l,
                    direction: o,
                    from: a,
                    to: c
                });
                if (g(this._element).hasClass("slide")) {
                    g(l).addClass(i), _.reflow(l), g(r).addClass(n), g(l).addClass(n);
                    var f = parseInt(l.getAttribute("data-interval"), 10);
                    this._config.interval = f ? (this._config.defaultInterval = this._config.defaultInterval || this._config.interval, f) : this._config.defaultInterval || this._config.interval;
                    var d = _.getTransitionDurationFromElement(r);
                    g(r).one(_.TRANSITION_END, function() {
                        g(l).removeClass(n + " " + i).addClass(U), g(r).removeClass(U + " " + i + " " + n), s._isSliding = !1, setTimeout(function() {
                            return g(s._element).trigger(u)
                        }, 0)
                    }).emulateTransitionEnd(d)
                } else g(r).removeClass(U), g(l).addClass(U), this._isSliding = !1, g(this._element).trigger(u);
                h && this.cycle()
            }
        }, K._jQueryInterface = function(i) {
            return this.each(function() {
                var t = g(this).data(O),
                    e = r({}, j, g(this).data());
                "object" == typeof i && (e = r({}, e, i));
                var n = "string" == typeof i ? i : e.slide;
                if (t || (t = new K(this, e), g(this).data(O, t)), "number" == typeof i) t.to(i);
                else if ("string" == typeof n) {
                    if (void 0 === t[n]) throw new TypeError('No method named "' + n + '"');
                    t[n]()
                } else e.interval && e.ride && (t.pause(), t.cycle())
            })
        }, K._dataApiClickHandler = function(t) {
            var e = _.getSelectorFromElement(this);
            if (e) {
                var n = g(e)[0];
                if (n && g(n).hasClass("carousel")) {
                    var i = r({}, g(n).data(), g(this).data()),
                        o = this.getAttribute("data-slide-to");
                    o && (i.interval = !1), K._jQueryInterface.call(g(n), i), o && g(n).data(O).to(o), t.preventDefault()
                }
            }
        }, s(K, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return j
            }
        }]), K);

    function K(t, e) {
        this._items = null, this._interval = null, this._activeElement = null, this._isPaused = !1, this._isSliding = !1, this.touchTimeout = null, this.touchStartX = 0, this.touchDeltaX = 0, this._config = this._getConfig(e), this._element = t, this._indicatorsElement = this._element.querySelector(".carousel-indicators"), this._touchSupported = "ontouchstart" in document.documentElement || 0 < navigator.maxTouchPoints, this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent), this._addEventListeners()
    }
    g(document).on(F.CLICK_DATA_API, "[data-slide], [data-slide-to]", M._dataApiClickHandler), g(window).on(F.LOAD_DATA_API, function() {
        for (var t = [].slice.call(document.querySelectorAll('[data-ride="carousel"]')), e = 0, n = t.length; e < n; e++) {
            var i = g(t[e]);
            M._jQueryInterface.call(i, i.data())
        }
    }), g.fn[N] = M._jQueryInterface, g.fn[N].Constructor = M, g.fn[N].noConflict = function() {
        return g.fn[N] = L, M._jQueryInterface
    };
    var Q, B = "collapse",
        V = "bs.collapse",
        Y = "." + V,
        z = g.fn[B],
        X = {
            toggle: !0,
            parent: ""
        },
        $ = {
            toggle: "boolean",
            parent: "(string|element)"
        },
        G = {
            SHOW: "show" + Y,
            SHOWN: "shown" + Y,
            HIDE: "hide" + Y,
            HIDDEN: "hidden" + Y,
            CLICK_DATA_API: "click" + Y + ".data-api"
        },
        J = "show",
        Z = "collapse",
        tt = "collapsing",
        et = "collapsed",
        nt = '[data-toggle="collapse"]',
        it = ((Q = ot.prototype).toggle = function() {
            g(this._element).hasClass(J) ? this.hide() : this.show()
        }, Q.show = function() {
            var t, e, n = this;
            if (!(this._isTransitioning || g(this._element).hasClass(J) || (this._parent && 0 === (t = [].slice.call(this._parent.querySelectorAll(".show, .collapsing")).filter(function(t) {
                    return "string" == typeof n._config.parent ? t.getAttribute("data-parent") === n._config.parent : t.classList.contains(Z)
                })).length && (t = null), t && (e = g(t).not(this._selector).data(V)) && e._isTransitioning))) {
                var i = g.Event(G.SHOW);
                if (g(this._element).trigger(i), !i.isDefaultPrevented()) {
                    t && (ot._jQueryInterface.call(g(t).not(this._selector), "hide"), e || g(t).data(V, null));
                    var o = this._getDimension();
                    g(this._element).removeClass(Z).addClass(tt), this._element.style[o] = 0, this._triggerArray.length && g(this._triggerArray).removeClass(et).attr("aria-expanded", !0), this.setTransitioning(!0);
                    var s = "scroll" + (o[0].toUpperCase() + o.slice(1)),
                        r = _.getTransitionDurationFromElement(this._element);
                    g(this._element).one(_.TRANSITION_END, function() {
                        g(n._element).removeClass(tt).addClass(Z).addClass(J), n._element.style[o] = "", n.setTransitioning(!1), g(n._element).trigger(G.SHOWN)
                    }).emulateTransitionEnd(r), this._element.style[o] = this._element[s] + "px"
                }
            }
        }, Q.hide = function() {
            var t = this;
            if (!this._isTransitioning && g(this._element).hasClass(J)) {
                var e = g.Event(G.HIDE);
                if (g(this._element).trigger(e), !e.isDefaultPrevented()) {
                    var n = this._getDimension();
                    this._element.style[n] = this._element.getBoundingClientRect()[n] + "px", _.reflow(this._element), g(this._element).addClass(tt).removeClass(Z).removeClass(J);
                    var i = this._triggerArray.length;
                    if (0 < i)
                        for (var o = 0; o < i; o++) {
                            var s = this._triggerArray[o],
                                r = _.getSelectorFromElement(s);
                            null !== r && (g([].slice.call(document.querySelectorAll(r))).hasClass(J) || g(s).addClass(et).attr("aria-expanded", !1))
                        }
                    this.setTransitioning(!0), this._element.style[n] = "";
                    var a = _.getTransitionDurationFromElement(this._element);
                    g(this._element).one(_.TRANSITION_END, function() {
                        t.setTransitioning(!1), g(t._element).removeClass(tt).addClass(Z).trigger(G.HIDDEN)
                    }).emulateTransitionEnd(a)
                }
            }
        }, Q.setTransitioning = function(t) {
            this._isTransitioning = t
        }, Q.dispose = function() {
            g.removeData(this._element, V), this._config = null, this._parent = null, this._element = null, this._triggerArray = null, this._isTransitioning = null
        }, Q._getConfig = function(t) {
            return (t = r({}, X, t)).toggle = Boolean(t.toggle), _.typeCheckConfig(B, t, $), t
        }, Q._getDimension = function() {
            return g(this._element).hasClass("width") ? "width" : "height"
        }, Q._getParent = function() {
            var t, n = this;
            _.isElement(this._config.parent) ? (t = this._config.parent, void 0 !== this._config.parent.jquery && (t = this._config.parent[0])) : t = document.querySelector(this._config.parent);
            var e = '[data-toggle="collapse"][data-parent="' + this._config.parent + '"]',
                i = [].slice.call(t.querySelectorAll(e));
            return g(i).each(function(t, e) {
                n._addAriaAndCollapsedClass(ot._getTargetFromElement(e), [e])
            }), t
        }, Q._addAriaAndCollapsedClass = function(t, e) {
            var n = g(t).hasClass(J);
            e.length && g(e).toggleClass(et, !n).attr("aria-expanded", n)
        }, ot._getTargetFromElement = function(t) {
            var e = _.getSelectorFromElement(t);
            return e ? document.querySelector(e) : null
        }, ot._jQueryInterface = function(i) {
            return this.each(function() {
                var t = g(this),
                    e = t.data(V),
                    n = r({}, X, t.data(), "object" == typeof i && i ? i : {});
                if (!e && n.toggle && /show|hide/.test(i) && (n.toggle = !1), e || (e = new ot(this, n), t.data(V, e)), "string" == typeof i) {
                    if (void 0 === e[i]) throw new TypeError('No method named "' + i + '"');
                    e[i]()
                }
            })
        }, s(ot, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return X
            }
        }]), ot);

    function ot(e, t) {
        this._isTransitioning = !1, this._element = e, this._config = this._getConfig(t), this._triggerArray = [].slice.call(document.querySelectorAll('[data-toggle="collapse"][href="#' + e.id + '"],[data-toggle="collapse"][data-target="#' + e.id + '"]'));
        for (var n = [].slice.call(document.querySelectorAll(nt)), i = 0, o = n.length; i < o; i++) {
            var s = n[i],
                r = _.getSelectorFromElement(s),
                a = [].slice.call(document.querySelectorAll(r)).filter(function(t) {
                    return t === e
                });
            null !== r && 0 < a.length && (this._selector = r, this._triggerArray.push(s))
        }
        this._parent = this._config.parent ? this._getParent() : null, this._config.parent || this._addAriaAndCollapsedClass(this._element, this._triggerArray), this._config.toggle && this.toggle()
    }
    g(document).on(G.CLICK_DATA_API, nt, function(t) {
        "A" === t.currentTarget.tagName && t.preventDefault();
        var n = g(this),
            e = _.getSelectorFromElement(this),
            i = [].slice.call(document.querySelectorAll(e));
        g(i).each(function() {
            var t = g(this),
                e = t.data(V) ? "toggle" : n.data();
            it._jQueryInterface.call(t, e)
        })
    }), g.fn[B] = it._jQueryInterface, g.fn[B].Constructor = it, g.fn[B].noConflict = function() {
        return g.fn[B] = z, it._jQueryInterface
    };
    var st, rt = "dropdown",
        at = "bs.dropdown",
        lt = "." + at,
        ct = ".data-api",
        ht = g.fn[rt],
        ut = new RegExp("38|40|27"),
        ft = {
            HIDE: "hide" + lt,
            HIDDEN: "hidden" + lt,
            SHOW: "show" + lt,
            SHOWN: "shown" + lt,
            CLICK: "click" + lt,
            CLICK_DATA_API: "click" + lt + ct,
            KEYDOWN_DATA_API: "keydown" + lt + ct,
            KEYUP_DATA_API: "keyup" + lt + ct
        },
        dt = "disabled",
        gt = "show",
        _t = "dropdown-menu-right",
        mt = '[data-toggle="dropdown"]',
        pt = ".dropdown-menu",
        vt = {
            offset: 0,
            flip: !0,
            boundary: "scrollParent",
            reference: "toggle",
            display: "dynamic"
        },
        Et = {
            offset: "(number|string|function)",
            flip: "boolean",
            boundary: "(string|element)",
            reference: "(string|element)",
            display: "string"
        },
        yt = ((st = Ct.prototype).toggle = function() {
            if (!this._element.disabled && !g(this._element).hasClass(dt)) {
                var t = Ct._getParentFromElement(this._element),
                    e = g(this._menu).hasClass(gt);
                if (Ct._clearMenus(), !e) {
                    var n = {
                            relatedTarget: this._element
                        },
                        i = g.Event(ft.SHOW, n);
                    if (g(t).trigger(i), !i.isDefaultPrevented()) {
                        if (!this._inNavbar) {
                            if (void 0 === u) throw new TypeError("Bootstrap's dropdowns require Popper.js (https://popper.js.org/)");
                            var o = this._element;
                            "parent" === this._config.reference ? o = t : _.isElement(this._config.reference) && (o = this._config.reference, void 0 !== this._config.reference.jquery && (o = this._config.reference[0])), "scrollParent" !== this._config.boundary && g(t).addClass("position-static"), this._popper = new u(o, this._menu, this._getPopperConfig())
                        }
                        "ontouchstart" in document.documentElement && 0 === g(t).closest(".navbar-nav").length && g(document.body).children().on("mouseover", null, g.noop), this._element.focus(), this._element.setAttribute("aria-expanded", !0), g(this._menu).toggleClass(gt), g(t).toggleClass(gt).trigger(g.Event(ft.SHOWN, n))
                    }
                }
            }
        }, st.show = function() {
            if (!(this._element.disabled || g(this._element).hasClass(dt) || g(this._menu).hasClass(gt))) {
                var t = {
                        relatedTarget: this._element
                    },
                    e = g.Event(ft.SHOW, t),
                    n = Ct._getParentFromElement(this._element);
                g(n).trigger(e), e.isDefaultPrevented() || (g(this._menu).toggleClass(gt), g(n).toggleClass(gt).trigger(g.Event(ft.SHOWN, t)))
            }
        }, st.hide = function() {
            if (!this._element.disabled && !g(this._element).hasClass(dt) && g(this._menu).hasClass(gt)) {
                var t = {
                        relatedTarget: this._element
                    },
                    e = g.Event(ft.HIDE, t),
                    n = Ct._getParentFromElement(this._element);
                g(n).trigger(e), e.isDefaultPrevented() || (g(this._menu).toggleClass(gt), g(n).toggleClass(gt).trigger(g.Event(ft.HIDDEN, t)))
            }
        }, st.dispose = function() {
            g.removeData(this._element, at), g(this._element).off(lt), this._element = null, (this._menu = null) !== this._popper && (this._popper.destroy(), this._popper = null)
        }, st.update = function() {
            this._inNavbar = this._detectNavbar(), null !== this._popper && this._popper.scheduleUpdate()
        }, st._addEventListeners = function() {
            var e = this;
            g(this._element).on(ft.CLICK, function(t) {
                t.preventDefault(), t.stopPropagation(), e.toggle()
            })
        }, st._getConfig = function(t) {
            return t = r({}, this.constructor.Default, g(this._element).data(), t), _.typeCheckConfig(rt, t, this.constructor.DefaultType), t
        }, st._getMenuElement = function() {
            if (!this._menu) {
                var t = Ct._getParentFromElement(this._element);
                t && (this._menu = t.querySelector(pt))
            }
            return this._menu
        }, st._getPlacement = function() {
            var t = g(this._element.parentNode),
                e = "bottom-start";
            return t.hasClass("dropup") ? (e = "top-start", g(this._menu).hasClass(_t) && (e = "top-end")) : t.hasClass("dropright") ? e = "right-start" : t.hasClass("dropleft") ? e = "left-start" : g(this._menu).hasClass(_t) && (e = "bottom-end"), e
        }, st._detectNavbar = function() {
            return 0 < g(this._element).closest(".navbar").length
        }, st._getOffset = function() {
            var e = this,
                t = {};
            return "function" == typeof this._config.offset ? t.fn = function(t) {
                return t.offsets = r({}, t.offsets, e._config.offset(t.offsets, e._element) || {}), t
            } : t.offset = this._config.offset, t
        }, st._getPopperConfig = function() {
            var t = {
                placement: this._getPlacement(),
                modifiers: {
                    offset: this._getOffset(),
                    flip: {
                        enabled: this._config.flip
                    },
                    preventOverflow: {
                        boundariesElement: this._config.boundary
                    }
                }
            };
            return "static" === this._config.display && (t.modifiers.applyStyle = {
                enabled: !1
            }), t
        }, Ct._jQueryInterface = function(e) {
            return this.each(function() {
                var t = g(this).data(at);
                if (t || (t = new Ct(this, "object" == typeof e ? e : null), g(this).data(at, t)), "string" == typeof e) {
                    if (void 0 === t[e]) throw new TypeError('No method named "' + e + '"');
                    t[e]()
                }
            })
        }, Ct._clearMenus = function(t) {
            if (!t || 3 !== t.which && ("keyup" !== t.type || 9 === t.which))
                for (var e = [].slice.call(document.querySelectorAll(mt)), n = 0, i = e.length; n < i; n++) {
                    var o = Ct._getParentFromElement(e[n]),
                        s = g(e[n]).data(at),
                        r = {
                            relatedTarget: e[n]
                        };
                    if (t && "click" === t.type && (r.clickEvent = t), s) {
                        var a = s._menu;
                        if (g(o).hasClass(gt) && !(t && ("click" === t.type && /input|textarea/i.test(t.target.tagName) || "keyup" === t.type && 9 === t.which) && g.contains(o, t.target))) {
                            var l = g.Event(ft.HIDE, r);
                            g(o).trigger(l), l.isDefaultPrevented() || ("ontouchstart" in document.documentElement && g(document.body).children().off("mouseover", null, g.noop), e[n].setAttribute("aria-expanded", "false"), g(a).removeClass(gt), g(o).removeClass(gt).trigger(g.Event(ft.HIDDEN, r)))
                        }
                    }
                }
        }, Ct._getParentFromElement = function(t) {
            var e, n = _.getSelectorFromElement(t);
            return n && (e = document.querySelector(n)), e || t.parentNode
        }, Ct._dataApiKeydownHandler = function(t) {
            if ((/input|textarea/i.test(t.target.tagName) ? !(32 === t.which || 27 !== t.which && (40 !== t.which && 38 !== t.which || g(t.target).closest(pt).length)) : ut.test(t.which)) && (t.preventDefault(), t.stopPropagation(), !this.disabled && !g(this).hasClass(dt))) {
                var e = Ct._getParentFromElement(this),
                    n = g(e).hasClass(gt);
                if (n && (!n || 27 !== t.which && 32 !== t.which)) {
                    var i = [].slice.call(e.querySelectorAll(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)"));
                    if (0 !== i.length) {
                        var o = i.indexOf(t.target);
                        38 === t.which && 0 < o && o--, 40 === t.which && o < i.length - 1 && o++, o < 0 && (o = 0), i[o].focus()
                    }
                } else {
                    if (27 === t.which) {
                        var s = e.querySelector(mt);
                        g(s).trigger("focus")
                    }
                    g(this).trigger("click")
                }
            }
        }, s(Ct, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return vt
            }
        }, {
            key: "DefaultType",
            get: function() {
                return Et
            }
        }]), Ct);

    function Ct(t, e) {
        this._element = t, this._popper = null, this._config = this._getConfig(e), this._menu = this._getMenuElement(), this._inNavbar = this._detectNavbar(), this._addEventListeners()
    }
    g(document).on(ft.KEYDOWN_DATA_API, mt, yt._dataApiKeydownHandler).on(ft.KEYDOWN_DATA_API, pt, yt._dataApiKeydownHandler).on(ft.CLICK_DATA_API + " " + ft.KEYUP_DATA_API, yt._clearMenus).on(ft.CLICK_DATA_API, mt, function(t) {
        t.preventDefault(), t.stopPropagation(), yt._jQueryInterface.call(g(this), "toggle")
    }).on(ft.CLICK_DATA_API, ".dropdown form", function(t) {
        t.stopPropagation()
    }), g.fn[rt] = yt._jQueryInterface, g.fn[rt].Constructor = yt, g.fn[rt].noConflict = function() {
        return g.fn[rt] = ht, yt._jQueryInterface
    };
    var Tt, St = "modal",
        bt = "bs.modal",
        It = "." + bt,
        Dt = g.fn[St],
        wt = {
            backdrop: !0,
            keyboard: !0,
            focus: !0,
            show: !0
        },
        At = {
            backdrop: "(boolean|string)",
            keyboard: "boolean",
            focus: "boolean",
            show: "boolean"
        },
        Nt = {
            HIDE: "hide" + It,
            HIDDEN: "hidden" + It,
            SHOW: "show" + It,
            SHOWN: "shown" + It,
            FOCUSIN: "focusin" + It,
            RESIZE: "resize" + It,
            CLICK_DISMISS: "click.dismiss" + It,
            KEYDOWN_DISMISS: "keydown.dismiss" + It,
            MOUSEUP_DISMISS: "mouseup.dismiss" + It,
            MOUSEDOWN_DISMISS: "mousedown.dismiss" + It,
            CLICK_DATA_API: "click" + It + ".data-api"
        },
        Ot = "modal-open",
        kt = "fade",
        Pt = "show",
        Lt = ".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",
        jt = ".sticky-top",
        Ht = ((Tt = Rt.prototype).toggle = function(t) {
            return this._isShown ? this.hide() : this.show(t)
        }, Tt.show = function(t) {
            var e = this;
            if (!this._isShown && !this._isTransitioning) {
                g(this._element).hasClass(kt) && (this._isTransitioning = !0);
                var n = g.Event(Nt.SHOW, {
                    relatedTarget: t
                });
                g(this._element).trigger(n), this._isShown || n.isDefaultPrevented() || (this._isShown = !0, this._checkScrollbar(), this._setScrollbar(), this._adjustDialog(), this._setEscapeEvent(), this._setResizeEvent(), g(this._element).on(Nt.CLICK_DISMISS, '[data-dismiss="modal"]', function(t) {
                    return e.hide(t)
                }), g(this._dialog).on(Nt.MOUSEDOWN_DISMISS, function() {
                    g(e._element).one(Nt.MOUSEUP_DISMISS, function(t) {
                        g(t.target).is(e._element) && (e._ignoreBackdropClick = !0)
                    })
                }), this._showBackdrop(function() {
                    return e._showElement(t)
                }))
            }
        }, Tt.hide = function(t) {
            var e = this;
            if (t && t.preventDefault(), this._isShown && !this._isTransitioning) {
                var n = g.Event(Nt.HIDE);
                if (g(this._element).trigger(n), this._isShown && !n.isDefaultPrevented()) {
                    this._isShown = !1;
                    var i = g(this._element).hasClass(kt);
                    if (i && (this._isTransitioning = !0), this._setEscapeEvent(), this._setResizeEvent(), g(document).off(Nt.FOCUSIN), g(this._element).removeClass(Pt), g(this._element).off(Nt.CLICK_DISMISS), g(this._dialog).off(Nt.MOUSEDOWN_DISMISS), i) {
                        var o = _.getTransitionDurationFromElement(this._element);
                        g(this._element).one(_.TRANSITION_END, function(t) {
                            return e._hideModal(t)
                        }).emulateTransitionEnd(o)
                    } else this._hideModal()
                }
            }
        }, Tt.dispose = function() {
            [window, this._element, this._dialog].forEach(function(t) {
                return g(t).off(It)
            }), g(document).off(Nt.FOCUSIN), g.removeData(this._element, bt), this._config = null, this._element = null, this._dialog = null, this._backdrop = null, this._isShown = null, this._isBodyOverflowing = null, this._ignoreBackdropClick = null, this._isTransitioning = null, this._scrollbarWidth = null
        }, Tt.handleUpdate = function() {
            this._adjustDialog()
        }, Tt._getConfig = function(t) {
            return t = r({}, wt, t), _.typeCheckConfig(St, t, At), t
        }, Tt._showElement = function(t) {
            var e = this,
                n = g(this._element).hasClass(kt);

            function i() {
                e._config.focus && e._element.focus(), e._isTransitioning = !1, g(e._element).trigger(o)
            }
            this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE || document.body.appendChild(this._element), this._element.style.display = "block", this._element.removeAttribute("aria-hidden"), this._element.setAttribute("aria-modal", !0), g(this._dialog).hasClass("modal-dialog-scrollable") ? this._dialog.querySelector(".modal-body").scrollTop = 0 : this._element.scrollTop = 0, n && _.reflow(this._element), g(this._element).addClass(Pt), this._config.focus && this._enforceFocus();
            var o = g.Event(Nt.SHOWN, {
                relatedTarget: t
            });
            if (n) {
                var s = _.getTransitionDurationFromElement(this._dialog);
                g(this._dialog).one(_.TRANSITION_END, i).emulateTransitionEnd(s)
            } else i()
        }, Tt._enforceFocus = function() {
            var e = this;
            g(document).off(Nt.FOCUSIN).on(Nt.FOCUSIN, function(t) {
                document !== t.target && e._element !== t.target && 0 === g(e._element).has(t.target).length && e._element.focus()
            })
        }, Tt._setEscapeEvent = function() {
            var e = this;
            this._isShown && this._config.keyboard ? g(this._element).on(Nt.KEYDOWN_DISMISS, function(t) {
                27 === t.which && (t.preventDefault(), e.hide())
            }) : this._isShown || g(this._element).off(Nt.KEYDOWN_DISMISS)
        }, Tt._setResizeEvent = function() {
            var e = this;
            this._isShown ? g(window).on(Nt.RESIZE, function(t) {
                return e.handleUpdate(t)
            }) : g(window).off(Nt.RESIZE)
        }, Tt._hideModal = function() {
            var t = this;
            this._element.style.display = "none", this._element.setAttribute("aria-hidden", !0), this._element.removeAttribute("aria-modal"), this._isTransitioning = !1, this._showBackdrop(function() {
                g(document.body).removeClass(Ot), t._resetAdjustments(), t._resetScrollbar(), g(t._element).trigger(Nt.HIDDEN)
            })
        }, Tt._removeBackdrop = function() {
            this._backdrop && (g(this._backdrop).remove(), this._backdrop = null)
        }, Tt._showBackdrop = function(t) {
            var e = this,
                n = g(this._element).hasClass(kt) ? kt : "";
            if (this._isShown && this._config.backdrop) {
                if (this._backdrop = document.createElement("div"), this._backdrop.className = "modal-backdrop", n && this._backdrop.classList.add(n), g(this._backdrop).appendTo(document.body), g(this._element).on(Nt.CLICK_DISMISS, function(t) {
                        e._ignoreBackdropClick ? e._ignoreBackdropClick = !1 : t.target === t.currentTarget && ("static" === e._config.backdrop ? e._element.focus() : e.hide())
                    }), n && _.reflow(this._backdrop), g(this._backdrop).addClass(Pt), !t) return;
                if (!n) return void t();
                var i = _.getTransitionDurationFromElement(this._backdrop);
                g(this._backdrop).one(_.TRANSITION_END, t).emulateTransitionEnd(i)
            } else if (!this._isShown && this._backdrop) {
                g(this._backdrop).removeClass(Pt);
                var o = function() {
                    e._removeBackdrop(), t && t()
                };
                if (g(this._element).hasClass(kt)) {
                    var s = _.getTransitionDurationFromElement(this._backdrop);
                    g(this._backdrop).one(_.TRANSITION_END, o).emulateTransitionEnd(s)
                } else o()
            } else t && t()
        }, Tt._adjustDialog = function() {
            var t = this._element.scrollHeight > document.documentElement.clientHeight;
            !this._isBodyOverflowing && t && (this._element.style.paddingLeft = this._scrollbarWidth + "px"), this._isBodyOverflowing && !t && (this._element.style.paddingRight = this._scrollbarWidth + "px")
        }, Tt._resetAdjustments = function() {
            this._element.style.paddingLeft = "", this._element.style.paddingRight = ""
        }, Tt._checkScrollbar = function() {
            var t = document.body.getBoundingClientRect();
            this._isBodyOverflowing = t.left + t.right < window.innerWidth, this._scrollbarWidth = this._getScrollbarWidth()
        }, Tt._setScrollbar = function() {
            var o = this;
            if (this._isBodyOverflowing) {
                var t = [].slice.call(document.querySelectorAll(Lt)),
                    e = [].slice.call(document.querySelectorAll(jt));
                g(t).each(function(t, e) {
                    var n = e.style.paddingRight,
                        i = g(e).css("padding-right");
                    g(e).data("padding-right", n).css("padding-right", parseFloat(i) + o._scrollbarWidth + "px")
                }), g(e).each(function(t, e) {
                    var n = e.style.marginRight,
                        i = g(e).css("margin-right");
                    g(e).data("margin-right", n).css("margin-right", parseFloat(i) - o._scrollbarWidth + "px")
                });
                var n = document.body.style.paddingRight,
                    i = g(document.body).css("padding-right");
                g(document.body).data("padding-right", n).css("padding-right", parseFloat(i) + this._scrollbarWidth + "px")
            }
            g(document.body).addClass(Ot)
        }, Tt._resetScrollbar = function() {
            var t = [].slice.call(document.querySelectorAll(Lt));
            g(t).each(function(t, e) {
                var n = g(e).data("padding-right");
                g(e).removeData("padding-right"), e.style.paddingRight = n || ""
            });
            var e = [].slice.call(document.querySelectorAll(jt));
            g(e).each(function(t, e) {
                var n = g(e).data("margin-right");
                void 0 !== n && g(e).css("margin-right", n).removeData("margin-right")
            });
            var n = g(document.body).data("padding-right");
            g(document.body).removeData("padding-right"), document.body.style.paddingRight = n || ""
        }, Tt._getScrollbarWidth = function() {
            var t = document.createElement("div");
            t.className = "modal-scrollbar-measure", document.body.appendChild(t);
            var e = t.getBoundingClientRect().width - t.clientWidth;
            return document.body.removeChild(t), e
        }, Rt._jQueryInterface = function(n, i) {
            return this.each(function() {
                var t = g(this).data(bt),
                    e = r({}, wt, g(this).data(), "object" == typeof n && n ? n : {});
                if (t || (t = new Rt(this, e), g(this).data(bt, t)), "string" == typeof n) {
                    if (void 0 === t[n]) throw new TypeError('No method named "' + n + '"');
                    t[n](i)
                } else e.show && t.show(i)
            })
        }, s(Rt, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return wt
            }
        }]), Rt);

    function Rt(t, e) {
        this._config = this._getConfig(e), this._element = t, this._dialog = t.querySelector(".modal-dialog"), this._backdrop = null, this._isShown = !1, this._isBodyOverflowing = !1, this._ignoreBackdropClick = !1, this._isTransitioning = !1, this._scrollbarWidth = 0
    }
    g(document).on(Nt.CLICK_DATA_API, '[data-toggle="modal"]', function(t) {
        var e, n = this,
            i = _.getSelectorFromElement(this);
        i && (e = document.querySelector(i));
        var o = g(e).data(bt) ? "toggle" : r({}, g(e).data(), g(this).data());
        "A" !== this.tagName && "AREA" !== this.tagName || t.preventDefault();
        var s = g(e).one(Nt.SHOW, function(t) {
            t.isDefaultPrevented() || s.one(Nt.HIDDEN, function() {
                g(n).is(":visible") && n.focus()
            })
        });
        Ht._jQueryInterface.call(g(e), o, this)
    }), g.fn[St] = Ht._jQueryInterface, g.fn[St].Constructor = Ht, g.fn[St].noConflict = function() {
        return g.fn[St] = Dt, Ht._jQueryInterface
    };
    var xt = ["background", "cite", "href", "itemtype", "longdesc", "poster", "src", "xlink:href"],
        Ft = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi,
        Ut = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i;

    function Wt(t, r, e) {
        if (0 === t.length) return t;
        if (e && "function" == typeof e) return e(t);
        for (var n = (new window.DOMParser).parseFromString(t, "text/html"), a = Object.keys(r), l = [].slice.call(n.body.querySelectorAll("*")), i = function(t, e) {
                var n = l[t],
                    i = n.nodeName.toLowerCase();
                if (-1 === a.indexOf(n.nodeName.toLowerCase())) return n.parentNode.removeChild(n), "continue";
                var o = [].slice.call(n.attributes),
                    s = [].concat(r["*"] || [], r[i] || []);
                o.forEach(function(t) {
                    ! function(t, e) {
                        var n = t.nodeName.toLowerCase();
                        if (-1 !== e.indexOf(n)) return -1 === xt.indexOf(n) || Boolean(t.nodeValue.match(Ft) || t.nodeValue.match(Ut));
                        for (var i = e.filter(function(t) {
                                return t instanceof RegExp
                            }), o = 0, s = i.length; o < s; o++)
                            if (n.match(i[o])) return 1
                    }(t, s) && n.removeAttribute(t.nodeName)
                })
            }, o = 0, s = l.length; o < s; o++) i(o);
        return n.body.innerHTML
    }
    var qt, Mt = "tooltip",
        Kt = "bs.tooltip",
        Qt = "." + Kt,
        Bt = g.fn[Mt],
        Vt = "bs-tooltip",
        Yt = new RegExp("(^|\\s)" + Vt + "\\S+", "g"),
        zt = ["sanitize", "whiteList", "sanitizeFn"],
        Xt = {
            animation: "boolean",
            template: "string",
            title: "(string|element|function)",
            trigger: "string",
            delay: "(number|object)",
            html: "boolean",
            selector: "(string|boolean)",
            placement: "(string|function)",
            offset: "(number|string|function)",
            container: "(string|element|boolean)",
            fallbackPlacement: "(string|array)",
            boundary: "(string|element)",
            sanitize: "boolean",
            sanitizeFn: "(null|function)",
            whiteList: "object"
        },
        $t = {
            AUTO: "auto",
            TOP: "top",
            RIGHT: "right",
            BOTTOM: "bottom",
            LEFT: "left"
        },
        Gt = {
            animation: !0,
            template: '<div class="tooltip" role="tooltip"><div class="arrow"></div><div class="tooltip-inner"></div></div>',
            trigger: "hover focus",
            title: "",
            delay: 0,
            html: !1,
            selector: !1,
            placement: "top",
            offset: 0,
            container: !1,
            fallbackPlacement: "flip",
            boundary: "scrollParent",
            sanitize: !0,
            sanitizeFn: null,
            whiteList: {
                "*": ["class", "dir", "id", "lang", "role", /^aria-[\w-]*$/i],
                a: ["target", "href", "title", "rel"],
                area: [],
                b: [],
                br: [],
                col: [],
                code: [],
                div: [],
                em: [],
                hr: [],
                h1: [],
                h2: [],
                h3: [],
                h4: [],
                h5: [],
                h6: [],
                i: [],
                img: ["src", "alt", "title", "width", "height"],
                li: [],
                ol: [],
                p: [],
                pre: [],
                s: [],
                small: [],
                span: [],
                sub: [],
                sup: [],
                strong: [],
                u: [],
                ul: []
            }
        },
        Jt = "show",
        Zt = {
            HIDE: "hide" + Qt,
            HIDDEN: "hidden" + Qt,
            SHOW: "show" + Qt,
            SHOWN: "shown" + Qt,
            INSERTED: "inserted" + Qt,
            CLICK: "click" + Qt,
            FOCUSIN: "focusin" + Qt,
            FOCUSOUT: "focusout" + Qt,
            MOUSEENTER: "mouseenter" + Qt,
            MOUSELEAVE: "mouseleave" + Qt
        },
        te = "fade",
        ee = "show",
        ne = "hover",
        ie = "focus",
        oe = ((qt = se.prototype).enable = function() {
            this._isEnabled = !0
        }, qt.disable = function() {
            this._isEnabled = !1
        }, qt.toggleEnabled = function() {
            this._isEnabled = !this._isEnabled
        }, qt.toggle = function(t) {
            if (this._isEnabled)
                if (t) {
                    var e = this.constructor.DATA_KEY,
                        n = g(t.currentTarget).data(e);
                    n || (n = new this.constructor(t.currentTarget, this._getDelegateConfig()), g(t.currentTarget).data(e, n)), n._activeTrigger.click = !n._activeTrigger.click, n._isWithActiveTrigger() ? n._enter(null, n) : n._leave(null, n)
                } else {
                    if (g(this.getTipElement()).hasClass(ee)) return void this._leave(null, this);
                    this._enter(null, this)
                }
        }, qt.dispose = function() {
            clearTimeout(this._timeout), g.removeData(this.element, this.constructor.DATA_KEY), g(this.element).off(this.constructor.EVENT_KEY), g(this.element).closest(".modal").off("hide.bs.modal"), this.tip && g(this.tip).remove(), this._isEnabled = null, this._timeout = null, this._hoverState = null, (this._activeTrigger = null) !== this._popper && this._popper.destroy(), this._popper = null, this.element = null, this.config = null, this.tip = null
        }, qt.show = function() {
            var e = this;
            if ("none" === g(this.element).css("display")) throw new Error("Please use show on visible elements");
            var t = g.Event(this.constructor.Event.SHOW);
            if (this.isWithContent() && this._isEnabled) {
                g(this.element).trigger(t);
                var n = _.findShadowRoot(this.element),
                    i = g.contains(null !== n ? n : this.element.ownerDocument.documentElement, this.element);
                if (t.isDefaultPrevented() || !i) return;
                var o = this.getTipElement(),
                    s = _.getUID(this.constructor.NAME);
                o.setAttribute("id", s), this.element.setAttribute("aria-describedby", s), this.setContent(), this.config.animation && g(o).addClass(te);
                var r = "function" == typeof this.config.placement ? this.config.placement.call(this, o, this.element) : this.config.placement,
                    a = this._getAttachment(r);
                this.addAttachmentClass(a);
                var l = this._getContainer();
                g(o).data(this.constructor.DATA_KEY, this), g.contains(this.element.ownerDocument.documentElement, this.tip) || g(o).appendTo(l), g(this.element).trigger(this.constructor.Event.INSERTED), this._popper = new u(this.element, o, {
                    placement: a,
                    modifiers: {
                        offset: this._getOffset(),
                        flip: {
                            behavior: this.config.fallbackPlacement
                        },
                        arrow: {
                            element: ".arrow"
                        },
                        preventOverflow: {
                            boundariesElement: this.config.boundary
                        }
                    },
                    onCreate: function(t) {
                        t.originalPlacement !== t.placement && e._handlePopperPlacementChange(t)
                    },
                    onUpdate: function(t) {
                        return e._handlePopperPlacementChange(t)
                    }
                }), g(o).addClass(ee), "ontouchstart" in document.documentElement && g(document.body).children().on("mouseover", null, g.noop);
                var c = function() {
                    e.config.animation && e._fixTransition();
                    var t = e._hoverState;
                    e._hoverState = null, g(e.element).trigger(e.constructor.Event.SHOWN), "out" === t && e._leave(null, e)
                };
                if (g(this.tip).hasClass(te)) {
                    var h = _.getTransitionDurationFromElement(this.tip);
                    g(this.tip).one(_.TRANSITION_END, c).emulateTransitionEnd(h)
                } else c()
            }
        }, qt.hide = function(t) {
            function e() {
                n._hoverState !== Jt && i.parentNode && i.parentNode.removeChild(i), n._cleanTipClass(), n.element.removeAttribute("aria-describedby"), g(n.element).trigger(n.constructor.Event.HIDDEN), null !== n._popper && n._popper.destroy(), t && t()
            }
            var n = this,
                i = this.getTipElement(),
                o = g.Event(this.constructor.Event.HIDE);
            if (g(this.element).trigger(o), !o.isDefaultPrevented()) {
                if (g(i).removeClass(ee), "ontouchstart" in document.documentElement && g(document.body).children().off("mouseover", null, g.noop), this._activeTrigger.click = !1, this._activeTrigger[ie] = !1, this._activeTrigger[ne] = !1, g(this.tip).hasClass(te)) {
                    var s = _.getTransitionDurationFromElement(i);
                    g(i).one(_.TRANSITION_END, e).emulateTransitionEnd(s)
                } else e();
                this._hoverState = ""
            }
        }, qt.update = function() {
            null !== this._popper && this._popper.scheduleUpdate()
        }, qt.isWithContent = function() {
            return Boolean(this.getTitle())
        }, qt.addAttachmentClass = function(t) {
            g(this.getTipElement()).addClass(Vt + "-" + t)
        }, qt.getTipElement = function() {
            return this.tip = this.tip || g(this.config.template)[0], this.tip
        }, qt.setContent = function() {
            var t = this.getTipElement();
            this.setElementContent(g(t.querySelectorAll(".tooltip-inner")), this.getTitle()), g(t).removeClass(te + " " + ee)
        }, qt.setElementContent = function(t, e) {
            "object" != typeof e || !e.nodeType && !e.jquery ? this.config.html ? (this.config.sanitize && (e = Wt(e, this.config.whiteList, this.config.sanitizeFn)), t.html(e)) : t.text(e) : this.config.html ? g(e).parent().is(t) || t.empty().append(e) : t.text(g(e).text())
        }, qt.getTitle = function() {
            var t = this.element.getAttribute("data-original-title");
            return t = t || ("function" == typeof this.config.title ? this.config.title.call(this.element) : this.config.title)
        }, qt._getOffset = function() {
            var e = this,
                t = {};
            return "function" == typeof this.config.offset ? t.fn = function(t) {
                return t.offsets = r({}, t.offsets, e.config.offset(t.offsets, e.element) || {}), t
            } : t.offset = this.config.offset, t
        }, qt._getContainer = function() {
            return !1 === this.config.container ? document.body : _.isElement(this.config.container) ? g(this.config.container) : g(document).find(this.config.container)
        }, qt._getAttachment = function(t) {
            return $t[t.toUpperCase()]
        }, qt._setListeners = function() {
            var i = this;
            this.config.trigger.split(" ").forEach(function(t) {
                if ("click" === t) g(i.element).on(i.constructor.Event.CLICK, i.config.selector, function(t) {
                    return i.toggle(t)
                });
                else if ("manual" !== t) {
                    var e = t === ne ? i.constructor.Event.MOUSEENTER : i.constructor.Event.FOCUSIN,
                        n = t === ne ? i.constructor.Event.MOUSELEAVE : i.constructor.Event.FOCUSOUT;
                    g(i.element).on(e, i.config.selector, function(t) {
                        return i._enter(t)
                    }).on(n, i.config.selector, function(t) {
                        return i._leave(t)
                    })
                }
            }), g(this.element).closest(".modal").on("hide.bs.modal", function() {
                i.element && i.hide()
            }), this.config.selector ? this.config = r({}, this.config, {
                trigger: "manual",
                selector: ""
            }) : this._fixTitle()
        }, qt._fixTitle = function() {
            var t = typeof this.element.getAttribute("data-original-title");
            !this.element.getAttribute("title") && "string" == t || (this.element.setAttribute("data-original-title", this.element.getAttribute("title") || ""), this.element.setAttribute("title", ""))
        }, qt._enter = function(t, e) {
            var n = this.constructor.DATA_KEY;
            (e = e || g(t.currentTarget).data(n)) || (e = new this.constructor(t.currentTarget, this._getDelegateConfig()), g(t.currentTarget).data(n, e)), t && (e._activeTrigger["focusin" === t.type ? ie : ne] = !0), g(e.getTipElement()).hasClass(ee) || e._hoverState === Jt ? e._hoverState = Jt : (clearTimeout(e._timeout), e._hoverState = Jt, e.config.delay && e.config.delay.show ? e._timeout = setTimeout(function() {
                e._hoverState === Jt && e.show()
            }, e.config.delay.show) : e.show())
        }, qt._leave = function(t, e) {
            var n = this.constructor.DATA_KEY;
            (e = e || g(t.currentTarget).data(n)) || (e = new this.constructor(t.currentTarget, this._getDelegateConfig()), g(t.currentTarget).data(n, e)), t && (e._activeTrigger["focusout" === t.type ? ie : ne] = !1), e._isWithActiveTrigger() || (clearTimeout(e._timeout), e._hoverState = "out", e.config.delay && e.config.delay.hide ? e._timeout = setTimeout(function() {
                "out" === e._hoverState && e.hide()
            }, e.config.delay.hide) : e.hide())
        }, qt._isWithActiveTrigger = function() {
            for (var t in this._activeTrigger)
                if (this._activeTrigger[t]) return !0;
            return !1
        }, qt._getConfig = function(t) {
            var e = g(this.element).data();
            return Object.keys(e).forEach(function(t) {
                -1 !== zt.indexOf(t) && delete e[t]
            }), "number" == typeof(t = r({}, this.constructor.Default, e, "object" == typeof t && t ? t : {})).delay && (t.delay = {
                show: t.delay,
                hide: t.delay
            }), "number" == typeof t.title && (t.title = t.title.toString()), "number" == typeof t.content && (t.content = t.content.toString()), _.typeCheckConfig(Mt, t, this.constructor.DefaultType), t.sanitize && (t.template = Wt(t.template, t.whiteList, t.sanitizeFn)), t
        }, qt._getDelegateConfig = function() {
            var t = {};
            if (this.config)
                for (var e in this.config) this.constructor.Default[e] !== this.config[e] && (t[e] = this.config[e]);
            return t
        }, qt._cleanTipClass = function() {
            var t = g(this.getTipElement()),
                e = t.attr("class").match(Yt);
            null !== e && e.length && t.removeClass(e.join(""))
        }, qt._handlePopperPlacementChange = function(t) {
            var e = t.instance;
            this.tip = e.popper, this._cleanTipClass(), this.addAttachmentClass(this._getAttachment(t.placement))
        }, qt._fixTransition = function() {
            var t = this.getTipElement(),
                e = this.config.animation;
            null === t.getAttribute("x-placement") && (g(t).removeClass(te), this.config.animation = !1, this.hide(), this.show(), this.config.animation = e)
        }, se._jQueryInterface = function(n) {
            return this.each(function() {
                var t = g(this).data(Kt),
                    e = "object" == typeof n && n;
                if ((t || !/dispose|hide/.test(n)) && (t || (t = new se(this, e), g(this).data(Kt, t)), "string" == typeof n)) {
                    if (void 0 === t[n]) throw new TypeError('No method named "' + n + '"');
                    t[n]()
                }
            })
        }, s(se, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return Gt
            }
        }, {
            key: "NAME",
            get: function() {
                return Mt
            }
        }, {
            key: "DATA_KEY",
            get: function() {
                return Kt
            }
        }, {
            key: "Event",
            get: function() {
                return Zt
            }
        }, {
            key: "EVENT_KEY",
            get: function() {
                return Qt
            }
        }, {
            key: "DefaultType",
            get: function() {
                return Xt
            }
        }]), se);

    function se(t, e) {
        if (void 0 === u) throw new TypeError("Bootstrap's tooltips require Popper.js (https://popper.js.org/)");
        this._isEnabled = !0, this._timeout = 0, this._hoverState = "", this._activeTrigger = {}, this._popper = null, this.element = t, this.config = this._getConfig(e), this.tip = null, this._setListeners()
    }
    g.fn[Mt] = oe._jQueryInterface, g.fn[Mt].Constructor = oe, g.fn[Mt].noConflict = function() {
        return g.fn[Mt] = Bt, oe._jQueryInterface
    };
    var re = "popover",
        ae = "bs.popover",
        le = "." + ae,
        ce = g.fn[re],
        he = "bs-popover",
        ue = new RegExp("(^|\\s)" + he + "\\S+", "g"),
        fe = r({}, oe.Default, {
            placement: "right",
            trigger: "click",
            content: "",
            template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>'
        }),
        de = r({}, oe.DefaultType, {
            content: "(string|element|function)"
        }),
        ge = {
            HIDE: "hide" + le,
            HIDDEN: "hidden" + le,
            SHOW: "show" + le,
            SHOWN: "shown" + le,
            INSERTED: "inserted" + le,
            CLICK: "click" + le,
            FOCUSIN: "focusin" + le,
            FOCUSOUT: "focusout" + le,
            MOUSEENTER: "mouseenter" + le,
            MOUSELEAVE: "mouseleave" + le
        },
        _e = function(t) {
            var e, n;

            function i() {
                return t.apply(this, arguments) || this
            }
            n = t, (e = i).prototype = Object.create(n.prototype), (e.prototype.constructor = e).__proto__ = n;
            var o = i.prototype;
            return o.isWithContent = function() {
                return this.getTitle() || this._getContent()
            }, o.addAttachmentClass = function(t) {
                g(this.getTipElement()).addClass(he + "-" + t)
            }, o.getTipElement = function() {
                return this.tip = this.tip || g(this.config.template)[0], this.tip
            }, o.setContent = function() {
                var t = g(this.getTipElement());
                this.setElementContent(t.find(".popover-header"), this.getTitle());
                var e = this._getContent();
                "function" == typeof e && (e = e.call(this.element)), this.setElementContent(t.find(".popover-body"), e), t.removeClass("fade show")
            }, o._getContent = function() {
                return this.element.getAttribute("data-content") || this.config.content
            }, o._cleanTipClass = function() {
                var t = g(this.getTipElement()),
                    e = t.attr("class").match(ue);
                null !== e && 0 < e.length && t.removeClass(e.join(""))
            }, i._jQueryInterface = function(n) {
                return this.each(function() {
                    var t = g(this).data(ae),
                        e = "object" == typeof n ? n : null;
                    if ((t || !/dispose|hide/.test(n)) && (t || (t = new i(this, e), g(this).data(ae, t)), "string" == typeof n)) {
                        if (void 0 === t[n]) throw new TypeError('No method named "' + n + '"');
                        t[n]()
                    }
                })
            }, s(i, null, [{
                key: "VERSION",
                get: function() {
                    return "4.3.1"
                }
            }, {
                key: "Default",
                get: function() {
                    return fe
                }
            }, {
                key: "NAME",
                get: function() {
                    return re
                }
            }, {
                key: "DATA_KEY",
                get: function() {
                    return ae
                }
            }, {
                key: "Event",
                get: function() {
                    return ge
                }
            }, {
                key: "EVENT_KEY",
                get: function() {
                    return le
                }
            }, {
                key: "DefaultType",
                get: function() {
                    return de
                }
            }]), i
        }(oe);
    g.fn[re] = _e._jQueryInterface, g.fn[re].Constructor = _e, g.fn[re].noConflict = function() {
        return g.fn[re] = ce, _e._jQueryInterface
    };
    var me, pe = "scrollspy",
        ve = "bs.scrollspy",
        Ee = "." + ve,
        ye = g.fn[pe],
        Ce = {
            offset: 10,
            method: "auto",
            target: ""
        },
        Te = {
            offset: "number",
            method: "string",
            target: "(string|element)"
        },
        Se = {
            ACTIVATE: "activate" + Ee,
            SCROLL: "scroll" + Ee,
            LOAD_DATA_API: "load" + Ee + ".data-api"
        },
        be = "active",
        Ie = ".nav, .list-group",
        De = ".nav-link",
        we = ".list-group-item",
        Ae = "position",
        Ne = ((me = Oe.prototype).refresh = function() {
            var e = this,
                t = this._scrollElement === this._scrollElement.window ? "offset" : Ae,
                o = "auto" === this._config.method ? t : this._config.method,
                s = o === Ae ? this._getScrollTop() : 0;
            this._offsets = [], this._targets = [], this._scrollHeight = this._getScrollHeight(), [].slice.call(document.querySelectorAll(this._selector)).map(function(t) {
                var e, n = _.getSelectorFromElement(t);
                if (n && (e = document.querySelector(n)), e) {
                    var i = e.getBoundingClientRect();
                    if (i.width || i.height) return [g(e)[o]().top + s, n]
                }
                return null
            }).filter(function(t) {
                return t
            }).sort(function(t, e) {
                return t[0] - e[0]
            }).forEach(function(t) {
                e._offsets.push(t[0]), e._targets.push(t[1])
            })
        }, me.dispose = function() {
            g.removeData(this._element, ve), g(this._scrollElement).off(Ee), this._element = null, this._scrollElement = null, this._config = null, this._selector = null, this._offsets = null, this._targets = null, this._activeTarget = null, this._scrollHeight = null
        }, me._getConfig = function(t) {
            if ("string" != typeof(t = r({}, Ce, "object" == typeof t && t ? t : {})).target) {
                var e = g(t.target).attr("id");
                e || (e = _.getUID(pe), g(t.target).attr("id", e)), t.target = "#" + e
            }
            return _.typeCheckConfig(pe, t, Te), t
        }, me._getScrollTop = function() {
            return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop
        }, me._getScrollHeight = function() {
            return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight)
        }, me._getOffsetHeight = function() {
            return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height
        }, me._process = function() {
            var t = this._getScrollTop() + this._config.offset,
                e = this._getScrollHeight(),
                n = this._config.offset + e - this._getOffsetHeight();
            if (this._scrollHeight !== e && this.refresh(), n <= t) {
                var i = this._targets[this._targets.length - 1];
                this._activeTarget !== i && this._activate(i)
            } else {
                if (this._activeTarget && t < this._offsets[0] && 0 < this._offsets[0]) return this._activeTarget = null, void this._clear();
                for (var o = this._offsets.length; o--;) this._activeTarget !== this._targets[o] && t >= this._offsets[o] && (void 0 === this._offsets[o + 1] || t < this._offsets[o + 1]) && this._activate(this._targets[o])
            }
        }, me._activate = function(e) {
            this._activeTarget = e, this._clear();
            var t = this._selector.split(",").map(function(t) {
                    return t + '[data-target="' + e + '"],' + t + '[href="' + e + '"]'
                }),
                n = g([].slice.call(document.querySelectorAll(t.join(","))));
            n.hasClass("dropdown-item") ? (n.closest(".dropdown").find(".dropdown-toggle").addClass(be), n.addClass(be)) : (n.addClass(be), n.parents(Ie).prev(De + ", " + we).addClass(be), n.parents(Ie).prev(".nav-item").children(De).addClass(be)), g(this._scrollElement).trigger(Se.ACTIVATE, {
                relatedTarget: e
            })
        }, me._clear = function() {
            [].slice.call(document.querySelectorAll(this._selector)).filter(function(t) {
                return t.classList.contains(be)
            }).forEach(function(t) {
                return t.classList.remove(be)
            })
        }, Oe._jQueryInterface = function(e) {
            return this.each(function() {
                var t = g(this).data(ve);
                if (t || (t = new Oe(this, "object" == typeof e && e), g(this).data(ve, t)), "string" == typeof e) {
                    if (void 0 === t[e]) throw new TypeError('No method named "' + e + '"');
                    t[e]()
                }
            })
        }, s(Oe, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "Default",
            get: function() {
                return Ce
            }
        }]), Oe);

    function Oe(t, e) {
        var n = this;
        this._element = t, this._scrollElement = "BODY" === t.tagName ? window : t, this._config = this._getConfig(e), this._selector = this._config.target + " " + De + "," + this._config.target + " " + we + "," + this._config.target + " .dropdown-item", this._offsets = [], this._targets = [], this._activeTarget = null, this._scrollHeight = 0, g(this._scrollElement).on(Se.SCROLL, function(t) {
            return n._process(t)
        }), this.refresh(), this._process()
    }
    g(window).on(Se.LOAD_DATA_API, function() {
        for (var t = [].slice.call(document.querySelectorAll('[data-spy="scroll"]')), e = t.length; e--;) {
            var n = g(t[e]);
            Ne._jQueryInterface.call(n, n.data())
        }
    }), g.fn[pe] = Ne._jQueryInterface, g.fn[pe].Constructor = Ne, g.fn[pe].noConflict = function() {
        return g.fn[pe] = ye, Ne._jQueryInterface
    };
    var ke, Pe = "bs.tab",
        Le = "." + Pe,
        je = g.fn.tab,
        He = {
            HIDE: "hide" + Le,
            HIDDEN: "hidden" + Le,
            SHOW: "show" + Le,
            SHOWN: "shown" + Le,
            CLICK_DATA_API: "click" + Le + ".data-api"
        },
        Re = "active",
        xe = ".active",
        Fe = "> li > .active",
        Ue = ((ke = We.prototype).show = function() {
            var n = this;
            if (!(this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && g(this._element).hasClass(Re) || g(this._element).hasClass("disabled"))) {
                var t, i, e = g(this._element).closest(".nav, .list-group")[0],
                    o = _.getSelectorFromElement(this._element);
                if (e) {
                    var s = "UL" === e.nodeName || "OL" === e.nodeName ? Fe : xe;
                    i = (i = g.makeArray(g(e).find(s)))[i.length - 1]
                }
                var r = g.Event(He.HIDE, {
                        relatedTarget: this._element
                    }),
                    a = g.Event(He.SHOW, {
                        relatedTarget: i
                    });
                if (i && g(i).trigger(r), g(this._element).trigger(a), !a.isDefaultPrevented() && !r.isDefaultPrevented()) {
                    o && (t = document.querySelector(o)), this._activate(this._element, e);
                    var l = function() {
                        var t = g.Event(He.HIDDEN, {
                                relatedTarget: n._element
                            }),
                            e = g.Event(He.SHOWN, {
                                relatedTarget: i
                            });
                        g(i).trigger(t), g(n._element).trigger(e)
                    };
                    t ? this._activate(t, t.parentNode, l) : l()
                }
            }
        }, ke.dispose = function() {
            g.removeData(this._element, Pe), this._element = null
        }, ke._activate = function(t, e, n) {
            function i() {
                return o._transitionComplete(t, s, n)
            }
            var o = this,
                s = (!e || "UL" !== e.nodeName && "OL" !== e.nodeName ? g(e).children(xe) : g(e).find(Fe))[0],
                r = n && s && g(s).hasClass("fade");
            if (s && r) {
                var a = _.getTransitionDurationFromElement(s);
                g(s).removeClass("show").one(_.TRANSITION_END, i).emulateTransitionEnd(a)
            } else i()
        }, ke._transitionComplete = function(t, e, n) {
            if (e) {
                g(e).removeClass(Re);
                var i = g(e.parentNode).find("> .dropdown-menu .active")[0];
                i && g(i).removeClass(Re), "tab" === e.getAttribute("role") && e.setAttribute("aria-selected", !1)
            }
            if (g(t).addClass(Re), "tab" === t.getAttribute("role") && t.setAttribute("aria-selected", !0), _.reflow(t), t.classList.contains("fade") && t.classList.add("show"), t.parentNode && g(t.parentNode).hasClass("dropdown-menu")) {
                var o = g(t).closest(".dropdown")[0];
                if (o) {
                    var s = [].slice.call(o.querySelectorAll(".dropdown-toggle"));
                    g(s).addClass(Re)
                }
                t.setAttribute("aria-expanded", !0)
            }
            n && n()
        }, We._jQueryInterface = function(n) {
            return this.each(function() {
                var t = g(this),
                    e = t.data(Pe);
                if (e || (e = new We(this), t.data(Pe, e)), "string" == typeof n) {
                    if (void 0 === e[n]) throw new TypeError('No method named "' + n + '"');
                    e[n]()
                }
            })
        }, s(We, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }]), We);

    function We(t) {
        this._element = t
    }
    g(document).on(He.CLICK_DATA_API, '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]', function(t) {
        t.preventDefault(), Ue._jQueryInterface.call(g(this), "show")
    }), g.fn.tab = Ue._jQueryInterface, g.fn.tab.Constructor = Ue, g.fn.tab.noConflict = function() {
        return g.fn.tab = je, Ue._jQueryInterface
    };
    var qe, Me = "toast",
        Ke = "bs.toast",
        Qe = "." + Ke,
        Be = g.fn[Me],
        Ve = {
            CLICK_DISMISS: "click.dismiss" + Qe,
            HIDE: "hide" + Qe,
            HIDDEN: "hidden" + Qe,
            SHOW: "show" + Qe,
            SHOWN: "shown" + Qe
        },
        Ye = "show",
        ze = "showing",
        Xe = {
            animation: "boolean",
            autohide: "boolean",
            delay: "number"
        },
        $e = {
            animation: !0,
            autohide: !0,
            delay: 500
        },
        Ge = ((qe = Je.prototype).show = function() {
            var t = this;

            function e() {
                t._element.classList.remove(ze), t._element.classList.add(Ye), g(t._element).trigger(Ve.SHOWN), t._config.autohide && t.hide()
            }
            if (g(this._element).trigger(Ve.SHOW), this._config.animation && this._element.classList.add("fade"), this._element.classList.remove("hide"), this._element.classList.add(ze), this._config.animation) {
                var n = _.getTransitionDurationFromElement(this._element);
                g(this._element).one(_.TRANSITION_END, e).emulateTransitionEnd(n)
            } else e()
        }, qe.hide = function(t) {
            var e = this;
            this._element.classList.contains(Ye) && (g(this._element).trigger(Ve.HIDE), t ? this._close() : this._timeout = setTimeout(function() {
                e._close()
            }, this._config.delay))
        }, qe.dispose = function() {
            clearTimeout(this._timeout), this._timeout = null, this._element.classList.contains(Ye) && this._element.classList.remove(Ye), g(this._element).off(Ve.CLICK_DISMISS), g.removeData(this._element, Ke), this._element = null, this._config = null
        }, qe._getConfig = function(t) {
            return t = r({}, $e, g(this._element).data(), "object" == typeof t && t ? t : {}), _.typeCheckConfig(Me, t, this.constructor.DefaultType), t
        }, qe._setListeners = function() {
            var t = this;
            g(this._element).on(Ve.CLICK_DISMISS, '[data-dismiss="toast"]', function() {
                return t.hide(!0)
            })
        }, qe._close = function() {
            function t() {
                e._element.classList.add("hide"), g(e._element).trigger(Ve.HIDDEN)
            }
            var e = this;
            if (this._element.classList.remove(Ye), this._config.animation) {
                var n = _.getTransitionDurationFromElement(this._element);
                g(this._element).one(_.TRANSITION_END, t).emulateTransitionEnd(n)
            } else t()
        }, Je._jQueryInterface = function(n) {
            return this.each(function() {
                var t = g(this),
                    e = t.data(Ke);
                if (e || (e = new Je(this, "object" == typeof n && n), t.data(Ke, e)), "string" == typeof n) {
                    if (void 0 === e[n]) throw new TypeError('No method named "' + n + '"');
                    e[n](this)
                }
            })
        }, s(Je, null, [{
            key: "VERSION",
            get: function() {
                return "4.3.1"
            }
        }, {
            key: "DefaultType",
            get: function() {
                return Xe
            }
        }, {
            key: "Default",
            get: function() {
                return $e
            }
        }]), Je);

    function Je(t, e) {
        this._element = t, this._config = this._getConfig(e), this._timeout = null, this._setListeners()
    }
    g.fn[Me] = Ge._jQueryInterface, g.fn[Me].Constructor = Ge, g.fn[Me].noConflict = function() {
            return g.fn[Me] = Be, Ge._jQueryInterface
        },
        function() {
            if (void 0 === g) throw new TypeError("Bootstrap's JavaScript requires jQuery. jQuery must be included before Bootstrap's JavaScript.");
            var t = g.fn.jquery.split(" ")[0].split(".");
            if (t[0] < 2 && t[1] < 9 || 1 === t[0] && 9 === t[1] && t[2] < 1 || 4 <= t[0]) throw new Error("Bootstrap's JavaScript requires at least jQuery v1.9.1 but less than v4.0.0")
        }(), t.Util = _, t.Alert = f, t.Button = D, t.Carousel = M, t.Collapse = it, t.Dropdown = yt, t.Modal = Ht, t.Popover = _e, t.Scrollspy = Ne, t.Tab = Ue, t.Toast = Ge, t.Tooltip = oe, Object.defineProperty(t, "__esModule", {
            value: !0
        })
});

(function() {
    function e(t, e) {
        return function() {
            return t.apply(e, arguments)
        }
    }
    var i, t, n, a, o, s = [].indexOf || function(t) {
        for (var e = 0, n = this.length; e < n; e++)
            if (e in this && this[e] === t) return e;
        return -1
    };

    function r(t) {
        null == t && (t = {}), this.scrollCallback = e(this.scrollCallback, this), this.scrollHandler = e(this.scrollHandler, this), this.start = e(this.start, this), this.scrolled = !0, this.config = this.util().extend(t, this.defaults), this.animationNameCache = new n
    }

    function l() {
        "undefined" != typeof console && null !== console && console.warn("MutationObserver is not supported by your browser."), "undefined" != typeof console && null !== console && console.warn("WOW.js cannot detect dom mutations, please call .sync() after loading new content.")
    }

    function u() {
        this.keys = [], this.values = []
    }

    function h() {}
    h.prototype.extend = function(t, e) {
        var n, i;
        for (n in e) i = e[n], null == t[n] && (t[n] = i);
        return t
    }, h.prototype.isMobile = function(t) {
        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(t)
    }, h.prototype.addEvent = function(t, e, n) {
        return null != t.addEventListener ? t.addEventListener(e, n, !1) : null != t.attachEvent ? t.attachEvent("on" + e, n) : t[e] = n
    }, h.prototype.removeEvent = function(t, e, n) {
        return null != t.removeEventListener ? t.removeEventListener(e, n, !1) : null != t.detachEvent ? t.detachEvent("on" + e, n) : delete t[e]
    }, h.prototype.innerHeight = function() {
        return "innerHeight" in window ? window.innerHeight : document.documentElement.clientHeight
    }, t = h, n = this.WeakMap || this.MozWeakMap || (u.prototype.get = function(t) {
        var e, n, i, o;
        for (e = n = 0, i = (o = this.keys).length; n < i; e = ++n)
            if (o[e] === t) return this.values[e]
    }, u.prototype.set = function(t, e) {
        var n, i, o, r;
        for (n = i = 0, o = (r = this.keys).length; i < o; n = ++i)
            if (r[n] === t) return void(this.values[n] = e);
        return this.keys.push(t), this.values.push(e)
    }, u), i = this.MutationObserver || this.WebkitMutationObserver || this.MozMutationObserver || (l.notSupported = !0, l.prototype.observe = function() {}, l), a = this.getComputedStyle || function(n) {
        return this.getPropertyValue = function(t) {
            var e;
            return "float" === t && (t = "styleFloat"), o.test(t) && t.replace(o, function(t, e) {
                return e.toUpperCase()
            }), (null != (e = n.currentStyle) ? e[t] : void 0) || null
        }, this
    }, o = /(\-([a-z]){1})/g, this.WOW = (r.prototype.defaults = {
        boxClass: "wow",
        animateClass: "animated",
        offset: 0,
        mobile: !0,
        live: !0
    }, r.prototype.init = function() {
        var t;
        return this.element = window.document.documentElement, "interactive" === (t = document.readyState) || "complete" === t ? this.start() : this.util().addEvent(document, "DOMContentLoaded", this.start), this.finished = []
    }, r.prototype.start = function() {
        var o, t, e, n, s;
        if (this.stopped = !1, this.boxes = function() {
                var t, e, n, i;
                for (i = [], t = 0, e = (n = this.element.querySelectorAll("." + this.config.boxClass)).length; t < e; t++) o = n[t], i.push(o);
                return i
            }.call(this), this.all = function() {
                var t, e, n, i;
                for (i = [], t = 0, e = (n = this.boxes).length; t < e; t++) o = n[t], i.push(o);
                return i
            }.call(this), this.boxes.length)
            if (this.disabled()) this.resetStyle();
            else
                for (t = 0, e = (n = this.boxes).length; t < e; t++) o = n[t], this.applyStyle(o, !0);
        return this.disabled() || (this.util().addEvent(window, "scroll", this.scrollHandler), this.util().addEvent(window, "resize", this.scrollHandler), this.interval = setInterval(this.scrollCallback, 50)), this.config.live ? new i((s = this, function(t) {
            var o, r, e, n, i;
            for (i = [], e = 0, n = t.length; e < n; e++) r = t[e], i.push(function() {
                var t, e, n, i;
                for (i = [], t = 0, e = (n = r.addedNodes || []).length; t < e; t++) o = n[t], i.push(this.doSync(o));
                return i
            }.call(s));
            return i
        })).observe(document.body, {
            childList: !0,
            subtree: !0
        }) : void 0
    }, r.prototype.stop = function() {
        return this.stopped = !0, this.util().removeEvent(window, "scroll", this.scrollHandler), this.util().removeEvent(window, "resize", this.scrollHandler), null != this.interval ? clearInterval(this.interval) : void 0
    }, r.prototype.sync = function() {
        return i.notSupported ? this.doSync(this.element) : void 0
    }, r.prototype.doSync = function(t) {
        var e, n, i, o, r;
        if (null == t && (t = this.element), 1 === t.nodeType) {
            for (r = [], n = 0, i = (o = (t = t.parentNode || t).querySelectorAll("." + this.config.boxClass)).length; n < i; n++) e = o[n], s.call(this.all, e) < 0 ? (this.boxes.push(e), this.all.push(e), this.stopped || this.disabled() ? this.resetStyle() : this.applyStyle(e, !0), r.push(this.scrolled = !0)) : r.push(void 0);
            return r
        }
    }, r.prototype.show = function(t) {
        return this.applyStyle(t), t.className = t.className + " " + this.config.animateClass
    }, r.prototype.applyStyle = function(t, e) {
        var n, i, o, r;
        return i = t.getAttribute("data-wow-duration"), n = t.getAttribute("data-wow-delay"), o = t.getAttribute("data-wow-iteration"), this.animate((r = this, function() {
            return r.customStyle(t, e, i, n, o)
        }))
    }, r.prototype.animate = "requestAnimationFrame" in window ? function(t) {
        return window.requestAnimationFrame(t)
    } : function(t) {
        return t()
    }, r.prototype.resetStyle = function() {
        var t, e, n, i, o;
        for (o = [], e = 0, n = (i = this.boxes).length; e < n; e++) t = i[e], o.push(t.style.visibility = "visible");
        return o
    }, r.prototype.customStyle = function(t, e, n, i, o) {
        return e && this.cacheAnimationName(t), t.style.visibility = e ? "hidden" : "visible", n && this.vendorSet(t.style, {
            animationDuration: n
        }), i && this.vendorSet(t.style, {
            animationDelay: i
        }), o && this.vendorSet(t.style, {
            animationIterationCount: o
        }), this.vendorSet(t.style, {
            animationName: e ? "none" : this.cachedAnimationName(t)
        }), t
    }, r.prototype.vendors = ["moz", "webkit"], r.prototype.vendorSet = function(o, t) {
        var r, s, l, e;
        for (r in e = [], t) s = t[r], o["" + r] = s, e.push(function() {
            var t, e, n, i;
            for (i = [], t = 0, e = (n = this.vendors).length; t < e; t++) l = n[t], i.push(o["" + l + r.charAt(0).toUpperCase() + r.substr(1)] = s);
            return i
        }.call(this));
        return e
    }, r.prototype.vendorCSS = function(t, e) {
        var n, i, o, r, s, l;
        for (n = (i = a(t)).getPropertyCSSValue(e), r = 0, s = (l = this.vendors).length; r < s; r++) o = l[r], n = n || i.getPropertyCSSValue("-" + o + "-" + e);
        return n
    }, r.prototype.animationName = function(e) {
        var n;
        try {
            n = this.vendorCSS(e, "animation-name").cssText
        } catch (t) {
            n = a(e).getPropertyValue("animation-name")
        }
        return "none" === n ? "" : n
    }, r.prototype.cacheAnimationName = function(t) {
        return this.animationNameCache.set(t, this.animationName(t))
    }, r.prototype.cachedAnimationName = function(t) {
        return this.animationNameCache.get(t)
    }, r.prototype.scrollHandler = function() {
        return this.scrolled = !0
    }, r.prototype.scrollCallback = function() {
        var o;
        return !this.scrolled || (this.scrolled = !1, this.boxes = function() {
            var t, e, n, i;
            for (i = [], t = 0, e = (n = this.boxes).length; t < e; t++)(o = n[t]) && (this.isVisible(o) ? this.show(o) : i.push(o));
            return i
        }.call(this), this.boxes.length || this.config.live) ? void 0 : this.stop()
    }, r.prototype.offsetTop = function(t) {
        for (var e; void 0 === t.offsetTop;) t = t.parentNode;
        for (e = t.offsetTop; t = t.offsetParent;) e += t.offsetTop;
        return e
    }, r.prototype.isVisible = function(t) {
        var e, n, i, o, r;
        return n = t.getAttribute("data-wow-offset") || this.config.offset, o = (r = window.pageYOffset) + Math.min(this.element.clientHeight, this.util().innerHeight()) - n, e = (i = this.offsetTop(t)) + t.clientHeight, i <= o && r <= e
    }, r.prototype.util = function() {
        return null != this._util ? this._util : this._util = new t
    }, r.prototype.disabled = function() {
        return !this.config.mobile && this.util().isMobile(navigator.userAgent)
    }, r)
}).call(this);

$(document).ready(function() {
    $(document).on("click", ".search-close", function() {
        $(".search-box").fadeOut()
    }), $(document).on("click", ".open-search", function() {
        $(".search-box").fadeIn()
    })
}), $(".sliding_form_icon").click(function() {
    $(".sliding_form").addClass("open")
}), $(".sliding_form_box .close_btn").click(function() {
    $(".sliding_form").removeClass("open")
}), $(document).ready(function() {
    $(".group1").colorbox({
        rel: "group1"
    }), $(".group2").colorbox({
        rel: "group2",
        transition: "fade"
    }), $(".group3").colorbox({
        rel: "group3",
        transition: "none",
        width: "75%",
        height: "75%"
    }), $(".group4").colorbox({
        rel: "group4",
        slideshow: !0
    }), $(".ajax").colorbox(), $(".youtube").colorbox({
        iframe: !0,
        innerWidth: 640,
        innerHeight: 390
    }), $(".vimeo").colorbox({
        iframe: !0,
        innerWidth: 500,
        innerHeight: 409,
        width: "100%",
        height: "100%"
    }), $(".iframe").colorbox({
        iframe: !0,
        width: "70%",
        height: "80%"
    }), $(".inline").colorbox({
        inline: !0,
        width: "50%"
    }), $(".callbacks").colorbox({
        onOpen: function() {
            alert("onOpen: colorbox is about to open")
        },
        onLoad: function() {
            alert("onLoad: colorbox has started to load the targeted content")
        },
        onComplete: function() {
            alert("onComplete: colorbox has displayed the loaded content")
        },
        onCleanup: function() {
            alert("onCleanup: colorbox has begun the close process")
        },
        onClosed: function() {
            alert("onClosed: colorbox has completely closed")
        }
    }), $(".non-retina").colorbox({
        rel: "group5",
        transition: "none"
    }), $(".retina").colorbox({
        rel: "group5",
        transition: "none",
        retinaImage: !0,
        retinaUrl: !0
    }), $("#click").click(function() {
        return $("#click").css({
            "background-color": "#f00",
            color: "#fff",
            cursor: "inherit"
        }).text("Open this window again and this message will still be here."), !1
    })
});

$(document).ready(function() {
    "use strict";

    function e() {
        $(window).width() < 768 ? $(".table-responsive-stack").each(function(e) {
            $(this).find(".table-responsive-stack-thead").show(), $(this).find("thead").hide()
        }) : $(".table-responsive-stack").each(function(e) {
            $(this).find(".table-responsive-stack-thead").hide(), $(this).find("thead").show()
        })
    }
    $(document).ready(function() {
        $(".home_page_slider").owlCarousel({
            loop: !0,
            lazyLoad: true,
            center: !0,
            items: 1,
            margin: 0,
            navSpeed: 8e3,
            nav: !1,
            mouseDrag: !1,
            animateOut: "fadeOut",
            animateIn: "fadeIn",
            autoplay: 8000,
            autoplayTimeout: 8e3,
            smartSpeed: 8000,
            items: 1,
            autoHeight: !0
        }), $(".drop-down_menu").hover(function() {
            $("body").toggleClass("menu_hover")
        }), $(".home_page_logo").owlCarousel({
            loop: !0,
            center: !0,
            items: 4,
            margin: 0,
            autoplay: !0,
            dots: !0,
            nav: !1,
            autoplayTimeout: 8500,
            smartSpeed: 450,
            navText: ['<i class="fa fa-angle-left"></i>', '<i class="fa fa-angle-right"></i>']
        })
    }), $("#show_search").click(function() {
        $(".searchoverlay").show()
    }), $(".hide_search").click(function() {
        $(".searchoverlay").hide()
    }), $(".facility").owlCarousel({
        loop: !0,
        center: !0,
        items: 1,
        margin: 0,
        autoplay: !0,
        dots: !0,
        nav: !0,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        navText: ['<i class="fa fa-angle-left"></i>', '<i class="fa fa-angle-right"></i>'],
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".library-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 0,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        navText: ['<i class="fa fa-angle-left"></i>', '<i class="fa fa-angle-right"></i>'],
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".testimonial-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 3,
        margin: 10,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        navText: ['<i class="fa fa-angle-left"></i>', '<i class="fa fa-angle-right"></i>'],
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 2
            },
            1170: {
                items: 3
            }
        }
    }), $(".roadmap-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".placcement-logo-slider").owlCarousel({
        loop: !1,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !1,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".news-panel-slider").owlCarousel({
        loop: !1,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: 1,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".csr-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".internaional-panel-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".placcement-logo-slider1").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 5,
        margin: 10,
        autoplay: !0,
        dots: !1,
        nav: !0,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 3
            },
            1170: {
                items: 5
            }
        }
    }), $(".placcement-logo-slider2").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !0,
        dots: !1,
        nav: !0,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".school-video-slider").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 1,
        margin: 10,
        autoplay: !0,
        dots: !1,
        nav: !0,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 1
            }
        }
    }), $(".home_page_logo1").owlCarousel({
        loop: !0,
        center: !0,
        lazyLoad: !0,
        items: 4,
        margin: 10,
        autoplay: !0,
        dots: !0,
        nav: !1,
        autoplayTimeout: 8500,
        smartSpeed: 450,
        responsive: {
            0: {
                items: 1
            },
            768: {
                items: 1
            },
            1170: {
                items: 4
            }
        }
    }), $(".home_logo_home").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 10,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 3,
                nav: !1
            },
            1000: {
                items: 4,
                nav: !1,
                loop: !1
            }
        }
    }), $(".faculty_sec").owlCarousel({
        loop: !0,
        autoplay: true,
        lazyLoad: true,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(".home_infra_slider").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 10,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 1,
                nav: !1
            },
            1000: {
                items: 1,
                nav: !1,
                loop: !1
            }
        }
    }), $(".news_activities_plmnt_overview").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(".testimonials_corporate_plmnt_overview").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(".testimonials_sec_course").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(".testimonials_sec_student").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 4,
                nav: !1,
                loop: !1
            }
        }
    }), $(".testimonials_sec_corporate").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 4,
                nav: !1,
                loop: !1
            }
        }
    }), $(".placement_video_testimonials").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 4,
                nav: !1,
                loop: !1
            }
        }
    }), $(".testimonials_sec_alumni").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 20,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(".campus_sec").owlCarousel({
        loop: !0,
        lazyLoad: !0,
        margin: 10,
        responsiveClass: !0,
        responsive: {
            0: {
                items: 1,
                nav: !1
            },
            600: {
                items: 2,
                nav: !1
            },
            1000: {
                items: 3,
                nav: !1,
                loop: !1
            }
        }
    }), $(window).on("scroll", function() {
        80 < $(window).scrollTop() ? $(".scrolling-navbar").addClass("top-nav-collapse") : $(".scrolling-navbar").removeClass("top-nav-collapse")
    }), $(".table-responsive-stack").find("th").each(function(e) {
        $(".table-responsive-stack td:nth-child(" + (e + 1) + ")").prepend('<span class="table-responsive-stack-thead">' + $(this).text() + ":</span> "), $(".table-responsive-stack-thead").hide()
    }), $(".table-responsive-stack").each(function() {
        var e = 100 / $(this).find("th").length + "%";
        $(this).find("th, td").css("flex-basis", e)
    }), e(), window.onresize = function(s) {
        e()
    }, $("#show_search").click(function() {
        $(".searchoverlay").show()
    }), $(".hide_search").click(function() {
        $(".searchoverlay").hide()
    }), $(".openCollapse").click(function() {
        $(".showCollapse").toggle()
    }), (new WOW).init(), $(".mobile_nav_icon").on("click", function() {
        $("#navbarResponsive2").toggleClass("menuopened"), $(this).toggleClass("open")
    }), $(document).ready(function() {
        $(".mobile_nav li").click(function() {
            $(".mobile_nav li > ul").not($(this).children("ul").toggle()).hide(), $(".mobile_nav .nav-item ").not($(this).children("ul").toggleClass("add")).removeClass("add")
        })
    }), $(".mobile_nav .nav-item").on("show.dropdown", function() {
        $(this).find(".dropdown-menu").first().stop(!0, !0).slideDown()
    }), $(".mobile_nav .nav-item").on("hide.dropdown", function() {
        $(this).find(".dropdown-menu").first().stop(!0, !0).slideUp()
    }), $(".dropdown-submenu a.link").on("click", function(e) {
        $(this).parent().find(".dropdown-menu").first().stop(!0, !0).slideToggle(), $(this).toggleClass("open"), e.stopPropagation(), e.preventDefault()
    })
}), $(function() {
    $(".slide").on("click", function() {
        $(".slide").removeClass("slick-current").addClass("slide-default"), $(this).addClass("slick-current").removeClass("slide-default").blur()
    }), $(window).scroll(function() {
        var e = $("#myHeader");
        400 <= $(window).scrollTop() ? e.addClass("myHeader-fixed") : e.removeClass("myHeader-fixed")
    })
});
var groups = {};
$(".galleryItem").each(function() {
    var e = parseInt($(this).attr("data-group"), 10);
    groups[e] || (groups[e] = []), groups[e].push(this)
}), $.each(groups, function() {
    $(this).magnificPopup({
        type: "image",
        closeOnContentClick: !0,
        closeBtnInside: !1,
        gallery: {
            enabled: !0
        }
    })
});

! function(d, s, l) {
    var c, g, u, f, p, m, w, v, x, y, b, T, C, H, h, t, r, a, k, W, E, I, M, L, F, R, S, K, P, B, O, _, o, n = {
            html: !1,
            photo: !1,
            iframe: !1,
            inline: !1,
            transition: "elastic",
            speed: 300,
            fadeOut: 300,
            width: !1,
            initialWidth: "600",
            innerWidth: !1,
            maxWidth: !1,
            height: !1,
            initialHeight: "450",
            innerHeight: !1,
            maxHeight: !1,
            scalePhotos: !0,
            scrolling: !0,
            opacity: .9,
            preloading: !0,
            className: !1,
            overlayClose: !0,
            escKey: !0,
            arrowKey: !0,
            top: !1,
            bottom: !1,
            left: !1,
            right: !1,
            fixed: !1,
            data: void 0,
            closeButton: !0,
            fastIframe: !0,
            open: !1,
            reposition: !0,
            loop: !0,
            slideshow: !1,
            slideshowAuto: !0,
            slideshowSpeed: 2500,
            slideshowStart: "start slideshow",
            slideshowStop: "stop slideshow",
            photoRegex: /\.(gif|png|jp(e|g|eg)|bmp|ico|webp|jxr|svg)((#|\?).*)?$/i,
            retinaImage: !1,
            retinaUrl: !1,
            retinaSuffix: "@2x.$1",
            current: "image {current} of {total}",
            previous: "previous",
            next: "next",
            close: "close",
            xhrError: "This content failed to load.",
            imgError: "This image failed to load.",
            returnFocus: !0,
            trapFocus: !0,
            onOpen: !1,
            onLoad: !1,
            onComplete: !1,
            onCleanup: !1,
            onClosed: !1,
            rel: function() {
                return this.rel
            },
            href: function() {
                return d(this).attr("href")
            },
            title: function() {
                return this.title
            },
            createImg: function() {
                var i = new Image,
                    t = d(this).data("cbox-img-attrs");
                return "object" == typeof t && d.each(t, function(t, e) {
                    i[t] = e
                }), i
            },
            createIframe: function() {
                var i = s.createElement("iframe"),
                    t = d(this).data("cbox-iframe-attrs");
                return "object" == typeof t && d.each(t, function(t, e) {
                    i[t] = e
                }), "frameBorder" in i && (i.frameBorder = 0), "allowTransparency" in i && (i.allowTransparency = "true"), i.name = (new Date).getTime(), i.allowFullscreen = !0, i
            }
        },
        j = "colorbox",
        D = "cbox",
        N = D + "Element",
        z = D + "_open",
        A = D + "_load",
        q = D + "_complete",
        e = D + "_cleanup",
        U = D + "_closed",
        $ = D + "_purge",
        G = d("<a/>"),
        Q = "div",
        J = 0,
        V = {};

    function X(t, e, i) {
        var n = s.createElement(t);
        return e && (n.id = D + e), i && (n.style.cssText = i), d(n)
    }

    function Y() {
        return l.innerHeight ? l.innerHeight : d(l).height()
    }

    function Z(t, i) {
        i !== Object(i) && (i = {}), this.cache = {}, this.el = t, this.value = function(t) {
            var e;
            return void 0 === this.cache[t] && (void 0 !== (e = d(this.el).attr("data-cbox-" + t)) ? this.cache[t] = e : void 0 !== i[t] ? this.cache[t] = i[t] : void 0 !== n[t] && (this.cache[t] = n[t])), this.cache[t]
        }, this.get = function(t) {
            var e = this.value(t);
            return d.isFunction(e) ? e.call(this.el, this) : e
        }
    }

    function tt(t) {
        var e = x.length,
            i = (R + t) % e;
        return i < 0 ? e + i : i
    }

    function et(t, e) {
        return Math.round((/%/.test(t) ? ("x" === e ? y.width() : Y()) / 100 : 1) * parseInt(t, 10))
    }

    function it(t, e) {
        return t.get("photo") || t.get("photoRegex").test(e)
    }

    function nt(t, e) {
        return t.get("retinaUrl") && 1 < l.devicePixelRatio ? e.replace(t.get("photoRegex"), t.get("retinaSuffix")) : e
    }

    function ot(t) {
        "contains" in g[0] && !g[0].contains(t.target) && t.target !== c[0] && (t.stopPropagation(), g.focus())
    }

    function ht(t) {
        ht.str !== t && (g.add(c).removeClass(ht.str).addClass(t), ht.str = t)
    }

    function rt(t) {
        d(s).trigger(t), G.triggerHandler(t)
    }
    var i, at, st, lt, dt = (st = D + "Slideshow_", lt = "click." + D, function() {
        i ? E.get("slideshow") || (G.unbind(e, pt), pt()) : E.get("slideshow") && x[1] && (i = !0, G.one(e, pt), (E.get("slideshowAuto") ? ut : ft)(), t.show())
    });

    function ct() {
        clearTimeout(at)
    }

    function gt() {
        (E.get("loop") || x[R + 1]) && (ct(), at = setTimeout(_.next, E.get("slideshowSpeed")))
    }

    function ut() {
        t.html(E.get("slideshowStop")).unbind(lt).one(lt, ft), G.bind(q, gt).bind(A, ct), g.removeClass(st + "off").addClass(st + "on")
    }

    function ft() {
        ct(), G.unbind(q, gt).unbind(A, ct), t.html(E.get("slideshowStart")).unbind(lt).one(lt, function() {
            _.next(), ut()
        }), g.removeClass(st + "on").addClass(st + "off")
    }

    function pt() {
        i = !1, t.hide(), ct(), G.unbind(q, gt).unbind(A, ct), g.removeClass(st + "off " + st + "on")
    }

    function mt(t) {
        var e, i;
        if (!B) {
            if (e = d(t).data(j), E = new Z(t, e), i = E.get("rel"), R = 0, i && !1 !== i && "nofollow" !== i ? (x = d("." + N).filter(function() {
                    return new Z(this, d.data(this, j)).get("rel") === i
                }), -1 === (R = x.index(E.el)) && (x = x.add(E.el), R = x.length - 1)) : x = d(E.el), !K) {
                K = P = !0, ht(E.get("className")), g.css({
                    visibility: "hidden",
                    display: "block",
                    opacity: ""
                }), b = X(Q, "LoadedContent", "width:0; height:0; overflow:hidden; visibility:hidden"), f.css({
                    width: "",
                    height: ""
                }).append(b), I = p.height() + v.height() + f.outerHeight(!0) - f.height(), M = m.width() + w.width() + f.outerWidth(!0) - f.width(), L = b.outerHeight(!0), F = b.outerWidth(!0);
                var n = et(E.get("initialWidth"), "x"),
                    o = et(E.get("initialHeight"), "y"),
                    h = E.get("maxWidth"),
                    r = E.get("maxHeight");
                E.w = Math.max((!1 !== h ? Math.min(n, et(h, "x")) : n) - F - M, 0), E.h = Math.max((!1 !== r ? Math.min(o, et(r, "y")) : o) - L - I, 0), b.css({
                    width: "",
                    height: E.h
                }), _.position(), rt(z), E.get("onOpen"), W.add(H).hide(), g.focus(), E.get("trapFocus") && s.addEventListener && (s.addEventListener("focus", ot, !0), G.one(U, function() {
                    s.removeEventListener("focus", ot, !0)
                })), E.get("returnFocus") && G.one(U, function() {
                    d(E.el).focus()
                })
            }
            var a = parseFloat(E.get("opacity"));
            c.css({
                    opacity: a == a ? a : "",
                    cursor: E.get("overlayClose") ? "pointer" : "",
                    visibility: "visible"
                }).show(), E.get("closeButton") ? k.html(E.get("close")).appendTo(f) : k.appendTo("<div/>"),
                function() {
                    var t, e, i, n = _.prep,
                        o = ++J;
                    P = !0, S = !1, rt($), rt(A), E.get("onLoad"), E.h = E.get("height") ? et(E.get("height"), "y") - L - I : E.get("innerHeight") && et(E.get("innerHeight"), "y"), E.w = E.get("width") ? et(E.get("width"), "x") - F - M : E.get("innerWidth") && et(E.get("innerWidth"), "x"), E.mw = E.w, E.mh = E.h, E.get("maxWidth") && (E.mw = et(E.get("maxWidth"), "x") - F - M, E.mw = E.w && E.w < E.mw ? E.w : E.mw);
                    E.get("maxHeight") && (E.mh = et(E.get("maxHeight"), "y") - L - I, E.mh = E.h && E.h < E.mh ? E.h : E.mh);
                    if (t = E.get("href"), O = setTimeout(function() {
                            C.show()
                        }, 100), E.get("inline")) {
                        var h = d(t).eq(0);
                        i = d("<div>").hide().insertBefore(h), G.one($, function() {
                            i.replaceWith(h)
                        }), n(h)
                    } else E.get("iframe") ? n(" ") : E.get("html") ? n(E.get("html")) : it(E, t) ? (t = nt(E, t), S = E.get("createImg"), d(S).addClass(D + "Photo").bind("error." + D, function() {
                        n(X(Q, "Error").html(E.get("imgError")))
                    }).one("load", function() {
                        o === J && setTimeout(function() {
                            var t;
                            E.get("retinaImage") && 1 < l.devicePixelRatio && (S.height = S.height / l.devicePixelRatio, S.width = S.width / l.devicePixelRatio), E.get("scalePhotos") && (e = function() {
                                S.height -= S.height * t, S.width -= S.width * t
                            }, E.mw && S.width > E.mw && (t = (S.width - E.mw) / S.width, e()), E.mh && S.height > E.mh && (t = (S.height - E.mh) / S.height, e())), E.h && (S.style.marginTop = Math.max(E.mh - S.height, 0) / 2 + "px"), x[1] && (E.get("loop") || x[R + 1]) && (S.style.cursor = "pointer", d(S).bind("click." + D, function() {
                                _.next()
                            })), S.style.width = S.width + "px", S.style.height = S.height + "px", n(S)
                        }, 1)
                    }), S.src = t) : t && T.load(t, E.get("data"), function(t, e) {
                        o === J && n("error" === e ? X(Q, "Error").html(E.get("xhrError")) : d(this).contents())
                    })
                }()
        }
    }

    function wt() {
        g || (o = !1, y = d(l), g = X(Q).attr({
            id: j,
            class: !1 === d.support.opacity ? D + "IE" : "",
            role: "dialog",
            tabindex: "-1"
        }).hide(), c = X(Q, "Overlay").hide(), C = d([X(Q, "LoadingOverlay")[0], X(Q, "LoadingGraphic")[0]]), u = X(Q, "Wrapper"), f = X(Q, "Content").append(H = X(Q, "Title"), h = X(Q, "Current"), a = d('<button type="button"/>').attr({
            id: D + "Previous"
        }), r = d('<button type="button"/>').attr({
            id: D + "Next"
        }), t = d('<button type="button"/>').attr({
            id: D + "Slideshow"
        }), C), k = d('<button type="button"/>').attr({
            id: D + "Close"
        }), u.append(X(Q).append(X(Q, "TopLeft"), p = X(Q, "TopCenter"), X(Q, "TopRight")), X(Q, !1, "clear:left").append(m = X(Q, "MiddleLeft"), f, w = X(Q, "MiddleRight")), X(Q, !1, "clear:left").append(X(Q, "BottomLeft"), v = X(Q, "BottomCenter"), X(Q, "BottomRight"))).find("div div").css({
            float: "left"
        }), T = X(Q, !1, "position:absolute; width:9999px; visibility:hidden; display:none; max-width:none;"), W = r.add(a).add(h).add(t)), s.body && !g.parent().length && d(s.body).append(c, g.append(u, T))
    }
    d[j] || (d(wt), (_ = d.fn[j] = d[j] = function(e, t) {
        var i = this;
        if (e = e || {}, d.isFunction(i) && (i = d("<a/>"), e.open = !0), !i[0]) return i;

        function n(t) {
            1 < t.which || t.shiftKey || t.altKey || t.metaKey || t.ctrlKey || (t.preventDefault(), mt(this))
        }
        return wt(), g && (o || (o = !0, r.click(function() {
            _.next()
        }), a.click(function() {
            _.prev()
        }), k.click(function() {
            _.close()
        }), c.click(function() {
            E.get("overlayClose") && _.close()
        }), d(s).bind("keydown." + D, function(t) {
            var e = t.keyCode;
            K && E.get("escKey") && 27 === e && (t.preventDefault(), _.close()), K && E.get("arrowKey") && x[1] && !t.altKey && (37 === e ? (t.preventDefault(), a.click()) : 39 === e && (t.preventDefault(), r.click()))
        }), d.isFunction(d.fn.on) ? d(s).on("click." + D, "." + N, n) : d("." + N).live("click." + D, n)), 1) && (t && (e.onComplete = t), i.each(function() {
            var t = d.data(this, j) || {};
            d.data(this, j, d.extend(t, e))
        }).addClass(N), new Z(i[0], e).get("open") && mt(i[0])), i
    }).position = function(e, t) {
        var i, n, o, h = 0,
            r = 0,
            a = g.offset();

        function s() {
            p[0].style.width = v[0].style.width = f[0].style.width = parseInt(g[0].style.width, 10) - M + "px", f[0].style.height = m[0].style.height = w[0].style.height = parseInt(g[0].style.height, 10) - I + "px"
        }
        if (y.unbind("resize." + D), g.css({
                top: -9e4,
                left: -9e4
            }), n = y.scrollTop(), o = y.scrollLeft(), E.get("fixed") ? (a.top -= n, a.left -= o, g.css({
                position: "fixed"
            })) : (h = n, r = o, g.css({
                position: "absolute"
            })), !1 !== E.get("right") ? r += Math.max(y.width() - E.w - F - M - et(E.get("right"), "x"), 0) : !1 !== E.get("left") ? r += et(E.get("left"), "x") : r += Math.round(Math.max(y.width() - E.w - F - M, 0) / 2), !1 !== E.get("bottom") ? h += Math.max(Y() - E.h - L - I - et(E.get("bottom"), "y"), 0) : !1 !== E.get("top") ? h += et(E.get("top"), "y") : h += Math.round(Math.max(Y() - E.h - L - I, 0) / 2), g.css({
                top: a.top,
                left: a.left,
                visibility: "visible"
            }), u[0].style.width = u[0].style.height = "9999px", i = {
                width: E.w + F + M,
                height: E.h + L + I,
                top: h,
                left: r
            }, e) {
            var l = 0;
            d.each(i, function(t) {
                i[t] === V[t] || (l = e)
            }), e = l
        }
        V = i, e || g.css(i), g.dequeue().animate(i, {
            duration: e || 0,
            complete: function() {
                s(), P = !1, u[0].style.width = E.w + F + M + "px", u[0].style.height = E.h + L + I + "px", E.get("reposition") && setTimeout(function() {
                    y.bind("resize." + D, _.position)
                }, 1), d.isFunction(t) && t()
            },
            step: s
        })
    }, _.resize = function(t) {
        var e;
        K && ((t = t || {}).width && (E.w = et(t.width, "x") - F - M), t.innerWidth && (E.w = et(t.innerWidth, "x")), b.css({
            width: E.w
        }), t.height && (E.h = et(t.height, "y") - L - I), t.innerHeight && (E.h = et(t.innerHeight, "y")), t.innerHeight || t.height || (e = b.scrollTop(), b.css({
            height: "auto"
        }), E.h = b.height()), b.css({
            height: E.h
        }), e && b.scrollTop(e), _.position("none" === E.get("transition") ? 0 : E.get("speed")))
    }, _.prep = function(t) {
        if (K) {
            var e, o = "none" === E.get("transition") ? 0 : E.get("speed");
            b.remove(), (b = X(Q, "LoadedContent").append(t)).hide().appendTo(T.show()).css({
                width: (E.w = E.w || b.width(), E.w = E.mw && E.mw < E.w ? E.mw : E.w, E.w),
                overflow: E.get("scrolling") ? "auto" : "hidden"
            }).css({
                height: (E.h = E.h || b.height(), E.h = E.mh && E.mh < E.h ? E.mh : E.h, E.h)
            }).prependTo(f), T.hide(), d(S).css({
                float: "none"
            }), ht(E.get("className")), e = function() {
                var t, e, i = x.length;

                function n() {
                    !1 === d.support.opacity && g[0].style.removeAttribute("filter")
                }
                K && (e = function() {
                    clearTimeout(O), C.hide(), rt(q), E.get("onComplete")
                }, H.html(E.get("title")).show(), b.show(), 1 < i ? ("string" == typeof E.get("current") && h.html(E.get("current").replace("{current}", R + 1).replace("{total}", i)).show(), r[E.get("loop") || R < i - 1 ? "show" : "hide"]().html(E.get("next")), a[E.get("loop") || R ? "show" : "hide"]().html(E.get("previous")), dt(), E.get("preloading") && d.each([tt(-1), tt(1)], function() {
                    var t = x[this],
                        e = new Z(t, d.data(t, j)),
                        i = e.get("href");
                    i && it(e, i) && (i = nt(e, i), s.createElement("img").src = i)
                })) : W.hide(), E.get("iframe") ? (t = E.get("createIframe"), E.get("scrolling") || (t.scrolling = "no"), d(t).attr({
                    src: E.get("href"),
                    class: D + "Iframe"
                }).one("load", e).appendTo(b), G.one($, function() {
                    t.src = "//about:blank"
                }), E.get("fastIframe") && d(t).trigger("load")) : e(), "fade" === E.get("transition") ? g.fadeTo(o, 1, n) : n())
            }, "fade" === E.get("transition") ? g.fadeTo(o, 0, function() {
                _.position(0, e)
            }) : _.position(o, e)
        }
    }, _.next = function() {
        !P && x[1] && (E.get("loop") || x[R + 1]) && (R = tt(1), mt(x[R]))
    }, _.prev = function() {
        !P && x[1] && (E.get("loop") || R) && (R = tt(-1), mt(x[R]))
    }, _.close = function() {
        K && !B && (K = !(B = !0), rt(e), E.get("onCleanup"), y.unbind("." + D), c.fadeTo(E.get("fadeOut") || 0, 0), g.stop().fadeTo(E.get("fadeOut") || 0, 0, function() {
            g.hide(), c.hide(), rt($), b.remove(), setTimeout(function() {
                B = !1, rt(U), E.get("onClosed")
            }, 1)
        }))
    }, _.remove = function() {
        g && (g.stop(), d[j].close(), g.stop(!1, !0).remove(), c.remove(), B = !1, g = null, d("." + N).removeData(j).removeClass(N), d(s).unbind("click." + D).unbind("keydown." + D))
    }, _.element = function() {
        return d(E.el)
    }, _.settings = n)
}(jQuery, document, window);

! function(t) {
    function e() {}

    function i(t) {
        function i(e) {
            e.prototype.option || (e.prototype.option = function(e) {
                t.isPlainObject(e) && (this.options = t.extend(!0, this.options, e))
            })
        }

        function n(e, i) {
            t.fn[e] = function(n) {
                if ("string" == typeof n) {
                    for (var s = o.call(arguments, 1), a = 0, u = this.length; u > a; a++) {
                        var p = this[a],
                            h = t.data(p, e);
                        if (h)
                            if (t.isFunction(h[n]) && "_" !== n.charAt(0)) {
                                var f = h[n].apply(h, s);
                                if (void 0 !== f) return f
                            } else r("no such method '" + n + "' for " + e + " instance");
                        else r("cannot call methods on " + e + " prior to initialization; attempted to call '" + n + "'")
                    }
                    return this
                }
                return this.each(function() {
                    var o = t.data(this, e);
                    o ? (o.option(n), o._init()) : (o = new i(this, n), t.data(this, e, o))
                })
            }
        }
        if (t) {
            var r = "undefined" == typeof console ? e : function(t) {
                console.error(t)
            };
            return t.bridget = function(t, e) {
                i(e), n(t, e)
            }, t.bridget
        }
    }
    var o = Array.prototype.slice;
    "function" == typeof define && define.amd ? define("jquery-bridget/jquery.bridget", ["jquery"], i) : i(t.jQuery)
}(window),
function(t) {
    function e(e) {
        var i = t.event;
        return i.target = i.target || i.srcElement || e, i
    }
    var i = document.documentElement,
        o = function() {};
    i.addEventListener ? o = function(t, e, i) {
        t.addEventListener(e, i, !1)
    } : i.attachEvent && (o = function(t, i, o) {
        t[i + o] = o.handleEvent ? function() {
            var i = e(t);
            o.handleEvent.call(o, i)
        } : function() {
            var i = e(t);
            o.call(t, i)
        }, t.attachEvent("on" + i, t[i + o])
    });
    var n = function() {};
    i.removeEventListener ? n = function(t, e, i) {
        t.removeEventListener(e, i, !1)
    } : i.detachEvent && (n = function(t, e, i) {
        t.detachEvent("on" + e, t[e + i]);
        try {
            delete t[e + i]
        } catch (o) {
            t[e + i] = void 0
        }
    });
    var r = {
        bind: o,
        unbind: n
    };
    "function" == typeof define && define.amd ? define("eventie/eventie", r) : "object" == typeof exports ? module.exports = r : t.eventie = r
}(this),
function(t) {
    function e(t) {
        "function" == typeof t && (e.isReady ? t() : r.push(t))
    }

    function i(t) {
        var i = "readystatechange" === t.type && "complete" !== n.readyState;
        if (!e.isReady && !i) {
            e.isReady = !0;
            for (var o = 0, s = r.length; s > o; o++) {
                var a = r[o];
                a()
            }
        }
    }

    function o(o) {
        return o.bind(n, "DOMContentLoaded", i), o.bind(n, "readystatechange", i), o.bind(t, "load", i), e
    }
    var n = t.document,
        r = [];
    e.isReady = !1, "function" == typeof define && define.amd ? (e.isReady = "function" == typeof requirejs, define("doc-ready/doc-ready", ["eventie/eventie"], o)) : t.docReady = o(t.eventie)
}(this),
function() {
    function t() {}

    function e(t, e) {
        for (var i = t.length; i--;)
            if (t[i].listener === e) return i;
        return -1
    }

    function i(t) {
        return function() {
            return this[t].apply(this, arguments)
        }
    }
    var o = t.prototype,
        n = this,
        r = n.EventEmitter;
    o.getListeners = function(t) {
        var e, i, o = this._getEvents();
        if (t instanceof RegExp) {
            e = {};
            for (i in o) o.hasOwnProperty(i) && t.test(i) && (e[i] = o[i])
        } else e = o[t] || (o[t] = []);
        return e
    }, o.flattenListeners = function(t) {
        var e, i = [];
        for (e = 0; t.length > e; e += 1) i.push(t[e].listener);
        return i
    }, o.getListenersAsObject = function(t) {
        var e, i = this.getListeners(t);
        return i instanceof Array && (e = {}, e[t] = i), e || i
    }, o.addListener = function(t, i) {
        var o, n = this.getListenersAsObject(t),
            r = "object" == typeof i;
        for (o in n) n.hasOwnProperty(o) && -1 === e(n[o], i) && n[o].push(r ? i : {
            listener: i,
            once: !1
        });
        return this
    }, o.on = i("addListener"), o.addOnceListener = function(t, e) {
        return this.addListener(t, {
            listener: e,
            once: !0
        })
    }, o.once = i("addOnceListener"), o.defineEvent = function(t) {
        return this.getListeners(t), this
    }, o.defineEvents = function(t) {
        for (var e = 0; t.length > e; e += 1) this.defineEvent(t[e]);
        return this
    }, o.removeListener = function(t, i) {
        var o, n, r = this.getListenersAsObject(t);
        for (n in r) r.hasOwnProperty(n) && (o = e(r[n], i), -1 !== o && r[n].splice(o, 1));
        return this
    }, o.off = i("removeListener"), o.addListeners = function(t, e) {
        return this.manipulateListeners(!1, t, e)
    }, o.removeListeners = function(t, e) {
        return this.manipulateListeners(!0, t, e)
    }, o.manipulateListeners = function(t, e, i) {
        var o, n, r = t ? this.removeListener : this.addListener,
            s = t ? this.removeListeners : this.addListeners;
        if ("object" != typeof e || e instanceof RegExp)
            for (o = i.length; o--;) r.call(this, e, i[o]);
        else
            for (o in e) e.hasOwnProperty(o) && (n = e[o]) && ("function" == typeof n ? r.call(this, o, n) : s.call(this, o, n));
        return this
    }, o.removeEvent = function(t) {
        var e, i = typeof t,
            o = this._getEvents();
        if ("string" === i) delete o[t];
        else if (t instanceof RegExp)
            for (e in o) o.hasOwnProperty(e) && t.test(e) && delete o[e];
        else delete this._events;
        return this
    }, o.removeAllListeners = i("removeEvent"), o.emitEvent = function(t, e) {
        var i, o, n, r, s = this.getListenersAsObject(t);
        for (n in s)
            if (s.hasOwnProperty(n))
                for (o = s[n].length; o--;) i = s[n][o], i.once === !0 && this.removeListener(t, i.listener), r = i.listener.apply(this, e || []), r === this._getOnceReturnValue() && this.removeListener(t, i.listener);
        return this
    }, o.trigger = i("emitEvent"), o.emit = function(t) {
        var e = Array.prototype.slice.call(arguments, 1);
        return this.emitEvent(t, e)
    }, o.setOnceReturnValue = function(t) {
        return this._onceReturnValue = t, this
    }, o._getOnceReturnValue = function() {
        return this.hasOwnProperty("_onceReturnValue") ? this._onceReturnValue : !0
    }, o._getEvents = function() {
        return this._events || (this._events = {})
    }, t.noConflict = function() {
        return n.EventEmitter = r, t
    }, "function" == typeof define && define.amd ? define("eventEmitter/EventEmitter", [], function() {
        return t
    }) : "object" == typeof module && module.exports ? module.exports = t : this.EventEmitter = t
}.call(this),
    function(t) {
        function e(t) {
            if (t) {
                if ("string" == typeof o[t]) return t;
                t = t.charAt(0).toUpperCase() + t.slice(1);
                for (var e, n = 0, r = i.length; r > n; n++)
                    if (e = i[n] + t, "string" == typeof o[e]) return e
            }
        }
        var i = "Webkit Moz ms Ms O".split(" "),
            o = document.documentElement.style;
        "function" == typeof define && define.amd ? define("get-style-property/get-style-property", [], function() {
            return e
        }) : "object" == typeof exports ? module.exports = e : t.getStyleProperty = e
    }(window),
    function(t) {
        function e(t) {
            var e = parseFloat(t),
                i = -1 === t.indexOf("%") && !isNaN(e);
            return i && e
        }

        function i() {
            for (var t = {
                    width: 0,
                    height: 0,
                    innerWidth: 0,
                    innerHeight: 0,
                    outerWidth: 0,
                    outerHeight: 0
                }, e = 0, i = s.length; i > e; e++) {
                var o = s[e];
                t[o] = 0
            }
            return t
        }

        function o(t) {
            function o(t) {
                if ("string" == typeof t && (t = document.querySelector(t)), t && "object" == typeof t && t.nodeType) {
                    var o = r(t);
                    if ("none" === o.display) return i();
                    var n = {};
                    n.width = t.offsetWidth, n.height = t.offsetHeight;
                    for (var h = n.isBorderBox = !(!p || !o[p] || "border-box" !== o[p]), f = 0, l = s.length; l > f; f++) {
                        var c = s[f],
                            d = o[c];
                        d = a(t, d);
                        var y = parseFloat(d);
                        n[c] = isNaN(y) ? 0 : y
                    }
                    var m = n.paddingLeft + n.paddingRight,
                        g = n.paddingTop + n.paddingBottom,
                        v = n.marginLeft + n.marginRight,
                        _ = n.marginTop + n.marginBottom,
                        I = n.borderLeftWidth + n.borderRightWidth,
                        L = n.borderTopWidth + n.borderBottomWidth,
                        z = h && u,
                        S = e(o.width);
                    S !== !1 && (n.width = S + (z ? 0 : m + I));
                    var b = e(o.height);
                    return b !== !1 && (n.height = b + (z ? 0 : g + L)), n.innerWidth = n.width - (m + I), n.innerHeight = n.height - (g + L), n.outerWidth = n.width + v, n.outerHeight = n.height + _, n
                }
            }

            function a(t, e) {
                if (n || -1 === e.indexOf("%")) return e;
                var i = t.style,
                    o = i.left,
                    r = t.runtimeStyle,
                    s = r && r.left;
                return s && (r.left = t.currentStyle.left), i.left = e, e = i.pixelLeft, i.left = o, s && (r.left = s), e
            }
            var u, p = t("boxSizing");
            return function() {
                if (p) {
                    var t = document.createElement("div");
                    t.style.width = "200px", t.style.padding = "1px 2px 3px 4px", t.style.borderStyle = "solid", t.style.borderWidth = "1px 2px 3px 4px", t.style[p] = "border-box";
                    var i = document.body || document.documentElement;
                    i.appendChild(t);
                    var o = r(t);
                    u = 200 === e(o.width), i.removeChild(t)
                }
            }(), o
        }
        var n = t.getComputedStyle,
            r = n ? function(t) {
                return n(t, null)
            } : function(t) {
                return t.currentStyle
            },
            s = ["paddingLeft", "paddingRight", "paddingTop", "paddingBottom", "marginLeft", "marginRight", "marginTop", "marginBottom", "borderLeftWidth", "borderRightWidth", "borderTopWidth", "borderBottomWidth"];
        "function" == typeof define && define.amd ? define("get-size/get-size", ["get-style-property/get-style-property"], o) : "object" == typeof exports ? module.exports = o(require("get-style-property")) : t.getSize = o(t.getStyleProperty)
    }(window),
    function(t, e) {
        function i(t, e) {
            return t[a](e)
        }

        function o(t) {
            if (!t.parentNode) {
                var e = document.createDocumentFragment();
                e.appendChild(t)
            }
        }

        function n(t, e) {
            o(t);
            for (var i = t.parentNode.querySelectorAll(e), n = 0, r = i.length; r > n; n++)
                if (i[n] === t) return !0;
            return !1
        }

        function r(t, e) {
            return o(t), i(t, e)
        }
        var s, a = function() {
            if (e.matchesSelector) return "matchesSelector";
            for (var t = ["webkit", "moz", "ms", "o"], i = 0, o = t.length; o > i; i++) {
                var n = t[i],
                    r = n + "MatchesSelector";
                if (e[r]) return r
            }
        }();
        if (a) {
            var u = document.createElement("div"),
                p = i(u, "div");
            s = p ? i : r
        } else s = n;
        "function" == typeof define && define.amd ? define("matches-selector/matches-selector", [], function() {
            return s
        }) : window.matchesSelector = s
    }(this, Element.prototype),
    function(t) {
        function e(t, e) {
            for (var i in e) t[i] = e[i];
            return t
        }

        function i(t) {
            for (var e in t) return !1;
            return e = null, !0
        }

        function o(t) {
            return t.replace(/([A-Z])/g, function(t) {
                return "-" + t.toLowerCase()
            })
        }

        function n(t, n, r) {
            function a(t, e) {
                t && (this.element = t, this.layout = e, this.position = {
                    x: 0,
                    y: 0
                }, this._create())
            }
            var u = r("transition"),
                p = r("transform"),
                h = u && p,
                f = !!r("perspective"),
                l = {
                    WebkitTransition: "webkitTransitionEnd",
                    MozTransition: "transitionend",
                    OTransition: "otransitionend",
                    transition: "transitionend"
                }[u],
                c = ["transform", "transition", "transitionDuration", "transitionProperty"],
                d = function() {
                    for (var t = {}, e = 0, i = c.length; i > e; e++) {
                        var o = c[e],
                            n = r(o);
                        n && n !== o && (t[o] = n)
                    }
                    return t
                }();
            e(a.prototype, t.prototype), a.prototype._create = function() {
                this._transn = {
                    ingProperties: {},
                    clean: {},
                    onEnd: {}
                }, this.css({
                    position: "absolute"
                })
            }, a.prototype.handleEvent = function(t) {
                var e = "on" + t.type;
                this[e] && this[e](t)
            }, a.prototype.getSize = function() {
                this.size = n(this.element)
            }, a.prototype.css = function(t) {
                var e = this.element.style;
                for (var i in t) {
                    var o = d[i] || i;
                    e[o] = t[i]
                }
            }, a.prototype.getPosition = function() {
                var t = s(this.element),
                    e = this.layout.options,
                    i = e.isOriginLeft,
                    o = e.isOriginTop,
                    n = parseInt(t[i ? "left" : "right"], 10),
                    r = parseInt(t[o ? "top" : "bottom"], 10);
                n = isNaN(n) ? 0 : n, r = isNaN(r) ? 0 : r;
                var a = this.layout.size;
                n -= i ? a.paddingLeft : a.paddingRight, r -= o ? a.paddingTop : a.paddingBottom, this.position.x = n, this.position.y = r
            }, a.prototype.layoutPosition = function() {
                var t = this.layout.size,
                    e = this.layout.options,
                    i = {};
                e.isOriginLeft ? (i.left = this.position.x + t.paddingLeft + "px", i.right = "") : (i.right = this.position.x + t.paddingRight + "px", i.left = ""), e.isOriginTop ? (i.top = this.position.y + t.paddingTop + "px", i.bottom = "") : (i.bottom = this.position.y + t.paddingBottom + "px", i.top = ""), this.css(i), this.emitEvent("layout", [this])
            };
            var y = f ? function(t, e) {
                return "translate3d(" + t + "px, " + e + "px, 0)"
            } : function(t, e) {
                return "translate(" + t + "px, " + e + "px)"
            };
            a.prototype._transitionTo = function(t, e) {
                this.getPosition();
                var i = this.position.x,
                    o = this.position.y,
                    n = parseInt(t, 10),
                    r = parseInt(e, 10),
                    s = n === this.position.x && r === this.position.y;
                if (this.setPosition(t, e), s && !this.isTransitioning) return void this.layoutPosition();
                var a = t - i,
                    u = e - o,
                    p = {},
                    h = this.layout.options;
                a = h.isOriginLeft ? a : -a, u = h.isOriginTop ? u : -u, p.transform = y(a, u), this.transition({
                    to: p,
                    onTransitionEnd: {
                        transform: this.layoutPosition
                    },
                    isCleaning: !0
                })
            }, a.prototype.goTo = function(t, e) {
                this.setPosition(t, e), this.layoutPosition()
            }, a.prototype.moveTo = h ? a.prototype._transitionTo : a.prototype.goTo, a.prototype.setPosition = function(t, e) {
                this.position.x = parseInt(t, 10), this.position.y = parseInt(e, 10)
            }, a.prototype._nonTransition = function(t) {
                this.css(t.to), t.isCleaning && this._removeStyles(t.to);
                for (var e in t.onTransitionEnd) t.onTransitionEnd[e].call(this)
            }, a.prototype._transition = function(t) {
                if (!parseFloat(this.layout.options.transitionDuration)) return void this._nonTransition(t);
                var e = this._transn;
                for (var i in t.onTransitionEnd) e.onEnd[i] = t.onTransitionEnd[i];
                for (i in t.to) e.ingProperties[i] = !0, t.isCleaning && (e.clean[i] = !0);
                if (t.from) {
                    this.css(t.from);
                    var o = this.element.offsetHeight;
                    o = null
                }
                this.enableTransition(t.to), this.css(t.to), this.isTransitioning = !0
            };
            var m = p && o(p) + ",opacity";
            a.prototype.enableTransition = function() {
                this.isTransitioning || (this.css({
                    transitionProperty: m,
                    transitionDuration: this.layout.options.transitionDuration
                }), this.element.addEventListener(l, this, !1))
            }, a.prototype.transition = a.prototype[u ? "_transition" : "_nonTransition"], a.prototype.onwebkitTransitionEnd = function(t) {
                this.ontransitionend(t)
            }, a.prototype.onotransitionend = function(t) {
                this.ontransitionend(t)
            };
            var g = {
                "-webkit-transform": "transform",
                "-moz-transform": "transform",
                "-o-transform": "transform"
            };
            a.prototype.ontransitionend = function(t) {
                if (t.target === this.element) {
                    var e = this._transn,
                        o = g[t.propertyName] || t.propertyName;
                    if (delete e.ingProperties[o], i(e.ingProperties) && this.disableTransition(), o in e.clean && (this.element.style[t.propertyName] = "", delete e.clean[o]), o in e.onEnd) {
                        var n = e.onEnd[o];
                        n.call(this), delete e.onEnd[o]
                    }
                    this.emitEvent("transitionEnd", [this])
                }
            }, a.prototype.disableTransition = function() {
                this.removeTransitionStyles(), this.element.removeEventListener(l, this, !1), this.isTransitioning = !1
            }, a.prototype._removeStyles = function(t) {
                var e = {};
                for (var i in t) e[i] = "";
                this.css(e)
            };
            var v = {
                transitionProperty: "",
                transitionDuration: ""
            };
            return a.prototype.removeTransitionStyles = function() {
                this.css(v)
            }, a.prototype.removeElem = function() {
                this.element.parentNode.removeChild(this.element), this.emitEvent("remove", [this])
            }, a.prototype.remove = function() {
                if (!u || !parseFloat(this.layout.options.transitionDuration)) return void this.removeElem();
                var t = this;
                this.on("transitionEnd", function() {
                    return t.removeElem(), !0
                }), this.hide()
            }, a.prototype.reveal = function() {
                delete this.isHidden, this.css({
                    display: ""
                });
                var t = this.layout.options;
                this.transition({
                    from: t.hiddenStyle,
                    to: t.visibleStyle,
                    isCleaning: !0
                })
            }, a.prototype.hide = function() {
                this.isHidden = !0, this.css({
                    display: ""
                });
                var t = this.layout.options;
                this.transition({
                    from: t.visibleStyle,
                    to: t.hiddenStyle,
                    isCleaning: !0,
                    onTransitionEnd: {
                        opacity: function() {
                            this.isHidden && this.css({
                                display: "none"
                            })
                        }
                    }
                })
            }, a.prototype.destroy = function() {
                this.css({
                    position: "",
                    left: "",
                    right: "",
                    top: "",
                    bottom: "",
                    transition: "",
                    transform: ""
                })
            }, a
        }
        var r = t.getComputedStyle,
            s = r ? function(t) {
                return r(t, null)
            } : function(t) {
                return t.currentStyle
            };
        "function" == typeof define && define.amd ? define("outlayer/item", ["eventEmitter/EventEmitter", "get-size/get-size", "get-style-property/get-style-property"], n) : (t.Outlayer = {}, t.Outlayer.Item = n(t.EventEmitter, t.getSize, t.getStyleProperty))
    }(window),
    function(t) {
        function e(t, e) {
            for (var i in e) t[i] = e[i];
            return t
        }

        function i(t) {
            return "[object Array]" === f.call(t)
        }

        function o(t) {
            var e = [];
            if (i(t)) e = t;
            else if (t && "number" == typeof t.length)
                for (var o = 0, n = t.length; n > o; o++) e.push(t[o]);
            else e.push(t);
            return e
        }

        function n(t, e) {
            var i = c(e, t); - 1 !== i && e.splice(i, 1)
        }

        function r(t) {
            return t.replace(/(.)([A-Z])/g, function(t, e, i) {
                return e + "-" + i
            }).toLowerCase()
        }

        function s(i, s, f, c, d, y) {
            function m(t, i) {
                if ("string" == typeof t && (t = a.querySelector(t)), !t || !l(t)) return void(u && u.error("Bad " + this.constructor.namespace + " element: " + t));
                this.element = t, this.options = e({}, this.constructor.defaults), this.option(i);
                var o = ++g;
                this.element.outlayerGUID = o, v[o] = this, this._create(), this.options.isInitLayout && this.layout()
            }
            var g = 0,
                v = {};
            return m.namespace = "outlayer", m.Item = y, m.defaults = {
                containerStyle: {
                    position: "relative"
                },
                isInitLayout: !0,
                isOriginLeft: !0,
                isOriginTop: !0,
                isResizeBound: !0,
                isResizingContainer: !0,
                transitionDuration: "0.4s",
                hiddenStyle: {
                    opacity: 0,
                    transform: "scale(0.001)"
                },
                visibleStyle: {
                    opacity: 1,
                    transform: "scale(1)"
                }
            }, e(m.prototype, f.prototype), m.prototype.option = function(t) {
                e(this.options, t)
            }, m.prototype._create = function() {
                this.reloadItems(), this.stamps = [], this.stamp(this.options.stamp), e(this.element.style, this.options.containerStyle), this.options.isResizeBound && this.bindResize()
            }, m.prototype.reloadItems = function() {
                this.items = this._itemize(this.element.children)
            }, m.prototype._itemize = function(t) {
                for (var e = this._filterFindItemElements(t), i = this.constructor.Item, o = [], n = 0, r = e.length; r > n; n++) {
                    var s = e[n],
                        a = new i(s, this);
                    o.push(a)
                }
                return o
            }, m.prototype._filterFindItemElements = function(t) {
                t = o(t);
                for (var e = this.options.itemSelector, i = [], n = 0, r = t.length; r > n; n++) {
                    var s = t[n];
                    if (l(s))
                        if (e) {
                            d(s, e) && i.push(s);
                            for (var a = s.querySelectorAll(e), u = 0, p = a.length; p > u; u++) i.push(a[u])
                        } else i.push(s)
                }
                return i
            }, m.prototype.getItemElements = function() {
                for (var t = [], e = 0, i = this.items.length; i > e; e++) t.push(this.items[e].element);
                return t
            }, m.prototype.layout = function() {
                this._resetLayout(), this._manageStamps();
                var t = void 0 !== this.options.isLayoutInstant ? this.options.isLayoutInstant : !this._isLayoutInited;
                this.layoutItems(this.items, t), this._isLayoutInited = !0
            }, m.prototype._init = m.prototype.layout, m.prototype._resetLayout = function() {
                this.getSize()
            }, m.prototype.getSize = function() {
                this.size = c(this.element)
            }, m.prototype._getMeasurement = function(t, e) {
                var i, o = this.options[t];
                o ? ("string" == typeof o ? i = this.element.querySelector(o) : l(o) && (i = o), this[t] = i ? c(i)[e] : o) : this[t] = 0
            }, m.prototype.layoutItems = function(t, e) {
                t = this._getItemsForLayout(t), this._layoutItems(t, e), this._postLayout()
            }, m.prototype._getItemsForLayout = function(t) {
                for (var e = [], i = 0, o = t.length; o > i; i++) {
                    var n = t[i];
                    n.isIgnored || e.push(n)
                }
                return e
            }, m.prototype._layoutItems = function(t, e) {
                function i() {
                    o.emitEvent("layoutComplete", [o, t])
                }
                var o = this;
                if (!t || !t.length) return void i();
                this._itemsOn(t, "layout", i);
                for (var n = [], r = 0, s = t.length; s > r; r++) {
                    var a = t[r],
                        u = this._getItemLayoutPosition(a);
                    u.item = a, u.isInstant = e || a.isLayoutInstant, n.push(u)
                }
                this._processLayoutQueue(n)
            }, m.prototype._getItemLayoutPosition = function() {
                return {
                    x: 0,
                    y: 0
                }
            }, m.prototype._processLayoutQueue = function(t) {
                for (var e = 0, i = t.length; i > e; e++) {
                    var o = t[e];
                    this._positionItem(o.item, o.x, o.y, o.isInstant)
                }
            }, m.prototype._positionItem = function(t, e, i, o) {
                o ? t.goTo(e, i) : t.moveTo(e, i)
            }, m.prototype._postLayout = function() {
                this.resizeContainer()
            }, m.prototype.resizeContainer = function() {
                if (this.options.isResizingContainer) {
                    var t = this._getContainerSize();
                    t && (this._setContainerMeasure(t.width, !0), this._setContainerMeasure(t.height, !1))
                }
            }, m.prototype._getContainerSize = h, m.prototype._setContainerMeasure = function(t, e) {
                if (void 0 !== t) {
                    var i = this.size;
                    i.isBorderBox && (t += e ? i.paddingLeft + i.paddingRight + i.borderLeftWidth + i.borderRightWidth : i.paddingBottom + i.paddingTop + i.borderTopWidth + i.borderBottomWidth), t = Math.max(t, 0), this.element.style[e ? "width" : "height"] = t + "px"
                }
            }, m.prototype._itemsOn = function(t, e, i) {
                function o() {
                    return n++, n === r && i.call(s), !0
                }
                for (var n = 0, r = t.length, s = this, a = 0, u = t.length; u > a; a++) {
                    var p = t[a];
                    p.on(e, o)
                }
            }, m.prototype.ignore = function(t) {
                var e = this.getItem(t);
                e && (e.isIgnored = !0)
            }, m.prototype.unignore = function(t) {
                var e = this.getItem(t);
                e && delete e.isIgnored
            }, m.prototype.stamp = function(t) {
                if (t = this._find(t)) {
                    this.stamps = this.stamps.concat(t);
                    for (var e = 0, i = t.length; i > e; e++) {
                        var o = t[e];
                        this.ignore(o)
                    }
                }
            }, m.prototype.unstamp = function(t) {
                if (t = this._find(t))
                    for (var e = 0, i = t.length; i > e; e++) {
                        var o = t[e];
                        n(o, this.stamps), this.unignore(o)
                    }
            }, m.prototype._find = function(t) {
                return t ? ("string" == typeof t && (t = this.element.querySelectorAll(t)), t = o(t)) : void 0
            }, m.prototype._manageStamps = function() {
                if (this.stamps && this.stamps.length) {
                    this._getBoundingRect();
                    for (var t = 0, e = this.stamps.length; e > t; t++) {
                        var i = this.stamps[t];
                        this._manageStamp(i)
                    }
                }
            }, m.prototype._getBoundingRect = function() {
                var t = this.element.getBoundingClientRect(),
                    e = this.size;
                this._boundingRect = {
                    left: t.left + e.paddingLeft + e.borderLeftWidth,
                    top: t.top + e.paddingTop + e.borderTopWidth,
                    right: t.right - (e.paddingRight + e.borderRightWidth),
                    bottom: t.bottom - (e.paddingBottom + e.borderBottomWidth)
                }
            }, m.prototype._manageStamp = h, m.prototype._getElementOffset = function(t) {
                var e = t.getBoundingClientRect(),
                    i = this._boundingRect,
                    o = c(t),
                    n = {
                        left: e.left - i.left - o.marginLeft,
                        top: e.top - i.top - o.marginTop,
                        right: i.right - e.right - o.marginRight,
                        bottom: i.bottom - e.bottom - o.marginBottom
                    };
                return n
            }, m.prototype.handleEvent = function(t) {
                var e = "on" + t.type;
                this[e] && this[e](t)
            }, m.prototype.bindResize = function() {
                this.isResizeBound || (i.bind(t, "resize", this), this.isResizeBound = !0)
            }, m.prototype.unbindResize = function() {
                this.isResizeBound && i.unbind(t, "resize", this), this.isResizeBound = !1
            }, m.prototype.onresize = function() {
                function t() {
                    e.resize(), delete e.resizeTimeout
                }
                this.resizeTimeout && clearTimeout(this.resizeTimeout);
                var e = this;
                this.resizeTimeout = setTimeout(t, 100)
            }, m.prototype.resize = function() {
                this.isResizeBound && this.needsResizeLayout() && this.layout()
            }, m.prototype.needsResizeLayout = function() {
                var t = c(this.element),
                    e = this.size && t;
                return e && t.innerWidth !== this.size.innerWidth
            }, m.prototype.addItems = function(t) {
                var e = this._itemize(t);
                return e.length && (this.items = this.items.concat(e)), e
            }, m.prototype.appended = function(t) {
                var e = this.addItems(t);
                e.length && (this.layoutItems(e, !0), this.reveal(e))
            }, m.prototype.prepended = function(t) {
                var e = this._itemize(t);
                if (e.length) {
                    var i = this.items.slice(0);
                    this.items = e.concat(i), this._resetLayout(), this._manageStamps(), this.layoutItems(e, !0), this.reveal(e), this.layoutItems(i)
                }
            }, m.prototype.reveal = function(t) {
                var e = t && t.length;
                if (e)
                    for (var i = 0; e > i; i++) {
                        var o = t[i];
                        o.reveal()
                    }
            }, m.prototype.hide = function(t) {
                var e = t && t.length;
                if (e)
                    for (var i = 0; e > i; i++) {
                        var o = t[i];
                        o.hide()
                    }
            }, m.prototype.getItem = function(t) {
                for (var e = 0, i = this.items.length; i > e; e++) {
                    var o = this.items[e];
                    if (o.element === t) return o
                }
            }, m.prototype.getItems = function(t) {
                if (t && t.length) {
                    for (var e = [], i = 0, o = t.length; o > i; i++) {
                        var n = t[i],
                            r = this.getItem(n);
                        r && e.push(r)
                    }
                    return e
                }
            }, m.prototype.remove = function(t) {
                t = o(t);
                var e = this.getItems(t);
                if (e && e.length) {
                    this._itemsOn(e, "remove", function() {
                        this.emitEvent("removeComplete", [this, e])
                    });
                    for (var i = 0, r = e.length; r > i; i++) {
                        var s = e[i];
                        s.remove(), n(s, this.items)
                    }
                }
            }, m.prototype.destroy = function() {
                var t = this.element.style;
                t.height = "", t.position = "", t.width = "";
                for (var e = 0, i = this.items.length; i > e; e++) {
                    var o = this.items[e];
                    o.destroy()
                }
                this.unbindResize(), delete this.element.outlayerGUID, p && p.removeData(this.element, this.constructor.namespace)
            }, m.data = function(t) {
                var e = t && t.outlayerGUID;
                return e && v[e]
            }, m.create = function(t, i) {
                function o() {
                    m.apply(this, arguments)
                }
                return Object.create ? o.prototype = Object.create(m.prototype) : e(o.prototype, m.prototype), o.prototype.constructor = o, o.defaults = e({}, m.defaults), e(o.defaults, i), o.prototype.settings = {}, o.namespace = t, o.data = m.data, o.Item = function() {
                    y.apply(this, arguments)
                }, o.Item.prototype = new y, s(function() {
                    for (var e = r(t), i = a.querySelectorAll(".js-" + e), n = "data-" + e + "-options", s = 0, h = i.length; h > s; s++) {
                        var f, l = i[s],
                            c = l.getAttribute(n);
                        try {
                            f = c && JSON.parse(c)
                        } catch (d) {
                            u && u.error("Error parsing " + n + " on " + l.nodeName.toLowerCase() + (l.id ? "#" + l.id : "") + ": " + d);
                            continue
                        }
                        var y = new o(l, f);
                        p && p.data(l, t, y)
                    }
                }), p && p.bridget && p.bridget(t, o), o
            }, m.Item = y, m
        }
        var a = t.document,
            u = t.console,
            p = t.jQuery,
            h = function() {},
            f = Object.prototype.toString,
            l = "object" == typeof HTMLElement ? function(t) {
                return t instanceof HTMLElement
            } : function(t) {
                return t && "object" == typeof t && 1 === t.nodeType && "string" == typeof t.nodeName
            },
            c = Array.prototype.indexOf ? function(t, e) {
                return t.indexOf(e)
            } : function(t, e) {
                for (var i = 0, o = t.length; o > i; i++)
                    if (t[i] === e) return i;
                return -1
            };
        "function" == typeof define && define.amd ? define("outlayer/outlayer", ["eventie/eventie", "doc-ready/doc-ready", "eventEmitter/EventEmitter", "get-size/get-size", "matches-selector/matches-selector", "./item"], s) : t.Outlayer = s(t.eventie, t.docReady, t.EventEmitter, t.getSize, t.matchesSelector, t.Outlayer.Item)
    }(window),
    function(t) {
        function e(t) {
            function e() {
                t.Item.apply(this, arguments)
            }
            return e.prototype = new t.Item, e.prototype._create = function() {
                this.id = this.layout.itemGUID++, t.Item.prototype._create.call(this), this.sortData = {}
            }, e.prototype.updateSortData = function() {
                if (!this.isIgnored) {
                    this.sortData.id = this.id, this.sortData["original-order"] = this.id, this.sortData.random = Math.random();
                    var t = this.layout.options.getSortData,
                        e = this.layout._sorters;
                    for (var i in t) {
                        var o = e[i];
                        this.sortData[i] = o(this.element, this)
                    }
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/item", ["outlayer/outlayer"], e) : (t.Isotope = t.Isotope || {}, t.Isotope.Item = e(t.Outlayer))
    }(window),
    function(t) {
        function e(t, e) {
            function i(t) {
                this.isotope = t, t && (this.options = t.options[this.namespace], this.element = t.element, this.items = t.filteredItems, this.size = t.size)
            }
            return function() {
                function t(t) {
                    return function() {
                        return e.prototype[t].apply(this.isotope, arguments)
                    }
                }
                for (var o = ["_resetLayout", "_getItemLayoutPosition", "_manageStamp", "_getContainerSize", "_getElementOffset", "needsResizeLayout"], n = 0, r = o.length; r > n; n++) {
                    var s = o[n];
                    i.prototype[s] = t(s)
                }
            }(), i.prototype.needsVerticalResizeLayout = function() {
                var e = t(this.isotope.element),
                    i = this.isotope.size && e;
                return i && e.innerHeight !== this.isotope.size.innerHeight
            }, i.prototype._getMeasurement = function() {
                this.isotope._getMeasurement.apply(this, arguments)
            }, i.prototype.getColumnWidth = function() {
                this.getSegmentSize("column", "Width")
            }, i.prototype.getRowHeight = function() {
                this.getSegmentSize("row", "Height")
            }, i.prototype.getSegmentSize = function(t, e) {
                var i = t + e,
                    o = "outer" + e;
                if (this._getMeasurement(i, o), !this[i]) {
                    var n = this.getFirstItemSize();
                    this[i] = n && n[o] || this.isotope.size["inner" + e]
                }
            }, i.prototype.getFirstItemSize = function() {
                var e = this.isotope.filteredItems[0];
                return e && e.element && t(e.element)
            }, i.prototype.layout = function() {
                this.isotope.layout.apply(this.isotope, arguments)
            }, i.prototype.getSize = function() {
                this.isotope.getSize(), this.size = this.isotope.size
            }, i.modes = {}, i.create = function(t, e) {
                function o() {
                    i.apply(this, arguments)
                }
                return o.prototype = new i, e && (o.options = e), o.prototype.namespace = t, i.modes[t] = o, o
            }, i
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-mode", ["get-size/get-size", "outlayer/outlayer"], e) : (t.Isotope = t.Isotope || {}, t.Isotope.LayoutMode = e(t.getSize, t.Outlayer))
    }(window),
    function(t) {
        function e(t, e) {
            var o = t.create("masonry");
            return o.prototype._resetLayout = function() {
                this.getSize(), this._getMeasurement("columnWidth", "outerWidth"), this._getMeasurement("gutter", "outerWidth"), this.measureColumns();
                var t = this.cols;
                for (this.colYs = []; t--;) this.colYs.push(0);
                this.maxY = 0
            }, o.prototype.measureColumns = function() {
                if (this.getContainerWidth(), !this.columnWidth) {
                    var t = this.items[0],
                        i = t && t.element;
                    this.columnWidth = i && e(i).outerWidth || this.containerWidth
                }
                this.columnWidth += this.gutter, this.cols = Math.floor((this.containerWidth + this.gutter) / this.columnWidth), this.cols = Math.max(this.cols, 1)
            }, o.prototype.getContainerWidth = function() {
                var t = this.options.isFitWidth ? this.element.parentNode : this.element,
                    i = e(t);
                this.containerWidth = i && i.innerWidth
            }, o.prototype._getItemLayoutPosition = function(t) {
                t.getSize();
                var e = t.size.outerWidth % this.columnWidth,
                    o = e && 1 > e ? "round" : "ceil",
                    n = Math[o](t.size.outerWidth / this.columnWidth);
                n = Math.min(n, this.cols);
                for (var r = this._getColGroup(n), s = Math.min.apply(Math, r), a = i(r, s), u = {
                        x: this.columnWidth * a,
                        y: s
                    }, p = s + t.size.outerHeight, h = this.cols + 1 - r.length, f = 0; h > f; f++) this.colYs[a + f] = p;
                return u
            }, o.prototype._getColGroup = function(t) {
                if (2 > t) return this.colYs;
                for (var e = [], i = this.cols + 1 - t, o = 0; i > o; o++) {
                    var n = this.colYs.slice(o, o + t);
                    e[o] = Math.max.apply(Math, n)
                }
                return e
            }, o.prototype._manageStamp = function(t) {
                var i = e(t),
                    o = this._getElementOffset(t),
                    n = this.options.isOriginLeft ? o.left : o.right,
                    r = n + i.outerWidth,
                    s = Math.floor(n / this.columnWidth);
                s = Math.max(0, s);
                var a = Math.floor(r / this.columnWidth);
                a -= r % this.columnWidth ? 0 : 1, a = Math.min(this.cols - 1, a);
                for (var u = (this.options.isOriginTop ? o.top : o.bottom) + i.outerHeight, p = s; a >= p; p++) this.colYs[p] = Math.max(u, this.colYs[p])
            }, o.prototype._getContainerSize = function() {
                this.maxY = Math.max.apply(Math, this.colYs);
                var t = {
                    height: this.maxY
                };
                return this.options.isFitWidth && (t.width = this._getContainerFitWidth()), t
            }, o.prototype._getContainerFitWidth = function() {
                for (var t = 0, e = this.cols; --e && 0 === this.colYs[e];) t++;
                return (this.cols - t) * this.columnWidth - this.gutter
            }, o.prototype.needsResizeLayout = function() {
                var t = this.containerWidth;
                return this.getContainerWidth(), t !== this.containerWidth
            }, o
        }
        var i = Array.prototype.indexOf ? function(t, e) {
            return t.indexOf(e)
        } : function(t, e) {
            for (var i = 0, o = t.length; o > i; i++) {
                var n = t[i];
                if (n === e) return i
            }
            return -1
        };
        "function" == typeof define && define.amd ? define("masonry/masonry", ["outlayer/outlayer", "get-size/get-size"], e) : t.Masonry = e(t.Outlayer, t.getSize)
    }(window),
    function(t) {
        function e(t, e) {
            for (var i in e) t[i] = e[i];
            return t
        }

        function i(t, i) {
            var o = t.create("masonry"),
                n = o.prototype._getElementOffset,
                r = o.prototype.layout,
                s = o.prototype._getMeasurement;
            e(o.prototype, i.prototype), o.prototype._getElementOffset = n, o.prototype.layout = r, o.prototype._getMeasurement = s;
            var a = o.prototype.measureColumns;
            o.prototype.measureColumns = function() {
                this.items = this.isotope.filteredItems, a.call(this)
            };
            var u = o.prototype._manageStamp;
            return o.prototype._manageStamp = function() {
                this.options.isOriginLeft = this.isotope.options.isOriginLeft, this.options.isOriginTop = this.isotope.options.isOriginTop, u.apply(this, arguments)
            }, o
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/masonry", ["../layout-mode", "masonry/masonry"], i) : i(t.Isotope.LayoutMode, t.Masonry)
    }(window),
    function(t) {
        function e(t) {
            var e = t.create("fitRows");
            return e.prototype._resetLayout = function() {
                this.x = 0, this.y = 0, this.maxY = 0
            }, e.prototype._getItemLayoutPosition = function(t) {
                t.getSize(), 0 !== this.x && t.size.outerWidth + this.x > this.isotope.size.innerWidth && (this.x = 0, this.y = this.maxY);
                var e = {
                    x: this.x,
                    y: this.y
                };
                return this.maxY = Math.max(this.maxY, this.y + t.size.outerHeight), this.x += t.size.outerWidth, e
            }, e.prototype._getContainerSize = function() {
                return {
                    height: this.maxY
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/fit-rows", ["../layout-mode"], e) : e(t.Isotope.LayoutMode)
    }(window),
    function(t) {
        function e(t) {
            var e = t.create("vertical", {
                horizontalAlignment: 0
            });
            return e.prototype._resetLayout = function() {
                this.y = 0
            }, e.prototype._getItemLayoutPosition = function(t) {
                t.getSize();
                var e = (this.isotope.size.innerWidth - t.size.outerWidth) * this.options.horizontalAlignment,
                    i = this.y;
                return this.y += t.size.outerHeight, {
                    x: e,
                    y: i
                }
            }, e.prototype._getContainerSize = function() {
                return {
                    height: this.y
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/vertical", ["../layout-mode"], e) : e(t.Isotope.LayoutMode)
    }(window),
    function(t) {
        function e(t, e) {
            for (var i in e) t[i] = e[i];
            return t
        }

        function i(t) {
            return "[object Array]" === h.call(t)
        }

        function o(t) {
            var e = [];
            if (i(t)) e = t;
            else if (t && "number" == typeof t.length)
                for (var o = 0, n = t.length; n > o; o++) e.push(t[o]);
            else e.push(t);
            return e
        }

        function n(t, e) {
            var i = f(e, t); - 1 !== i && e.splice(i, 1)
        }

        function r(t, i, r, u, h) {
            function f(t, e) {
                return function(i, o) {
                    for (var n = 0, r = t.length; r > n; n++) {
                        var s = t[n],
                            a = i.sortData[s],
                            u = o.sortData[s];
                        if (a > u || u > a) {
                            var p = void 0 !== e[s] ? e[s] : e,
                                h = p ? 1 : -1;
                            return (a > u ? 1 : -1) * h
                        }
                    }
                    return 0
                }
            }
            var l = t.create("isotope", {
                layoutMode: "masonry",
                isJQueryFiltering: !0,
                sortAscending: !0
            });
            l.Item = u, l.LayoutMode = h, l.prototype._create = function() {
                this.itemGUID = 0, this._sorters = {}, this._getSorters(), t.prototype._create.call(this), this.modes = {}, this.filteredItems = this.items, this.sortHistory = ["original-order"];
                for (var e in h.modes) this._initLayoutMode(e)
            }, l.prototype.reloadItems = function() {
                this.itemGUID = 0, t.prototype.reloadItems.call(this)
            }, l.prototype._itemize = function() {
                for (var e = t.prototype._itemize.apply(this, arguments), i = 0, o = e.length; o > i; i++) {
                    var n = e[i];
                    n.id = this.itemGUID++
                }
                return this._updateItemsSortData(e), e
            }, l.prototype._initLayoutMode = function(t) {
                var i = h.modes[t],
                    o = this.options[t] || {};
                this.options[t] = i.options ? e(i.options, o) : o, this.modes[t] = new i(this)
            }, l.prototype.layout = function() {
                return !this._isLayoutInited && this.options.isInitLayout ? void this.arrange() : void this._layout()
            }, l.prototype._layout = function() {
                var t = this._getIsInstant();
                this._resetLayout(), this._manageStamps(), this.layoutItems(this.filteredItems, t), this._isLayoutInited = !0
            }, l.prototype.arrange = function(t) {
                this.option(t), this._getIsInstant(), this.filteredItems = this._filter(this.items), this._sort(), this._layout()
            }, l.prototype._init = l.prototype.arrange, l.prototype._getIsInstant = function() {
                var t = void 0 !== this.options.isLayoutInstant ? this.options.isLayoutInstant : !this._isLayoutInited;
                return this._isInstant = t, t
            }, l.prototype._filter = function(t) {
                function e() {
                    f.reveal(n), f.hide(r)
                }
                var i = this.options.filter;
                i = i || "*";
                for (var o = [], n = [], r = [], s = this._getFilterTest(i), a = 0, u = t.length; u > a; a++) {
                    var p = t[a];
                    if (!p.isIgnored) {
                        var h = s(p);
                        h && o.push(p), h && p.isHidden ? n.push(p) : h || p.isHidden || r.push(p)
                    }
                }
                var f = this;
                return this._isInstant ? this._noTransition(e) : e(), o
            }, l.prototype._getFilterTest = function(t) {
                return s && this.options.isJQueryFiltering ? function(e) {
                    return s(e.element).is(t)
                } : "function" == typeof t ? function(e) {
                    return t(e.element)
                } : function(e) {
                    return r(e.element, t)
                }
            }, l.prototype.updateSortData = function(t) {
                this._getSorters(), t = o(t);
                var e = this.getItems(t);
                e = e.length ? e : this.items, this._updateItemsSortData(e)
            }, l.prototype._getSorters = function() {
                var t = this.options.getSortData;
                for (var e in t) {
                    var i = t[e];
                    this._sorters[e] = c(i)
                }
            }, l.prototype._updateItemsSortData = function(t) {
                for (var e = 0, i = t.length; i > e; e++) {
                    var o = t[e];
                    o.updateSortData()
                }
            };
            var c = function() {
                function t(t) {
                    if ("string" != typeof t) return t;
                    var i = a(t).split(" "),
                        o = i[0],
                        n = o.match(/^\[(.+)\]$/),
                        r = n && n[1],
                        s = e(r, o),
                        u = l.sortDataParsers[i[1]];
                    return t = u ? function(t) {
                        return t && u(s(t))
                    } : function(t) {
                        return t && s(t)
                    }
                }

                function e(t, e) {
                    var i;
                    return i = t ? function(e) {
                        return e.getAttribute(t)
                    } : function(t) {
                        var i = t.querySelector(e);
                        return i && p(i)
                    }
                }
                return t
            }();
            l.sortDataParsers = {
                parseInt: function(t) {
                    return parseInt(t, 10)
                },
                parseFloat: function(t) {
                    return parseFloat(t)
                }
            }, l.prototype._sort = function() {
                var t = this.options.sortBy;
                if (t) {
                    var e = [].concat.apply(t, this.sortHistory),
                        i = f(e, this.options.sortAscending);
                    this.filteredItems.sort(i), t !== this.sortHistory[0] && this.sortHistory.unshift(t)
                }
            }, l.prototype._mode = function() {
                var t = this.options.layoutMode,
                    e = this.modes[t];
                if (!e) throw Error("No layout mode: " + t);
                return e.options = this.options[t], e
            }, l.prototype._resetLayout = function() {
                t.prototype._resetLayout.call(this), this._mode()._resetLayout()
            }, l.prototype._getItemLayoutPosition = function(t) {
                return this._mode()._getItemLayoutPosition(t)
            }, l.prototype._manageStamp = function(t) {
                this._mode()._manageStamp(t)
            }, l.prototype._getContainerSize = function() {
                return this._mode()._getContainerSize()
            }, l.prototype.needsResizeLayout = function() {
                return this._mode().needsResizeLayout()
            }, l.prototype.appended = function(t) {
                var e = this.addItems(t);
                if (e.length) {
                    var i = this._filterRevealAdded(e);
                    this.filteredItems = this.filteredItems.concat(i)
                }
            }, l.prototype.prepended = function(t) {
                var e = this._itemize(t);
                if (e.length) {
                    var i = this.items.slice(0);
                    this.items = e.concat(i), this._resetLayout(), this._manageStamps();
                    var o = this._filterRevealAdded(e);
                    this.layoutItems(i), this.filteredItems = o.concat(this.filteredItems)
                }
            }, l.prototype._filterRevealAdded = function(t) {
                var e = this._noTransition(function() {
                    return this._filter(t)
                });
                return this.layoutItems(e, !0), this.reveal(e), t
            }, l.prototype.insert = function(t) {
                var e = this.addItems(t);
                if (e.length) {
                    var i, o, n = e.length;
                    for (i = 0; n > i; i++) o = e[i], this.element.appendChild(o.element);
                    var r = this._filter(e);
                    for (this._noTransition(function() {
                            this.hide(r)
                        }), i = 0; n > i; i++) e[i].isLayoutInstant = !0;
                    for (this.arrange(), i = 0; n > i; i++) delete e[i].isLayoutInstant;
                    this.reveal(r)
                }
            };
            var d = l.prototype.remove;
            return l.prototype.remove = function(t) {
                t = o(t);
                var e = this.getItems(t);
                if (d.call(this, t), e && e.length)
                    for (var i = 0, r = e.length; r > i; i++) {
                        var s = e[i];
                        n(s, this.filteredItems)
                    }
            }, l.prototype._noTransition = function(t) {
                var e = this.options.transitionDuration;
                this.options.transitionDuration = 0;
                var i = t.call(this);
                return this.options.transitionDuration = e, i
            }, l
        }
        var s = t.jQuery,
            a = String.prototype.trim ? function(t) {
                return t.trim()
            } : function(t) {
                return t.replace(/^\s+|\s+$/g, "")
            },
            u = document.documentElement,
            p = u.textContent ? function(t) {
                return t.textContent
            } : function(t) {
                return t.innerText
            },
            h = Object.prototype.toString,
            f = Array.prototype.indexOf ? function(t, e) {
                return t.indexOf(e)
            } : function(t, e) {
                for (var i = 0, o = t.length; o > i; i++)
                    if (t[i] === e) return i;
                return -1
            };
        "function" == typeof define && define.amd ? define(["outlayer/outlayer", "get-size/get-size", "matches-selector/matches-selector", "isotope/js/item", "isotope/js/layout-mode", "isotope/js/layout-modes/masonry", "isotope/js/layout-modes/fit-rows", "isotope/js/layout-modes/vertical"], r) : t.Isotope = r(t.Outlayer, t.getSize, t.matchesSelector, t.Isotope.Item, t.Isotope.LayoutMode)
    }(window), jQuery(window).load(function() {
        var t = {},
            e = jQuery(".stream");
        jQuery(".filter a").click(function() {
            var e, i, o = jQuery(this),
                n = [],
                r = o.parents(".dcsns-toolbar"),
                s = r.next(),
                a = jQuery(".stream", s);
            jQuery(".filter a", r).removeClass("iso-active"), o.addClass("iso-active"), t[o.data("group")] = o.data("filter");
            for (e in t) n.push(t[e]);
            return i = n.join(""), a.isotope({
                filter: i,
                sortBy: "postDate"
            }), !1
        }), jQuery.each(e, function() {
            jQuery("li .section-thumb img, li .section-text img", jQuery(this)).css("opacity", 0).show().fadeTo(800, 1), jQuery(this).isotope("layout")
        })
    }), $(document).ready(function() {
        $("button").click(function() {
            $(".link-all").addClass("iso-active")
        })
    }), $(window).scroll(function() {
        $(this).scrollTop() > 2 ? $(".link-all").addClass("iso-active") : $(".link-all").removeClass("iso-active")
    });

! function(t) {
    function e() {}

    function i(t) {
        function i(e) {
            e.prototype.option || (e.prototype.option = function(e) {
                t.isPlainObject(e) && (this.options = t.extend(!0, this.options, e))
            })
        }

        function n(e, i) {
            t.fn[e] = function(n) {
                if ("string" == typeof n) {
                    for (var s = o.call(arguments, 1), a = 0, u = this.length; u > a; a++) {
                        var p = this[a],
                            h = t.data(p, e);
                        if (h)
                            if (t.isFunction(h[n]) && "_" !== n.charAt(0)) {
                                var f = h[n].apply(h, s);
                                if (void 0 !== f) return f
                            } else r("no such method '" + n + "' for " + e + " instance");
                        else r("cannot call methods on " + e + " prior to initialization; attempted to call '" + n + "'")
                    }
                    return this
                }
                return this.each(function() {
                    var o = t.data(this, e);
                    o ? (o.option(n), o._init()) : (o = new i(this, n), t.data(this, e, o))
                })
            }
        }
        if (t) {
            var r = "undefined" == typeof console ? e : function(t) {
                console.error(t)
            };
            return t.bridget = function(t, e) {
                i(e), n(t, e)
            }, t.bridget
        }
    }
    var o = Array.prototype.slice;
    "function" == typeof define && define.amd ? define("jquery-bridget/jquery.bridget", ["jquery"], i) : i(t.jQuery)
}(window),
function(t) {
    function e(e) {
        var i = t.event;
        return i.target = i.target || i.srcElement || e, i
    }
    var i = document.documentElement,
        o = function() {};
    i.addEventListener ? o = function(t, e, i) {
        t.addEventListener(e, i, !1)
    } : i.attachEvent && (o = function(t, i, o) {
        t[i + o] = o.handleEvent ? function() {
            var i = e(t);
            o.handleEvent.call(o, i)
        } : function() {
            var i = e(t);
            o.call(t, i)
        }, t.attachEvent("on" + i, t[i + o])
    });
    var n = function() {};
    i.removeEventListener ? n = function(t, e, i) {
        t.removeEventListener(e, i, !1)
    } : i.detachEvent && (n = function(t, e, i) {
        t.detachEvent("on" + e, t[e + i]);
        try {
            delete t[e + i]
        } catch (o) {
            t[e + i] = void 0
        }
    });
    var r = {
        bind: o,
        unbind: n
    };
    "function" == typeof define && define.amd ? define("eventie/eventie", r) : "object" == typeof exports ? module.exports = r : t.eventie = r
}(this),
function(t) {
    function e(t) {
        "function" == typeof t && (e.isReady ? t() : r.push(t))
    }

    function i(t) {
        var i = "readystatechange" === t.type && "complete" !== n.readyState;
        if (!e.isReady && !i) {
            e.isReady = !0;
            for (var o = 0, s = r.length; s > o; o++) {
                (0, r[o])()
            }
        }
    }

    function o(o) {
        return o.bind(n, "DOMContentLoaded", i), o.bind(n, "readystatechange", i), o.bind(t, "load", i), e
    }
    var n = t.document,
        r = [];
    e.isReady = !1, "function" == typeof define && define.amd ? (e.isReady = "function" == typeof requirejs, define("doc-ready/doc-ready", ["eventie/eventie"], o)) : t.docReady = o(t.eventie)
}(this),
function() {
    function t() {}

    function e(t, e) {
        for (var i = t.length; i--;)
            if (t[i].listener === e) return i;
        return -1
    }

    function i(t) {
        return function() {
            return this[t].apply(this, arguments)
        }
    }
    var o = t.prototype,
        n = this,
        r = n.EventEmitter;
    o.getListeners = function(t) {
        var e, i, o = this._getEvents();
        if (t instanceof RegExp)
            for (i in e = {}, o) o.hasOwnProperty(i) && t.test(i) && (e[i] = o[i]);
        else e = o[t] || (o[t] = []);
        return e
    }, o.flattenListeners = function(t) {
        var e, i = [];
        for (e = 0; t.length > e; e += 1) i.push(t[e].listener);
        return i
    }, o.getListenersAsObject = function(t) {
        var e, i = this.getListeners(t);
        return i instanceof Array && ((e = {})[t] = i), e || i
    }, o.addListener = function(t, i) {
        var o, n = this.getListenersAsObject(t),
            r = "object" == typeof i;
        for (o in n) n.hasOwnProperty(o) && -1 === e(n[o], i) && n[o].push(r ? i : {
            listener: i,
            once: !1
        });
        return this
    }, o.on = i("addListener"), o.addOnceListener = function(t, e) {
        return this.addListener(t, {
            listener: e,
            once: !0
        })
    }, o.once = i("addOnceListener"), o.defineEvent = function(t) {
        return this.getListeners(t), this
    }, o.defineEvents = function(t) {
        for (var e = 0; t.length > e; e += 1) this.defineEvent(t[e]);
        return this
    }, o.removeListener = function(t, i) {
        var o, n, r = this.getListenersAsObject(t);
        for (n in r) r.hasOwnProperty(n) && (-1 !== (o = e(r[n], i)) && r[n].splice(o, 1));
        return this
    }, o.off = i("removeListener"), o.addListeners = function(t, e) {
        return this.manipulateListeners(!1, t, e)
    }, o.removeListeners = function(t, e) {
        return this.manipulateListeners(!0, t, e)
    }, o.manipulateListeners = function(t, e, i) {
        var o, n, r = t ? this.removeListener : this.addListener,
            s = t ? this.removeListeners : this.addListeners;
        if ("object" != typeof e || e instanceof RegExp)
            for (o = i.length; o--;) r.call(this, e, i[o]);
        else
            for (o in e) e.hasOwnProperty(o) && (n = e[o]) && ("function" == typeof n ? r.call(this, o, n) : s.call(this, o, n));
        return this
    }, o.removeEvent = function(t) {
        var e, i = typeof t,
            o = this._getEvents();
        if ("string" === i) delete o[t];
        else if (t instanceof RegExp)
            for (e in o) o.hasOwnProperty(e) && t.test(e) && delete o[e];
        else delete this._events;
        return this
    }, o.removeAllListeners = i("removeEvent"), o.emitEvent = function(t, e) {
        var i, o, n, r = this.getListenersAsObject(t);
        for (n in r)
            if (r.hasOwnProperty(n))
                for (o = r[n].length; o--;) !0 === (i = r[n][o]).once && this.removeListener(t, i.listener), i.listener.apply(this, e || []) === this._getOnceReturnValue() && this.removeListener(t, i.listener);
        return this
    }, o.trigger = i("emitEvent"), o.emit = function(t) {
        var e = Array.prototype.slice.call(arguments, 1);
        return this.emitEvent(t, e)
    }, o.setOnceReturnValue = function(t) {
        return this._onceReturnValue = t, this
    }, o._getOnceReturnValue = function() {
        return !this.hasOwnProperty("_onceReturnValue") || this._onceReturnValue
    }, o._getEvents = function() {
        return this._events || (this._events = {})
    }, t.noConflict = function() {
        return n.EventEmitter = r, t
    }, "function" == typeof define && define.amd ? define("eventEmitter/EventEmitter", [], function() {
        return t
    }) : "object" == typeof module && module.exports ? module.exports = t : this.EventEmitter = t
}.call(this),
    function(t) {
        function e(t) {
            if (t) {
                if ("string" == typeof o[t]) return t;
                t = t.charAt(0).toUpperCase() + t.slice(1);
                for (var e, n = 0, r = i.length; r > n; n++)
                    if (e = i[n] + t, "string" == typeof o[e]) return e
            }
        }
        var i = "Webkit Moz ms Ms O".split(" "),
            o = document.documentElement.style;
        "function" == typeof define && define.amd ? define("get-style-property/get-style-property", [], function() {
            return e
        }) : "object" == typeof exports ? module.exports = e : t.getStyleProperty = e
    }(window),
    function(t) {
        function e(t) {
            var e = parseFloat(t);
            return -1 === t.indexOf("%") && !isNaN(e) && e
        }

        function i(t) {
            function i(t, e) {
                if (o || -1 === e.indexOf("%")) return e;
                var i = t.style,
                    n = i.left,
                    r = t.runtimeStyle,
                    s = r && r.left;
                return s && (r.left = t.currentStyle.left), i.left = e, e = i.pixelLeft, i.left = n, s && (r.left = s), e
            }
            var s, a = t("boxSizing");
            return function() {
                    if (a) {
                        var t = document.createElement("div");
                        t.style.width = "200px", t.style.padding = "1px 2px 3px 4px", t.style.borderStyle = "solid", t.style.borderWidth = "1px 2px 3px 4px", t.style[a] = "border-box";
                        var i = document.body || document.documentElement;
                        i.appendChild(t);
                        var o = n(t);
                        s = 200 === e(o.width), i.removeChild(t)
                    }
                }(),
                function(t) {
                    if ("string" == typeof t && (t = document.querySelector(t)), t && "object" == typeof t && t.nodeType) {
                        var o = n(t);
                        if ("none" === o.display) return function() {
                            for (var t = {
                                    width: 0,
                                    height: 0,
                                    innerWidth: 0,
                                    innerHeight: 0,
                                    outerWidth: 0,
                                    outerHeight: 0
                                }, e = 0, i = r.length; i > e; e++) t[r[e]] = 0;
                            return t
                        }();
                        var u = {};
                        u.width = t.offsetWidth, u.height = t.offsetHeight;
                        for (var p = u.isBorderBox = !(!a || !o[a] || "border-box" !== o[a]), h = 0, f = r.length; f > h; h++) {
                            var l = r[h],
                                c = o[l];
                            c = i(t, c);
                            var d = parseFloat(c);
                            u[l] = isNaN(d) ? 0 : d
                        }
                        var y = u.paddingLeft + u.paddingRight,
                            m = u.paddingTop + u.paddingBottom,
                            g = u.marginLeft + u.marginRight,
                            v = u.marginTop + u.marginBottom,
                            _ = u.borderLeftWidth + u.borderRightWidth,
                            I = u.borderTopWidth + u.borderBottomWidth,
                            L = p && s,
                            z = e(o.width);
                        !1 !== z && (u.width = z + (L ? 0 : y + _));
                        var S = e(o.height);
                        return !1 !== S && (u.height = S + (L ? 0 : m + I)), u.innerWidth = u.width - (y + _), u.innerHeight = u.height - (m + I), u.outerWidth = u.width + g, u.outerHeight = u.height + v, u
                    }
                }
        }
        var o = t.getComputedStyle,
            n = o ? function(t) {
                return o(t, null)
            } : function(t) {
                return t.currentStyle
            },
            r = ["paddingLeft", "paddingRight", "paddingTop", "paddingBottom", "marginLeft", "marginRight", "marginTop", "marginBottom", "borderLeftWidth", "borderRightWidth", "borderTopWidth", "borderBottomWidth"];
        "function" == typeof define && define.amd ? define("get-size/get-size", ["get-style-property/get-style-property"], i) : "object" == typeof exports ? module.exports = i(require("get-style-property")) : t.getSize = i(t.getStyleProperty)
    }(window),
    function(t, e) {
        function i(t, e) {
            return t[r](e)
        }

        function o(t) {
            t.parentNode || document.createDocumentFragment().appendChild(t)
        }
        var n, r = function() {
            if (e.matchesSelector) return "matchesSelector";
            for (var t = ["webkit", "moz", "ms", "o"], i = 0, o = t.length; o > i; i++) {
                var n = t[i] + "MatchesSelector";
                if (e[n]) return n
            }
        }();
        if (r) {
            var s = i(document.createElement("div"), "div");
            n = s ? i : function(t, e) {
                return o(t), i(t, e)
            }
        } else n = function(t, e) {
            o(t);
            for (var i = t.parentNode.querySelectorAll(e), n = 0, r = i.length; r > n; n++)
                if (i[n] === t) return !0;
            return !1
        };
        "function" == typeof define && define.amd ? define("matches-selector/matches-selector", [], function() {
            return n
        }) : window.matchesSelector = n
    }(0, Element.prototype),
    function(t) {
        function e(t, e, i) {
            function n(t, e) {
                t && (this.element = t, this.layout = e, this.position = {
                    x: 0,
                    y: 0
                }, this._create())
            }
            var r = i("transition"),
                s = i("transform"),
                a = r && s,
                u = !!i("perspective"),
                p = {
                    WebkitTransition: "webkitTransitionEnd",
                    MozTransition: "transitionend",
                    OTransition: "otransitionend",
                    transition: "transitionend"
                }[r],
                h = ["transform", "transition", "transitionDuration", "transitionProperty"],
                f = function() {
                    for (var t = {}, e = 0, o = h.length; o > e; e++) {
                        var n = h[e],
                            r = i(n);
                        r && r !== n && (t[n] = r)
                    }
                    return t
                }();
            (function(t, e) {
                for (var i in e) t[i] = e[i]
            })(n.prototype, t.prototype), n.prototype._create = function() {
                this._transn = {
                    ingProperties: {},
                    clean: {},
                    onEnd: {}
                }, this.css({
                    position: "absolute"
                })
            }, n.prototype.handleEvent = function(t) {
                var e = "on" + t.type;
                this[e] && this[e](t)
            }, n.prototype.getSize = function() {
                this.size = e(this.element)
            }, n.prototype.css = function(t) {
                var e = this.element.style;
                for (var i in t) {
                    e[f[i] || i] = t[i]
                }
            }, n.prototype.getPosition = function() {
                var t = o(this.element),
                    e = this.layout.options,
                    i = e.isOriginLeft,
                    n = e.isOriginTop,
                    r = parseInt(t[i ? "left" : "right"], 10),
                    s = parseInt(t[n ? "top" : "bottom"], 10);
                r = isNaN(r) ? 0 : r, s = isNaN(s) ? 0 : s;
                var a = this.layout.size;
                r -= i ? a.paddingLeft : a.paddingRight, s -= n ? a.paddingTop : a.paddingBottom, this.position.x = r, this.position.y = s
            }, n.prototype.layoutPosition = function() {
                var t = this.layout.size,
                    e = this.layout.options,
                    i = {};
                e.isOriginLeft ? (i.left = this.position.x + t.paddingLeft + "px", i.right = "") : (i.right = this.position.x + t.paddingRight + "px", i.left = ""), e.isOriginTop ? (i.top = this.position.y + t.paddingTop + "px", i.bottom = "") : (i.bottom = this.position.y + t.paddingBottom + "px", i.top = ""), this.css(i), this.emitEvent("layout", [this])
            };
            var l = u ? function(t, e) {
                return "translate3d(" + t + "px, " + e + "px, 0)"
            } : function(t, e) {
                return "translate(" + t + "px, " + e + "px)"
            };
            n.prototype._transitionTo = function(t, e) {
                this.getPosition();
                var i = this.position.x,
                    o = this.position.y,
                    n = parseInt(t, 10),
                    r = parseInt(e, 10),
                    s = n === this.position.x && r === this.position.y;
                if (this.setPosition(t, e), !s || this.isTransitioning) {
                    var a = t - i,
                        u = e - o,
                        p = {},
                        h = this.layout.options;
                    a = h.isOriginLeft ? a : -a, u = h.isOriginTop ? u : -u, p.transform = l(a, u), this.transition({
                        to: p,
                        onTransitionEnd: {
                            transform: this.layoutPosition
                        },
                        isCleaning: !0
                    })
                } else this.layoutPosition()
            }, n.prototype.goTo = function(t, e) {
                this.setPosition(t, e), this.layoutPosition()
            }, n.prototype.moveTo = a ? n.prototype._transitionTo : n.prototype.goTo, n.prototype.setPosition = function(t, e) {
                this.position.x = parseInt(t, 10), this.position.y = parseInt(e, 10)
            }, n.prototype._nonTransition = function(t) {
                for (var e in this.css(t.to), t.isCleaning && this._removeStyles(t.to), t.onTransitionEnd) t.onTransitionEnd[e].call(this)
            }, n.prototype._transition = function(t) {
                if (parseFloat(this.layout.options.transitionDuration)) {
                    var e = this._transn;
                    for (var i in t.onTransitionEnd) e.onEnd[i] = t.onTransitionEnd[i];
                    for (i in t.to) e.ingProperties[i] = !0, t.isCleaning && (e.clean[i] = !0);
                    if (t.from) {
                        this.css(t.from);
                        this.element.offsetHeight;
                        null
                    }
                    this.enableTransition(t.to), this.css(t.to), this.isTransitioning = !0
                } else this._nonTransition(t)
            };
            var c = s && function(t) {
                return t.replace(/([A-Z])/g, function(t) {
                    return "-" + t.toLowerCase()
                })
            }(s) + ",opacity";
            n.prototype.enableTransition = function() {
                this.isTransitioning || (this.css({
                    transitionProperty: c,
                    transitionDuration: this.layout.options.transitionDuration
                }), this.element.addEventListener(p, this, !1))
            }, n.prototype.transition = n.prototype[r ? "_transition" : "_nonTransition"], n.prototype.onwebkitTransitionEnd = function(t) {
                this.ontransitionend(t)
            }, n.prototype.onotransitionend = function(t) {
                this.ontransitionend(t)
            };
            var d = {
                "-webkit-transform": "transform",
                "-moz-transform": "transform",
                "-o-transform": "transform"
            };
            n.prototype.ontransitionend = function(t) {
                if (t.target === this.element) {
                    var e = this._transn,
                        i = d[t.propertyName] || t.propertyName;
                    if (delete e.ingProperties[i], function(t) {
                            for (var e in t) return !1;
                            return !0
                        }(e.ingProperties) && this.disableTransition(), i in e.clean && (this.element.style[t.propertyName] = "", delete e.clean[i]), i in e.onEnd) e.onEnd[i].call(this), delete e.onEnd[i];
                    this.emitEvent("transitionEnd", [this])
                }
            }, n.prototype.disableTransition = function() {
                this.removeTransitionStyles(), this.element.removeEventListener(p, this, !1), this.isTransitioning = !1
            }, n.prototype._removeStyles = function(t) {
                var e = {};
                for (var i in t) e[i] = "";
                this.css(e)
            };
            var y = {
                transitionProperty: "",
                transitionDuration: ""
            };
            return n.prototype.removeTransitionStyles = function() {
                this.css(y)
            }, n.prototype.removeElem = function() {
                this.element.parentNode.removeChild(this.element), this.emitEvent("remove", [this])
            }, n.prototype.remove = function() {
                if (r && parseFloat(this.layout.options.transitionDuration)) {
                    var t = this;
                    this.on("transitionEnd", function() {
                        return t.removeElem(), !0
                    }), this.hide()
                } else this.removeElem()
            }, n.prototype.reveal = function() {
                delete this.isHidden, this.css({
                    display: ""
                });
                var t = this.layout.options;
                this.transition({
                    from: t.hiddenStyle,
                    to: t.visibleStyle,
                    isCleaning: !0
                })
            }, n.prototype.hide = function() {
                this.isHidden = !0, this.css({
                    display: ""
                });
                var t = this.layout.options;
                this.transition({
                    from: t.visibleStyle,
                    to: t.hiddenStyle,
                    isCleaning: !0,
                    onTransitionEnd: {
                        opacity: function() {
                            this.isHidden && this.css({
                                display: "none"
                            })
                        }
                    }
                })
            }, n.prototype.destroy = function() {
                this.css({
                    position: "",
                    left: "",
                    right: "",
                    top: "",
                    bottom: "",
                    transition: "",
                    transform: ""
                })
            }, n
        }
        var i = t.getComputedStyle,
            o = i ? function(t) {
                return i(t, null)
            } : function(t) {
                return t.currentStyle
            };
        "function" == typeof define && define.amd ? define("outlayer/item", ["eventEmitter/EventEmitter", "get-size/get-size", "get-style-property/get-style-property"], e) : (t.Outlayer = {}, t.Outlayer.Item = e(t.EventEmitter, t.getSize, t.getStyleProperty))
    }(window),
    function(t) {
        function e(t, e) {
            for (var i in e) t[i] = e[i];
            return t
        }

        function i(t) {
            var e = [];
            if (function(t) {
                    return "[object Array]" === p.call(t)
                }(t)) e = t;
            else if (t && "number" == typeof t.length)
                for (var i = 0, o = t.length; o > i; i++) e.push(t[i]);
            else e.push(t);
            return e
        }

        function o(t, e) {
            var i = f(e, t); - 1 !== i && e.splice(i, 1)
        }

        function n(n, p, f, l, c, d) {
            function y(t, i) {
                if ("string" == typeof t && (t = r.querySelector(t)), t && h(t)) {
                    this.element = t, this.options = e({}, this.constructor.defaults), this.option(i);
                    var o = ++m;
                    this.element.outlayerGUID = o, g[o] = this, this._create(), this.options.isInitLayout && this.layout()
                } else s && s.error("Bad " + this.constructor.namespace + " element: " + t)
            }
            var m = 0,
                g = {};
            return y.namespace = "outlayer", y.Item = d, y.defaults = {
                containerStyle: {
                    position: "relative"
                },
                isInitLayout: !0,
                isOriginLeft: !0,
                isOriginTop: !0,
                isResizeBound: !0,
                isResizingContainer: !0,
                transitionDuration: "0.4s",
                hiddenStyle: {
                    opacity: 0,
                    transform: "scale(0.001)"
                },
                visibleStyle: {
                    opacity: 1,
                    transform: "scale(1)"
                }
            }, e(y.prototype, f.prototype), y.prototype.option = function(t) {
                e(this.options, t)
            }, y.prototype._create = function() {
                this.reloadItems(), this.stamps = [], this.stamp(this.options.stamp), e(this.element.style, this.options.containerStyle), this.options.isResizeBound && this.bindResize()
            }, y.prototype.reloadItems = function() {
                this.items = this._itemize(this.element.children)
            }, y.prototype._itemize = function(t) {
                for (var e = this._filterFindItemElements(t), i = this.constructor.Item, o = [], n = 0, r = e.length; r > n; n++) {
                    var s = new i(e[n], this);
                    o.push(s)
                }
                return o
            }, y.prototype._filterFindItemElements = function(t) {
                t = i(t);
                for (var e = this.options.itemSelector, o = [], n = 0, r = t.length; r > n; n++) {
                    var s = t[n];
                    if (h(s))
                        if (e) {
                            c(s, e) && o.push(s);
                            for (var a = s.querySelectorAll(e), u = 0, p = a.length; p > u; u++) o.push(a[u])
                        } else o.push(s)
                }
                return o
            }, y.prototype.getItemElements = function() {
                for (var t = [], e = 0, i = this.items.length; i > e; e++) t.push(this.items[e].element);
                return t
            }, y.prototype.layout = function() {
                this._resetLayout(), this._manageStamps();
                var t = void 0 !== this.options.isLayoutInstant ? this.options.isLayoutInstant : !this._isLayoutInited;
                this.layoutItems(this.items, t), this._isLayoutInited = !0
            }, y.prototype._init = y.prototype.layout, y.prototype._resetLayout = function() {
                this.getSize()
            }, y.prototype.getSize = function() {
                this.size = l(this.element)
            }, y.prototype._getMeasurement = function(t, e) {
                var i, o = this.options[t];
                o ? ("string" == typeof o ? i = this.element.querySelector(o) : h(o) && (i = o), this[t] = i ? l(i)[e] : o) : this[t] = 0
            }, y.prototype.layoutItems = function(t, e) {
                t = this._getItemsForLayout(t), this._layoutItems(t, e), this._postLayout()
            }, y.prototype._getItemsForLayout = function(t) {
                for (var e = [], i = 0, o = t.length; o > i; i++) {
                    var n = t[i];
                    n.isIgnored || e.push(n)
                }
                return e
            }, y.prototype._layoutItems = function(t, e) {
                function i() {
                    o.emitEvent("layoutComplete", [o, t])
                }
                var o = this;
                if (t && t.length) {
                    this._itemsOn(t, "layout", i);
                    for (var n = [], r = 0, s = t.length; s > r; r++) {
                        var a = t[r],
                            u = this._getItemLayoutPosition(a);
                        u.item = a, u.isInstant = e || a.isLayoutInstant, n.push(u)
                    }
                    this._processLayoutQueue(n)
                } else i()
            }, y.prototype._getItemLayoutPosition = function() {
                return {
                    x: 0,
                    y: 0
                }
            }, y.prototype._processLayoutQueue = function(t) {
                for (var e = 0, i = t.length; i > e; e++) {
                    var o = t[e];
                    this._positionItem(o.item, o.x, o.y, o.isInstant)
                }
            }, y.prototype._positionItem = function(t, e, i, o) {
                o ? t.goTo(e, i) : t.moveTo(e, i)
            }, y.prototype._postLayout = function() {
                this.resizeContainer()
            }, y.prototype.resizeContainer = function() {
                if (this.options.isResizingContainer) {
                    var t = this._getContainerSize();
                    t && (this._setContainerMeasure(t.width, !0), this._setContainerMeasure(t.height, !1))
                }
            }, y.prototype._getContainerSize = u, y.prototype._setContainerMeasure = function(t, e) {
                if (void 0 !== t) {
                    var i = this.size;
                    i.isBorderBox && (t += e ? i.paddingLeft + i.paddingRight + i.borderLeftWidth + i.borderRightWidth : i.paddingBottom + i.paddingTop + i.borderTopWidth + i.borderBottomWidth), t = Math.max(t, 0), this.element.style[e ? "width" : "height"] = t + "px"
                }
            }, y.prototype._itemsOn = function(t, e, i) {
                function o() {
                    return ++n === r && i.call(s), !0
                }
                for (var n = 0, r = t.length, s = this, a = 0, u = t.length; u > a; a++) {
                    t[a].on(e, o)
                }
            }, y.prototype.ignore = function(t) {
                var e = this.getItem(t);
                e && (e.isIgnored = !0)
            }, y.prototype.unignore = function(t) {
                var e = this.getItem(t);
                e && delete e.isIgnored
            }, y.prototype.stamp = function(t) {
                if (t = this._find(t)) {
                    this.stamps = this.stamps.concat(t);
                    for (var e = 0, i = t.length; i > e; e++) {
                        var o = t[e];
                        this.ignore(o)
                    }
                }
            }, y.prototype.unstamp = function(t) {
                if (t = this._find(t))
                    for (var e = 0, i = t.length; i > e; e++) {
                        var n = t[e];
                        o(n, this.stamps), this.unignore(n)
                    }
            }, y.prototype._find = function(t) {
                return t ? ("string" == typeof t && (t = this.element.querySelectorAll(t)), t = i(t)) : void 0
            }, y.prototype._manageStamps = function() {
                if (this.stamps && this.stamps.length) {
                    this._getBoundingRect();
                    for (var t = 0, e = this.stamps.length; e > t; t++) {
                        var i = this.stamps[t];
                        this._manageStamp(i)
                    }
                }
            }, y.prototype._getBoundingRect = function() {
                var t = this.element.getBoundingClientRect(),
                    e = this.size;
                this._boundingRect = {
                    left: t.left + e.paddingLeft + e.borderLeftWidth,
                    top: t.top + e.paddingTop + e.borderTopWidth,
                    right: t.right - (e.paddingRight + e.borderRightWidth),
                    bottom: t.bottom - (e.paddingBottom + e.borderBottomWidth)
                }
            }, y.prototype._manageStamp = u, y.prototype._getElementOffset = function(t) {
                var e = t.getBoundingClientRect(),
                    i = this._boundingRect,
                    o = l(t);
                return {
                    left: e.left - i.left - o.marginLeft,
                    top: e.top - i.top - o.marginTop,
                    right: i.right - e.right - o.marginRight,
                    bottom: i.bottom - e.bottom - o.marginBottom
                }
            }, y.prototype.handleEvent = function(t) {
                var e = "on" + t.type;
                this[e] && this[e](t)
            }, y.prototype.bindResize = function() {
                this.isResizeBound || (n.bind(t, "resize", this), this.isResizeBound = !0)
            }, y.prototype.unbindResize = function() {
                this.isResizeBound && n.unbind(t, "resize", this), this.isResizeBound = !1
            }, y.prototype.onresize = function() {
                this.resizeTimeout && clearTimeout(this.resizeTimeout);
                var t = this;
                this.resizeTimeout = setTimeout(function() {
                    t.resize(), delete t.resizeTimeout
                }, 100)
            }, y.prototype.resize = function() {
                this.isResizeBound && this.needsResizeLayout() && this.layout()
            }, y.prototype.needsResizeLayout = function() {
                var t = l(this.element);
                return this.size && t && t.innerWidth !== this.size.innerWidth
            }, y.prototype.addItems = function(t) {
                var e = this._itemize(t);
                return e.length && (this.items = this.items.concat(e)), e
            }, y.prototype.appended = function(t) {
                var e = this.addItems(t);
                e.length && (this.layoutItems(e, !0), this.reveal(e))
            }, y.prototype.prepended = function(t) {
                var e = this._itemize(t);
                if (e.length) {
                    var i = this.items.slice(0);
                    this.items = e.concat(i), this._resetLayout(), this._manageStamps(), this.layoutItems(e, !0), this.reveal(e), this.layoutItems(i)
                }
            }, y.prototype.reveal = function(t) {
                var e = t && t.length;
                if (e)
                    for (var i = 0; e > i; i++) {
                        t[i].reveal()
                    }
            }, y.prototype.hide = function(t) {
                var e = t && t.length;
                if (e)
                    for (var i = 0; e > i; i++) {
                        t[i].hide()
                    }
            }, y.prototype.getItem = function(t) {
                for (var e = 0, i = this.items.length; i > e; e++) {
                    var o = this.items[e];
                    if (o.element === t) return o
                }
            }, y.prototype.getItems = function(t) {
                if (t && t.length) {
                    for (var e = [], i = 0, o = t.length; o > i; i++) {
                        var n = t[i],
                            r = this.getItem(n);
                        r && e.push(r)
                    }
                    return e
                }
            }, y.prototype.remove = function(t) {
                t = i(t);
                var e = this.getItems(t);
                if (e && e.length) {
                    this._itemsOn(e, "remove", function() {
                        this.emitEvent("removeComplete", [this, e])
                    });
                    for (var n = 0, r = e.length; r > n; n++) {
                        var s = e[n];
                        s.remove(), o(s, this.items)
                    }
                }
            }, y.prototype.destroy = function() {
                var t = this.element.style;
                t.height = "", t.position = "", t.width = "";
                for (var e = 0, i = this.items.length; i > e; e++) {
                    this.items[e].destroy()
                }
                this.unbindResize(), delete this.element.outlayerGUID, a && a.removeData(this.element, this.constructor.namespace)
            }, y.data = function(t) {
                var e = t && t.outlayerGUID;
                return e && g[e]
            }, y.create = function(t, i) {
                function o() {
                    y.apply(this, arguments)
                }
                return Object.create ? o.prototype = Object.create(y.prototype) : e(o.prototype, y.prototype), o.prototype.constructor = o, o.defaults = e({}, y.defaults), e(o.defaults, i), o.prototype.settings = {}, o.namespace = t, o.data = y.data, o.Item = function() {
                    d.apply(this, arguments)
                }, o.Item.prototype = new d, p(function() {
                    for (var e = function(t) {
                            return t.replace(/(.)([A-Z])/g, function(t, e, i) {
                                return e + "-" + i
                            }).toLowerCase()
                        }(t), i = r.querySelectorAll(".js-" + e), n = "data-" + e + "-options", u = 0, p = i.length; p > u; u++) {
                        var h, f = i[u],
                            l = f.getAttribute(n);
                        try {
                            h = l && JSON.parse(l)
                        } catch (t) {
                            s && s.error("Error parsing " + n + " on " + f.nodeName.toLowerCase() + (f.id ? "#" + f.id : "") + ": " + t);
                            continue
                        }
                        var c = new o(f, h);
                        a && a.data(f, t, c)
                    }
                }), a && a.bridget && a.bridget(t, o), o
            }, y.Item = d, y
        }
        var r = t.document,
            s = t.console,
            a = t.jQuery,
            u = function() {},
            p = Object.prototype.toString,
            h = "object" == typeof HTMLElement ? function(t) {
                return t instanceof HTMLElement
            } : function(t) {
                return t && "object" == typeof t && 1 === t.nodeType && "string" == typeof t.nodeName
            },
            f = Array.prototype.indexOf ? function(t, e) {
                return t.indexOf(e)
            } : function(t, e) {
                for (var i = 0, o = t.length; o > i; i++)
                    if (t[i] === e) return i;
                return -1
            };
        "function" == typeof define && define.amd ? define("outlayer/outlayer", ["eventie/eventie", "doc-ready/doc-ready", "eventEmitter/EventEmitter", "get-size/get-size", "matches-selector/matches-selector", "./item"], n) : t.Outlayer = n(t.eventie, t.docReady, t.EventEmitter, t.getSize, t.matchesSelector, t.Outlayer.Item)
    }(window),
    function(t) {
        function e(t) {
            function e() {
                t.Item.apply(this, arguments)
            }
            return e.prototype = new t.Item, e.prototype._create = function() {
                this.id = this.layout.itemGUID++, t.Item.prototype._create.call(this), this.sortData = {}
            }, e.prototype.updateSortData = function() {
                if (!this.isIgnored) {
                    this.sortData.id = this.id, this.sortData["original-order"] = this.id, this.sortData.random = Math.random();
                    var t = this.layout.options.getSortData,
                        e = this.layout._sorters;
                    for (var i in t) {
                        var o = e[i];
                        this.sortData[i] = o(this.element, this)
                    }
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/item", ["outlayer/outlayer"], e) : (t.Isotope = t.Isotope || {}, t.Isotope.Item = e(t.Outlayer))
    }(window),
    function(t) {
        function e(t, e) {
            function i(t) {
                this.isotope = t, t && (this.options = t.options[this.namespace], this.element = t.element, this.items = t.filteredItems, this.size = t.size)
            }
            return function() {
                function t(t) {
                    return function() {
                        return e.prototype[t].apply(this.isotope, arguments)
                    }
                }
                for (var o = ["_resetLayout", "_getItemLayoutPosition", "_manageStamp", "_getContainerSize", "_getElementOffset", "needsResizeLayout"], n = 0, r = o.length; r > n; n++) {
                    var s = o[n];
                    i.prototype[s] = t(s)
                }
            }(), i.prototype.needsVerticalResizeLayout = function() {
                var e = t(this.isotope.element);
                return this.isotope.size && e && e.innerHeight !== this.isotope.size.innerHeight
            }, i.prototype._getMeasurement = function() {
                this.isotope._getMeasurement.apply(this, arguments)
            }, i.prototype.getColumnWidth = function() {
                this.getSegmentSize("column", "Width")
            }, i.prototype.getRowHeight = function() {
                this.getSegmentSize("row", "Height")
            }, i.prototype.getSegmentSize = function(t, e) {
                var i = t + e,
                    o = "outer" + e;
                if (this._getMeasurement(i, o), !this[i]) {
                    var n = this.getFirstItemSize();
                    this[i] = n && n[o] || this.isotope.size["inner" + e]
                }
            }, i.prototype.getFirstItemSize = function() {
                var e = this.isotope.filteredItems[0];
                return e && e.element && t(e.element)
            }, i.prototype.layout = function() {
                this.isotope.layout.apply(this.isotope, arguments)
            }, i.prototype.getSize = function() {
                this.isotope.getSize(), this.size = this.isotope.size
            }, i.modes = {}, i.create = function(t, e) {
                function o() {
                    i.apply(this, arguments)
                }
                return o.prototype = new i, e && (o.options = e), o.prototype.namespace = t, i.modes[t] = o, o
            }, i
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-mode", ["get-size/get-size", "outlayer/outlayer"], e) : (t.Isotope = t.Isotope || {}, t.Isotope.LayoutMode = e(t.getSize, t.Outlayer))
    }(window),
    function(t) {
        function e(t, e) {
            var o = t.create("masonry");
            return o.prototype._resetLayout = function() {
                this.getSize(), this._getMeasurement("columnWidth", "outerWidth"), this._getMeasurement("gutter", "outerWidth"), this.measureColumns();
                var t = this.cols;
                for (this.colYs = []; t--;) this.colYs.push(0);
                this.maxY = 0
            }, o.prototype.measureColumns = function() {
                if (this.getContainerWidth(), !this.columnWidth) {
                    var t = this.items[0],
                        i = t && t.element;
                    this.columnWidth = i && e(i).outerWidth || this.containerWidth
                }
                this.columnWidth += this.gutter, this.cols = Math.floor((this.containerWidth + this.gutter) / this.columnWidth), this.cols = Math.max(this.cols, 1)
            }, o.prototype.getContainerWidth = function() {
                var t = this.options.isFitWidth ? this.element.parentNode : this.element,
                    i = e(t);
                this.containerWidth = i && i.innerWidth
            }, o.prototype._getItemLayoutPosition = function(t) {
                t.getSize();
                var e = t.size.outerWidth % this.columnWidth,
                    o = Math[e && 1 > e ? "round" : "ceil"](t.size.outerWidth / this.columnWidth);
                o = Math.min(o, this.cols);
                for (var n = this._getColGroup(o), r = Math.min.apply(Math, n), s = i(n, r), a = {
                        x: this.columnWidth * s,
                        y: r
                    }, u = r + t.size.outerHeight, p = this.cols + 1 - n.length, h = 0; p > h; h++) this.colYs[s + h] = u;
                return a
            }, o.prototype._getColGroup = function(t) {
                if (2 > t) return this.colYs;
                for (var e = [], i = this.cols + 1 - t, o = 0; i > o; o++) {
                    var n = this.colYs.slice(o, o + t);
                    e[o] = Math.max.apply(Math, n)
                }
                return e
            }, o.prototype._manageStamp = function(t) {
                var i = e(t),
                    o = this._getElementOffset(t),
                    n = this.options.isOriginLeft ? o.left : o.right,
                    r = n + i.outerWidth,
                    s = Math.floor(n / this.columnWidth);
                s = Math.max(0, s);
                var a = Math.floor(r / this.columnWidth);
                a -= r % this.columnWidth ? 0 : 1, a = Math.min(this.cols - 1, a);
                for (var u = (this.options.isOriginTop ? o.top : o.bottom) + i.outerHeight, p = s; a >= p; p++) this.colYs[p] = Math.max(u, this.colYs[p])
            }, o.prototype._getContainerSize = function() {
                this.maxY = Math.max.apply(Math, this.colYs);
                var t = {
                    height: this.maxY
                };
                return this.options.isFitWidth && (t.width = this._getContainerFitWidth()), t
            }, o.prototype._getContainerFitWidth = function() {
                for (var t = 0, e = this.cols; --e && 0 === this.colYs[e];) t++;
                return (this.cols - t) * this.columnWidth - this.gutter
            }, o.prototype.needsResizeLayout = function() {
                var t = this.containerWidth;
                return this.getContainerWidth(), t !== this.containerWidth
            }, o
        }
        var i = Array.prototype.indexOf ? function(t, e) {
            return t.indexOf(e)
        } : function(t, e) {
            for (var i = 0, o = t.length; o > i; i++) {
                if (t[i] === e) return i
            }
            return -1
        };
        "function" == typeof define && define.amd ? define("masonry/masonry", ["outlayer/outlayer", "get-size/get-size"], e) : t.Masonry = e(t.Outlayer, t.getSize)
    }(window),
    function(t) {
        function e(t, e) {
            var i = t.create("masonry"),
                o = i.prototype._getElementOffset,
                n = i.prototype.layout,
                r = i.prototype._getMeasurement;
            (function(t, e) {
                for (var i in e) t[i] = e[i]
            })(i.prototype, e.prototype), i.prototype._getElementOffset = o, i.prototype.layout = n, i.prototype._getMeasurement = r;
            var s = i.prototype.measureColumns;
            i.prototype.measureColumns = function() {
                this.items = this.isotope.filteredItems, s.call(this)
            };
            var a = i.prototype._manageStamp;
            return i.prototype._manageStamp = function() {
                this.options.isOriginLeft = this.isotope.options.isOriginLeft, this.options.isOriginTop = this.isotope.options.isOriginTop, a.apply(this, arguments)
            }, i
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/masonry", ["../layout-mode", "masonry/masonry"], e) : e(t.Isotope.LayoutMode, t.Masonry)
    }(window),
    function(t) {
        function e(t) {
            var e = t.create("fitRows");
            return e.prototype._resetLayout = function() {
                this.x = 0, this.y = 0, this.maxY = 0
            }, e.prototype._getItemLayoutPosition = function(t) {
                t.getSize(), 0 !== this.x && t.size.outerWidth + this.x > this.isotope.size.innerWidth && (this.x = 0, this.y = this.maxY);
                var e = {
                    x: this.x,
                    y: this.y
                };
                return this.maxY = Math.max(this.maxY, this.y + t.size.outerHeight), this.x += t.size.outerWidth, e
            }, e.prototype._getContainerSize = function() {
                return {
                    height: this.maxY
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/fit-rows", ["../layout-mode"], e) : e(t.Isotope.LayoutMode)
    }(window),
    function(t) {
        function e(t) {
            var e = t.create("vertical", {
                horizontalAlignment: 0
            });
            return e.prototype._resetLayout = function() {
                this.y = 0
            }, e.prototype._getItemLayoutPosition = function(t) {
                t.getSize();
                var e = (this.isotope.size.innerWidth - t.size.outerWidth) * this.options.horizontalAlignment,
                    i = this.y;
                return this.y += t.size.outerHeight, {
                    x: e,
                    y: i
                }
            }, e.prototype._getContainerSize = function() {
                return {
                    height: this.y
                }
            }, e
        }
        "function" == typeof define && define.amd ? define("isotope/js/layout-modes/vertical", ["../layout-mode"], e) : e(t.Isotope.LayoutMode)
    }(window),
    function(t) {
        function e(t) {
            var e = [];
            if (function(t) {
                    return "[object Array]" === a.call(t)
                }(t)) e = t;
            else if (t && "number" == typeof t.length)
                for (var i = 0, o = t.length; o > i; i++) e.push(t[i]);
            else e.push(t);
            return e
        }

        function i(t, e) {
            var i = u(e, t); - 1 !== i && e.splice(i, 1)
        }

        function o(t, o, a, u, p) {
            var h = t.create("isotope", {
                layoutMode: "masonry",
                isJQueryFiltering: !0,
                sortAscending: !0
            });
            h.Item = u, h.LayoutMode = p, h.prototype._create = function() {
                for (var e in this.itemGUID = 0, this._sorters = {}, this._getSorters(), t.prototype._create.call(this), this.modes = {}, this.filteredItems = this.items, this.sortHistory = ["original-order"], p.modes) this._initLayoutMode(e)
            }, h.prototype.reloadItems = function() {
                this.itemGUID = 0, t.prototype.reloadItems.call(this)
            }, h.prototype._itemize = function() {
                for (var e = t.prototype._itemize.apply(this, arguments), i = 0, o = e.length; o > i; i++) {
                    e[i].id = this.itemGUID++
                }
                return this._updateItemsSortData(e), e
            }, h.prototype._initLayoutMode = function(t) {
                var e = p.modes[t],
                    i = this.options[t] || {};
                this.options[t] = e.options ? function(t, e) {
                    for (var i in e) t[i] = e[i];
                    return t
                }(e.options, i) : i, this.modes[t] = new e(this)
            }, h.prototype.layout = function() {
                return !this._isLayoutInited && this.options.isInitLayout ? void this.arrange() : void this._layout()
            }, h.prototype._layout = function() {
                var t = this._getIsInstant();
                this._resetLayout(), this._manageStamps(), this.layoutItems(this.filteredItems, t), this._isLayoutInited = !0
            }, h.prototype.arrange = function(t) {
                this.option(t), this._getIsInstant(), this.filteredItems = this._filter(this.items), this._sort(), this._layout()
            }, h.prototype._init = h.prototype.arrange, h.prototype._getIsInstant = function() {
                var t = void 0 !== this.options.isLayoutInstant ? this.options.isLayoutInstant : !this._isLayoutInited;
                return this._isInstant = t, t
            }, h.prototype._filter = function(t) {
                function e() {
                    f.reveal(n), f.hide(r)
                }
                var i = this.options.filter;
                i = i || "*";
                for (var o = [], n = [], r = [], s = this._getFilterTest(i), a = 0, u = t.length; u > a; a++) {
                    var p = t[a];
                    if (!p.isIgnored) {
                        var h = s(p);
                        h && o.push(p), h && p.isHidden ? n.push(p) : h || p.isHidden || r.push(p)
                    }
                }
                var f = this;
                return this._isInstant ? this._noTransition(e) : e(), o
            }, h.prototype._getFilterTest = function(t) {
                return n && this.options.isJQueryFiltering ? function(e) {
                    return n(e.element).is(t)
                } : "function" == typeof t ? function(e) {
                    return t(e.element)
                } : function(e) {
                    return a(e.element, t)
                }
            }, h.prototype.updateSortData = function(t) {
                this._getSorters(), t = e(t);
                var i = this.getItems(t);
                i = i.length ? i : this.items, this._updateItemsSortData(i)
            }, h.prototype._getSorters = function() {
                var t = this.options.getSortData;
                for (var e in t) {
                    var i = t[e];
                    this._sorters[e] = f(i)
                }
            }, h.prototype._updateItemsSortData = function(t) {
                for (var e = 0, i = t.length; i > e; e++) {
                    t[e].updateSortData()
                }
            };
            var f = function() {
                return function(t) {
                    if ("string" != typeof t) return t;
                    var e = r(t).split(" "),
                        i = e[0],
                        o = i.match(/^\[(.+)\]$/),
                        n = function(t, e) {
                            return t ? function(e) {
                                return e.getAttribute(t)
                            } : function(t) {
                                var i = t.querySelector(e);
                                return i && s(i)
                            }
                        }(o && o[1], i),
                        a = h.sortDataParsers[e[1]];
                    return a ? function(t) {
                        return t && a(n(t))
                    } : function(t) {
                        return t && n(t)
                    }
                }
            }();
            h.sortDataParsers = {
                parseInt: function(t) {
                    return parseInt(t, 10)
                },
                parseFloat: function(t) {
                    return parseFloat(t)
                }
            }, h.prototype._sort = function() {
                var t = this.options.sortBy;
                if (t) {
                    var e = function(t, e) {
                        return function(i, o) {
                            for (var n = 0, r = t.length; r > n; n++) {
                                var s = t[n],
                                    a = i.sortData[s],
                                    u = o.sortData[s];
                                if (a > u || u > a) return (a > u ? 1 : -1) * ((void 0 !== e[s] ? e[s] : e) ? 1 : -1)
                            }
                            return 0
                        }
                    }([].concat.apply(t, this.sortHistory), this.options.sortAscending);
                    this.filteredItems.sort(e), t !== this.sortHistory[0] && this.sortHistory.unshift(t)
                }
            }, h.prototype._mode = function() {
                var t = this.options.layoutMode,
                    e = this.modes[t];
                if (!e) throw Error("No layout mode: " + t);
                return e.options = this.options[t], e
            }, h.prototype._resetLayout = function() {
                t.prototype._resetLayout.call(this), this._mode()._resetLayout()
            }, h.prototype._getItemLayoutPosition = function(t) {
                return this._mode()._getItemLayoutPosition(t)
            }, h.prototype._manageStamp = function(t) {
                this._mode()._manageStamp(t)
            }, h.prototype._getContainerSize = function() {
                return this._mode()._getContainerSize()
            }, h.prototype.needsResizeLayout = function() {
                return this._mode().needsResizeLayout()
            }, h.prototype.appended = function(t) {
                var e = this.addItems(t);
                if (e.length) {
                    var i = this._filterRevealAdded(e);
                    this.filteredItems = this.filteredItems.concat(i)
                }
            }, h.prototype.prepended = function(t) {
                var e = this._itemize(t);
                if (e.length) {
                    var i = this.items.slice(0);
                    this.items = e.concat(i), this._resetLayout(), this._manageStamps();
                    var o = this._filterRevealAdded(e);
                    this.layoutItems(i), this.filteredItems = o.concat(this.filteredItems)
                }
            }, h.prototype._filterRevealAdded = function(t) {
                var e = this._noTransition(function() {
                    return this._filter(t)
                });
                return this.layoutItems(e, !0), this.reveal(e), t
            }, h.prototype.insert = function(t) {
                var e = this.addItems(t);
                if (e.length) {
                    var i, o, n = e.length;
                    for (i = 0; n > i; i++) o = e[i], this.element.appendChild(o.element);
                    var r = this._filter(e);
                    for (this._noTransition(function() {
                            this.hide(r)
                        }), i = 0; n > i; i++) e[i].isLayoutInstant = !0;
                    for (this.arrange(), i = 0; n > i; i++) delete e[i].isLayoutInstant;
                    this.reveal(r)
                }
            };
            var l = h.prototype.remove;
            return h.prototype.remove = function(t) {
                t = e(t);
                var o = this.getItems(t);
                if (l.call(this, t), o && o.length)
                    for (var n = 0, r = o.length; r > n; n++) {
                        i(o[n], this.filteredItems)
                    }
            }, h.prototype._noTransition = function(t) {
                var e = this.options.transitionDuration;
                this.options.transitionDuration = 0;
                var i = t.call(this);
                return this.options.transitionDuration = e, i
            }, h
        }
        var n = t.jQuery,
            r = String.prototype.trim ? function(t) {
                return t.trim()
            } : function(t) {
                return t.replace(/^\s+|\s+$/g, "")
            },
            s = document.documentElement.textContent ? function(t) {
                return t.textContent
            } : function(t) {
                return t.innerText
            },
            a = Object.prototype.toString,
            u = Array.prototype.indexOf ? function(t, e) {
                return t.indexOf(e)
            } : function(t, e) {
                for (var i = 0, o = t.length; o > i; i++)
                    if (t[i] === e) return i;
                return -1
            };
        "function" == typeof define && define.amd ? define(["outlayer/outlayer", "get-size/get-size", "matches-selector/matches-selector", "isotope/js/item", "isotope/js/layout-mode", "isotope/js/layout-modes/masonry", "isotope/js/layout-modes/fit-rows", "isotope/js/layout-modes/vertical"], o) : t.Isotope = o(t.Outlayer, t.getSize, t.matchesSelector, t.Isotope.Item, t.Isotope.LayoutMode)
    }(window), jQuery(window).load(function() {
        var t = {},
            e = jQuery(".stream");
        jQuery(".filter a").click(function() {
            var e, i, o = jQuery(this),
                n = [],
                r = o.parents(".dcsns-toolbar"),
                s = r.next(),
                a = jQuery(".stream", s);
            for (e in jQuery(".filter a", r).removeClass("iso-active"), o.addClass("iso-active"), t[o.data("group")] = o.data("filter"), t) n.push(t[e]);
            return i = n.join(""), a.isotope({
                filter: i,
                sortBy: "postDate"
            }), !1
        }), jQuery.each(e, function() {
            jQuery("li .section-thumb img, li .section-text img", jQuery(this)).css("opacity", 0).show().fadeTo(800, 1), jQuery(this).isotope("layout")
        })
    }), $(document).ready(function() {
        $("button").click(function() {
            $(".link-all").addClass("iso-active")
        })
    }), $(window).scroll(function() {
        $(this).scrollTop() > 2 ? $(".link-all").addClass("iso-active") : $(".link-all").removeClass("iso-active")
    });

MMCT - 2023