text: // Avoid `console` errors in browsers that lack a console.
  (function() {
    var method;
    var noop = function noop() {};
    var methods = [
      'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
      'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
      'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
      'timeStamp', 'trace', 'warn'
    ];
    var length = methods.length;
    var console = (window.console = window.console || {});
    while (length--) {
      method = methods[length];
      // Only stub undefined methods.
      if (!console[method]) {
        console[method] = noop;
      }
    }
  }());
  
  /**
   * Owl Carousel v2.2.1
   * Copyright 2013-2017 David Deutsch
   * Licensed under  ()
   */
  ! function(a, b, c, d) {
    function e(b, c) {
      this.settings = null, this.options = a.extend({}, e.Defaults, c), this.$element = a(b), 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"]
        }
      }, a.each(["onResize", "onThrottledResize"], a.proxy(function(b, c) {
        this._handlers[c] = a.proxy(this[c], this)
      }, this)), a.each(e.Plugins, a.proxy(function(a, b) {
        this._plugins[a.charAt(0).toLowerCase() + a.slice(1)] = new b(this)
      }, this)), a.each(e.Workers, a.proxy(function(b, c) {
        this._pipe.push({
          filter: c.filter,
          run: a.proxy(c.run, this)
        })
      }, this)), this.setup(), this.initialize()
    }
    e.Defaults = {
      items: 3,
      loop: !1,
      center: !1,
      rewind: !1,
      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: b,
      fallbackEasing: "swing",
      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"
    }, e.Width = {
      Default: "default",
      Inner: "inner",
      Outer: "outer"
    }, e.Type = {
      Event: "event",
      State: "state"
    }, e.Plugins = {}, e.Workers = [{
      filter: ["width", "settings"],
      run: function() {
        this._width = this.$element.width()
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function(a) {
        a.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(a) {
        var b = this.settings.margin || "",
          c = !this.settings.autoWidth,
          d = this.settings.rtl,
          e = {
            width: "auto",
            "margin-left": d ? b : "",
            "margin-right": d ? "" : b
          };
        !c && this.$stage.children().css(e), a.css = e
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function(a) {
        var b = (this.width() / this.settings.items).toFixed(3) - this.settings.margin,
          c = null,
          d = this._items.length,
          e = !this.settings.autoWidth,
          f = [];
        for (a.items = {
            merge: !1,
            width: b
          }; d--;) c = this._mergers[d], c = this.settings.mergeFit && Math.min(c, this.settings.items) || c, a.items.merge = c > 1 || a.items.merge, f[d] = e ? b * c : this._items[d].width();
        this._widths = f
      }
    }, {
      filter: ["items", "settings"],
      run: function() {
        var b = [],
          c = this._items,
          d = this.settings,
          e = Math.max(2 * d.items, 4),
          f = 2 * Math.ceil(c.length / 2),
          g = d.loop && c.length ? d.rewind ? e : Math.max(e, f) : 0,
          h = "",
          i = "";
        for (g /= 2; g--;) b.push(this.normalize(b.length / 2, !0)), h += c[b[b.length - 1]][0].outerHTML, b.push(this.normalize(c.length - 1 - (b.length - 1) / 2, !0)), i = c[b[b.length - 1]][0].outerHTML + i;
        this._clones = b, a(h).addClass("cloned").appendTo(this.$stage), a(i).addClass("cloned").prependTo(this.$stage)
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function() {
        for (var a = this.settings.rtl ? 1 : -1, b = this._clones.length + this._items.length, c = -1, d = 0, e = 0, f = []; ++c < b;) d = f[c - 1] || 0, e = this._widths[this.relative(c)] + this.settings.margin, f.push(d + e * a);
        this._coordinates = f
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function() {
        var a = this.settings.stagePadding,
          b = this._coordinates,
          c = {
            width: Math.ceil(Math.abs(b[b.length - 1])) + 2 * a,
            "padding-left": a || "",
            "padding-right": a || ""
          };
        this.$stage.css(c)
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function(a) {
        var b = this._coordinates.length,
          c = !this.settings.autoWidth,
          d = this.$stage.children();
        if (c && a.items.merge)
          for (; b--;) a.css.width = this._widths[this.relative(b)], d.eq(b).css(a.css);
        else c && (a.css.width = a.items.width, d.css(a.css))
      }
    }, {
      filter: ["items"],
      run: function() {
        this._coordinates.length < 1 && this.$stage.removeAttr("style")
      }
    }, {
      filter: ["width", "items", "settings"],
      run: function(a) {
        a.current = a.current ? this.$stage.children().index(a.current) : 0, a.current = Math.max(this.minimum(), Math.min(this.maximum(), a.current)), this.reset(a.current)
      }
    }, {
      filter: ["position"],
      run: function() {
        this.animate(this.coordinates(this._current))
      }
    }, {
      filter: ["width", "position", "items", "settings"],
      run: function() {
        var a, b, c, d, e = this.settings.rtl ? 1 : -1,
          f = 2 * this.settings.stagePadding,
          g = this.coordinates(this.current()) + f,
          h = g + this.width() * e,
          i = [];
        for (c = 0, d = this._coordinates.length; c < d; c++) a = this._coordinates[c - 1] || 0, b = Math.abs(this._coordinates[c]) + f * e, (this.op(a, "<=", g) && this.op(a, ">", h) || this.op(b, "<", g) && this.op(b, ">", h)) && i.push(c);
        this.$stage.children(".active").removeClass("active"), this.$stage.children(":eq(" + i.join("), :eq(") + ")").addClass("active"), this.settings.center && (this.$stage.children(".center").removeClass("center"), this.$stage.children().eq(this.current()).addClass("center"))
      }
    }], e.prototype.initialize = function() {
      if (this.enter("initializing"), this.trigger("initialize"), this.$element.toggleClass(this.settings.rtlClass, this.settings.rtl), this.settings.autoWidth && !this.is("pre-loading")) {
        var b, c, e;
        b = this.$element.find("img"), c = this.settings.nestedItemSelector ? "." + this.settings.nestedItemSelector : d, e = this.$element.children(c).width(), b.length && e <= 0 && this.preloadAutoWidthImages(b)
      }
      this.$element.addClass(this.options.loadingClass), this.$stage = a("<" + this.settings.stageElement + ' class="' + this.settings.stageClass + '"/>').wrap('<div class="' + this.settings.stageOuterClass + '"/>'), this.$element.append(this.$stage.parent()), this.replace(this.$element.children().not(this.$stage.parent())), this.$element.is(":visible") ? this.refresh() : this.invalidate("width"), this.$element.removeClass(this.options.loadingClass).addClass(this.options.loadedClass), this.registerEventHandlers(), this.leave("initializing"), this.trigger("initialized")
    }, e.prototype.setup = function() {
      var b = this.viewport(),
        c = this.options.responsive,
        d = -1,
        e = null;
      c ? (a.each(c, function(a) {
        a <= b && a > d && (d = Number(a))
      }), e = a.extend({}, this.options, c[d]), "function" == typeof e.stagePadding && (e.stagePadding = e.stagePadding()), delete e.responsive, e.responsiveClass && this.$element.attr("class", this.$element.attr("class").replace(new RegExp("(" + this.options.responsiveClass + "-)\\S+\\s", "g"), "$1" + d))) : e = a.extend({}, this.options), this.trigger("change", {
        property: {
          name: "settings",
          value: e
        }
      }), this._breakpoint = d, this.settings = e, this.invalidate("settings"), this.trigger("changed", {
        property: {
          name: "settings",
          value: this.settings
        }
      })
    }, e.prototype.optionsLogic = function() {
      this.settings.autoWidth && (this.settings.stagePadding = !1, this.settings.merge = !1)
    }, e.prototype.prepare = function(b) {
      var c = this.trigger("prepare", {
        content: b
      });
      return c.data || (c.data = a("<" + this.settings.itemElement + "/>").addClass(this.options.itemClass).append(b)), this.trigger("prepared", {
        content: c.data
      }), c.data
    }, e.prototype.update = function() {
      for (var b = 0, c = this._pipe.length, d = a.proxy(function(a) {
          return this[a]
        }, this._invalidated), e = {}; b < c;)(this._invalidated.all || a.grep(this._pipe[b].filter, d).length > 0) && this._pipe[b].run(e), b++;
      this._invalidated = {}, !this.is("valid") && this.enter("valid")
    }, e.prototype.width = function(a) {
      switch (a = a || e.Width.Default) {
        case e.Width.Inner:
        case e.Width.Outer:
          return this._width;
        default:
          return this._width - 2 * this.settings.stagePadding + this.settings.margin
      }
    }, e.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")
    }, e.prototype.onThrottledResize = function() {
      b.clearTimeout(this.resizeTimer), this.resizeTimer = b.setTimeout(this._handlers.onResize, this.settings.responsiveRefreshRate)
    }, e.prototype.onResize = function() {
      return !!this._items.length && (this._width !== this.$element.width() && (!!this.$element.is(":visible") && (this.enter("resizing"), this.trigger("resize").isDefaultPrevented() ? (this.leave("resizing"), !1) : (this.invalidate("width"), this.refresh(), this.leave("resizing"), void this.trigger("resized")))))
    }, e.prototype.registerEventHandlers = function() {
      a.support.transition && this.$stage.on(a.support.transition.end + ".owl.core", a.proxy(this.onTransitionEnd, this)), this.settings.responsive !== !1 && this.on(b, "resize", this._handlers.onThrottledResize), this.settings.mouseDrag && (this.$element.addClass(this.options.dragClass), this.$stage.on("mousedown.owl.core", a.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", a.proxy(this.onDragStart, this)), this.$stage.on("touchcancel.owl.core", a.proxy(this.onDragEnd, this)))
    }, e.prototype.onDragStart = function(b) {
      var d = null;
      3 !== b.which && (a.support.transform ? (d = this.$stage.css("transform").replace(/.*\(|\)| /g, "").split(","), d = {
        x: d[16 === d.length ? 12 : 4],
        y: d[16 === d.length ? 13 : 5]
      }) : (d = this.$stage.position(), d = {
        x: this.settings.rtl ? d.left + this.$stage.width() - this.width() + this.settings.margin : d.left,
        y: d.top
      }), this.is("animating") && (a.support.transform ? this.animate(d.x) : this.$stage.stop(), this.invalidate("position")), this.$element.toggleClass(this.options.grabClass, "mousedown" === b.type), this.speed(0), this._drag.time = (new Date).getTime(), this._drag.target = a(b.target), this._drag.stage.start = d, this._drag.stage.current = d, this._drag.pointer = this.pointer(b), a(c).on("mouseup.owl.core touchend.owl.core", a.proxy(this.onDragEnd, this)), a(c).one("mousemove.owl.core touchmove.owl.core", a.proxy(function(b) {
        var d = this.difference(this._drag.pointer, this.pointer(b));
        a(c).on("mousemove.owl.core touchmove.owl.core", a.proxy(this.onDragMove, this)), Math.abs(d.x) < Math.abs(d.y) && this.is("valid") || (b.preventDefault(), this.enter("dragging"), this.trigger("drag"))
      }, this)))
    }, e.prototype.onDragMove = function(a) {
      var b = null,
        c = null,
        d = null,
        e = this.difference(this._drag.pointer, this.pointer(a)),
        f = this.difference(this._drag.stage.start, e);
      this.is("dragging") && (a.preventDefault(), this.settings.loop ? (b = this.coordinates(this.minimum()), c = this.coordinates(this.maximum() + 1) - b, f.x = ((f.x - b) % c + c) % c + b) : (b = this.settings.rtl ? this.coordinates(this.maximum()) : this.coordinates(this.minimum()), c = this.settings.rtl ? this.coordinates(this.minimum()) : this.coordinates(this.maximum()), d = this.settings.pullDrag ? -1 * e.x / 5 : 0, f.x = Math.max(Math.min(f.x, b + d), c + d)), this._drag.stage.current = f, this.animate(f.x))
    }, e.prototype.onDragEnd = function(b) {
      var d = this.difference(this._drag.pointer, this.pointer(b)),
        e = this._drag.stage.current,
        f = d.x > 0 ^ this.settings.rtl ? "left" : "right";
      a(c).off(".owl.core"), this.$element.removeClass(this.options.grabClass), (0 !== d.x && this.is("dragging") || !this.is("valid")) && (this.speed(this.settings.dragEndSpeed || this.settings.smartSpeed), this.current(this.closest(e.x, 0 !== d.x ? f : this._drag.direction)), this.invalidate("position"), this.update(), this._drag.direction = f, (Math.abs(d.x) > 3 || (new Date).getTime() - this._drag.time > 300) && this._drag.target.one("click.owl.core", function() {
        return !1
      })), this.is("dragging") && (this.leave("dragging"), this.trigger("dragged"))
    }, e.prototype.closest = function(b, c) {
      var d = -1,
        e = 30,
        f = this.width(),
        g = this.coordinates();
      return this.settings.freeDrag || a.each(g, a.proxy(function(a, h) {
        return "left" === c && b > h - e && b < h + e ? d = a : "right" === c && b > h - f - e && b < h - f + e ? d = a + 1 : this.op(b, "<", h) && this.op(b, ">", g[a + 1] || h - f) && (d = "left" === c ? a + 1 : a), d === -1
      }, this)), this.settings.loop || (this.op(b, ">", g[this.minimum()]) ? d = b = this.minimum() : this.op(b, "<", g[this.maximum()]) && (d = b = this.maximum())), d
    }, e.prototype.animate = function(b) {
      var c = this.speed() > 0;
      this.is("animating") && this.onTransitionEnd(), c && (this.enter("animating"), this.trigger("translate")), a.support.transform3d && a.support.transition ? this.$stage.css({
        transform: "translate3d(" + b + "px,0px,0px)",
        transition: this.speed() / 1e3 + "s"
      }) : c ? this.$stage.animate({
        left: b + "px"
      }, this.speed(), this.settings.fallbackEasing, a.proxy(this.onTransitionEnd, this)) : this.$stage.css({
        left: b + "px"
      })
    }, e.prototype.is = function(a) {
      return this._states.current[a] && this._states.current[a] > 0
    }, e.prototype.current = function(a) {
      if (a === d) return this._current;
      if (0 === this._items.length) return d;
      if (a = this.normalize(a), this._current !== a) {
        var b = this.trigger("change", {
          property: {
            name: "position",
            value: a
          }
        });
        b.data !== d && (a = this.normalize(b.data)), this._current = a, this.invalidate("position"), this.trigger("changed", {
          property: {
            name: "position",
            value: this._current
          }
        })
      }
      return this._current
    }, e.prototype.invalidate = function(b) {
      return "string" === a.type(b) && (this._invalidated[b] = !0, this.is("valid") && this.leave("valid")), a.map(this._invalidated, function(a, b) {
        return b
      })
    }, e.prototype.reset = function(a) {
      a = this.normalize(a), a !== d && (this._speed = 0, this._current = a, this.suppress(["translate", "translated"]), this.animate(this.coordinates(a)), this.release(["translate", "translated"]))
    }, e.prototype.normalize = function(a, b) {
      var c = this._items.length,
        e = b ? 0 : this._clones.length;
      return !this.isNumeric(a) || c < 1 ? a = d : (a < 0 || a >= c + e) && (a = ((a - e / 2) % c + c) % c + e / 2), a
    }, e.prototype.relative = function(a) {
      return a -= this._clones.length / 2, this.normalize(a, !0)
    }, e.prototype.maximum = function(a) {
      var b, c, d, e = this.settings,
        f = this._coordinates.length;
      if (e.loop) f = this._clones.length / 2 + this._items.length - 1;
      else if (e.autoWidth || e.merge) {
        for (b = this._items.length, c = this._items[--b].width(), d = this.$element.width(); b-- && (c += this._items[b].width() + this.settings.margin, !(c > d)););
        f = b + 1
      } else f = e.center ? this._items.length - 1 : this._items.length - e.items;
      return a && (f -= this._clones.length / 2), Math.max(f, 0)
    }, e.prototype.minimum = function(a) {
      return a ? 0 : this._clones.length / 2
    }, e.prototype.items = function(a) {
      return a === d ? this._items.slice() : (a = this.normalize(a, !0), this._items[a])
    }, e.prototype.mergers = function(a) {
      return a === d ? this._mergers.slice() : (a = this.normalize(a, !0), this._mergers[a])
    }, e.prototype.clones = function(b) {
      var c = this._clones.length / 2,
        e = c + this._items.length,
        f = function(a) {
          return a % 2 === 0 ? e + a / 2 : c - (a + 1) / 2
        };
      return b === d ? a.map(this._clones, function(a, b) {
        return f(b)
      }) : a.map(this._clones, function(a, c) {
        return a === b ? f(c) : null
      })
    }, e.prototype.speed = function(a) {
      return a !== d && (this._speed = a), this._speed
    }, e.prototype.coordinates = function(b) {
      var c, e = 1,
        f = b - 1;
      return b === d ? a.map(this._coordinates, a.proxy(function(a, b) {
        return this.coordinates(b)
      }, this)) : (this.settings.center ? (this.settings.rtl && (e = -1, f = b + 1), c = this._coordinates[b], c += (this.width() - c + (this._coordinates[f] || 0)) / 2 * e) : c = this._coordinates[f] || 0, c = Math.ceil(c))
    }, e.prototype.duration = function(a, b, c) {
      return 0 === c ? 0 : Math.min(Math.max(Math.abs(b - a), 1), 6) * Math.abs(c || this.settings.smartSpeed)
    }, e.prototype.to = function(a, b) {
      var c = this.current(),
        d = null,
        e = a - this.relative(c),
        f = (e > 0) - (e < 0),
        g = this._items.length,
        h = this.minimum(),
        i = this.maximum();
      this.settings.loop ? (!this.settings.rewind && Math.abs(e) > g / 2 && (e += f * -1 * g), a = c + e, d = ((a - h) % g + g) % g + h, d !== a && d - e <= i && d - e > 0 && (c = d - e, a = d, this.reset(c))) : this.settings.rewind ? (i += 1, a = (a % i + i) % i) : a = Math.max(h, Math.min(i, a)), this.speed(this.duration(c, a, b)), this.current(a), this.$element.is(":visible") && this.update()
    }, e.prototype.next = function(a) {
      a = a || !1, this.to(this.relative(this.current()) + 1, a)
    }, e.prototype.prev = function(a) {
      a = a || !1, this.to(this.relative(this.current()) - 1, a)
    }, e.prototype.onTransitionEnd = function(a) {
      if (a !== d && (a.stopPropagation(), (a.target || a.srcElement || a.originalTarget) !== this.$stage.get(0))) return !1;
      this.leave("animating"), this.trigger("translated")
    }, e.prototype.viewport = function() {
      var d;
      return this.options.responsiveBaseElement !== b ? d = a(this.options.responsiveBaseElement).width() : b.innerWidth ? d = b.innerWidth : c.documentElement && c.documentElement.clientWidth ? d = c.documentElement.clientWidth : console.warn("Can not detect viewport width."), d
    }, e.prototype.replace = function(b) {
      this.$stage.empty(), this._items = [], b && (b = b instanceof jQuery ? b : a(b)), this.settings.nestedItemSelector && (b = b.find("." + this.settings.nestedItemSelector)), b.filter(function() {
        return 1 === this.nodeType
      }).each(a.proxy(function(a, b) {
        b = this.prepare(b), this.$stage.append(b), this._items.push(b), this._mergers.push(1 * b.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")
    }, e.prototype.add = function(b, c) {
      var e = this.relative(this._current);
      c = c === d ? this._items.length : this.normalize(c, !0), b = b instanceof jQuery ? b : a(b), this.trigger("add", {
        content: b,
        position: c
      }), b = this.prepare(b), 0 === this._items.length || c === this._items.length ? (0 === this._items.length && this.$stage.append(b), 0 !== this._items.length && this._items[c - 1].after(b), this._items.push(b), this._mergers.push(1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)) : (this._items[c].before(b), this._items.splice(c, 0, b), this._mergers.splice(c, 0, 1 * b.find("[data-merge]").addBack("[data-merge]").attr("data-merge") || 1)), this._items[e] && this.reset(this._items[e].index()), this.invalidate("items"), this.trigger("added", {
        content: b,
        position: c
      })
    }, e.prototype.remove = function(a) {
      a = this.normalize(a, !0), a !== d && (this.trigger("remove", {
        content: this._items[a],
        position: a
      }), this._items[a].remove(), this._items.splice(a, 1), this._mergers.splice(a, 1), this.invalidate("items"), this.trigger("removed", {
        content: null,
        position: a
      }))
    }, e.prototype.preloadAutoWidthImages = function(b) {
      b.each(a.proxy(function(b, c) {
        this.enter("pre-loading"), c = a(c), a(new Image).one("load", a.proxy(function(a) {
          c.attr("src", a.target.src), c.css("opacity", 1), this.leave("pre-loading"), !this.is("pre-loading") && !this.is("initializing") && this.refresh()
        }, this)).attr("src", c.attr("src") || c.attr("data-src") || c.attr("data-src-retina"))
      }, this))
    }, e.prototype.destroy = function() {
      this.$element.off(".owl.core"), this.$stage.off(".owl.core"), a(c).off(".owl.core"), this.settings.responsive !== !1 && (b.clearTimeout(this.resizeTimer), this.off(b, "resize", this._handlers.onThrottledResize));
      for (var d in this._plugins) this._plugins[d].destroy();
      this.$stage.children(".cloned").remove(), this.$stage.unwrap(), this.$stage.children().contents().unwrap(), this.$stage.children().unwrap(), 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")
    }, e.prototype.op = function(a, b, c) {
      var d = this.settings.rtl;
      switch (b) {
        case "<":
          return d ? a > c : a < c;
        case ">":
          return d ? a < c : a > c;
        case ">=":
          return d ? a <= c : a >= c;
        case "<=":
          return d ? a >= c : a <= c
      }
    }, e.prototype.on = function(a, b, c, d) {
      a.addEventListener ? a.addEventListener(b, c, d) : a.attachEvent && a.attachEvent("on" + b, c)
    }, e.prototype.off = function(a, b, c, d) {
      a.removeEventListener ? a.removeEventListener(b, c, d) : a.detachEvent && a.detachEvent("on" + b, c)
    }, e.prototype.trigger = function(b, c, d, f, g) {
      var h = {
          item: {
            count: this._items.length,
            index: this.current()
          }
        },
        i = a.camelCase(a.grep(["on", b, d], function(a) {
          return a
        }).join("-").toLowerCase()),
        j = a.Event([b, "owl", d || "carousel"].join(".").toLowerCase(), a.extend({
          relatedTarget: this
        }, h, c));
      return this._supress[b] || (a.each(this._plugins, function(a, b) {
        b.onTrigger && b.onTrigger(j)
      }), this.register({
        type: e.Type.Event,
        name: b
      }), this.$element.trigger(j), this.settings && "function" == typeof this.settings[i] && this.settings[i].call(this, j)), j
    }, e.prototype.enter = function(b) {
      a.each([b].concat(this._states.tags[b] || []), a.proxy(function(a, b) {
        this._states.current[b] === d && (this._states.current[b] = 0), this._states.current[b]++
      }, this))
    }, e.prototype.leave = function(b) {
      a.each([b].concat(this._states.tags[b] || []), a.proxy(function(a, b) {
        this._states.current[b]--
      }, this))
    }, e.prototype.register = function(b) {
      if (b.type === e.Type.Event) {
        if (a.event.special[b.name] || (a.event.special[b.name] = {}), !a.event.special[b.name].owl) {
          var c = a.event.special[b.name]._default;
          a.event.special[b.name]._default = function(a) {
            return !c || !c.apply || a.namespace && a.namespace.indexOf("owl") !== -1 ? a.namespace && a.namespace.indexOf("owl") > -1 : c.apply(this, arguments)
          }, a.event.special[b.name].owl = !0
        }
      } else b.type === e.Type.State && (this._states.tags[b.name] ? this._states.tags[b.name] = this._states.tags[b.name].concat(b.tags) : this._states.tags[b.name] = b.tags, this._states.tags[b.name] = a.grep(this._states.tags[b.name], a.proxy(function(c, d) {
        return a.inArray(c, this._states.tags[b.name]) === d
      }, this)))
    }, e.prototype.suppress = function(b) {
      a.each(b, a.proxy(function(a, b) {
        this._supress[b] = !0
      }, this))
    }, e.prototype.release = function(b) {
      a.each(b, a.proxy(function(a, b) {
        delete this._supress[b]
      }, this))
    }, e.prototype.pointer = function(a) {
      var c = {
        x: null,
        y: null
      };
      return a = a.originalEvent || a || b.event, a = a.touches && a.touches.length ? a.touches[0] : a.changedTouches && a.changedTouches.length ? a.changedTouches[0] : a, a.pageX ? (c.x = a.pageX, c.y = a.pageY) : (c.x = a.clientX, c.y = a.clientY), c
    }, e.prototype.isNumeric = function(a) {
      return !isNaN(parseFloat(a))
    }, e.prototype.difference = function(a, b) {
      return {
        x: a.x - b.x,
        y: a.y - b.y
      }
    }, a.fn.owlCarousel = function(b) {
      var c = Array.prototype.slice.call(arguments, 1);
      return this.each(function() {
        var d = a(this),
          f = d.data("owl.carousel");
        f || (f = new e(this, "object" == typeof b && b), d.data("owl.carousel", f), a.each(["next", "prev", "to", "destroy", "refresh", "replace", "add", "remove"], function(b, c) {
          f.register({
            type: e.Type.Event,
            name: c
          }), f.$element.on(c + ".owl.carousel.core", a.proxy(function(a) {
            a.namespace && a.relatedTarget !== this && (this.suppress([c]), f[c].apply(this, [].slice.call(arguments, 1)), this.release([c]))
          }, f))
        })), "string" == typeof b && "_" !== b.charAt(0) && f[b].apply(f, c)
      })
    }, a.fn.owlCarousel.Constructor = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this._core = b, this._interval = null, this._visible = null, this._handlers = {
        "initialized.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.autoRefresh && this.watch()
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this._core.$element.on(this._handlers)
    };
    e.Defaults = {
      autoRefresh: !0,
      autoRefreshInterval: 500
    }, e.prototype.watch = function() {
      this._interval || (this._visible = this._core.$element.is(":visible"), this._interval = b.setInterval(a.proxy(this.refresh, this), this._core.settings.autoRefreshInterval))
    }, e.prototype.refresh = function() {
      this._core.$element.is(":visible") !== this._visible && (this._visible = !this._visible, this._core.$element.toggleClass("owl-hidden", !this._visible), this._visible && this._core.invalidate("width") && this._core.refresh())
    }, e.prototype.destroy = function() {
      var a, c;
      b.clearInterval(this._interval);
      for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
      for (c in Object.getOwnPropertyNames(this)) "function" != typeof this[c] && (this[c] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.AutoRefresh = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this._core = b, this._loaded = [], this._handlers = {
        "initialized.owl.carousel change.owl.carousel resized.owl.carousel": a.proxy(function(b) {
          if (b.namespace && this._core.settings && this._core.settings.lazyLoad && (b.property && "position" == b.property.name || "initialized" == b.type))
            for (var c = this._core.settings, e = c.center && Math.ceil(c.items / 2) || c.items, f = c.center && e * -1 || 0, g = (b.property && b.property.value !== d ? b.property.value : this._core.current()) + f, h = this._core.clones().length, i = a.proxy(function(a, b) {
                this.load(b)
              }, this); f++ < e;) this.load(h / 2 + this._core.relative(g)), h && a.each(this._core.clones(this._core.relative(g)), i), g++
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this._core.$element.on(this._handlers)
    };
    e.Defaults = {
      lazyLoad: !1
    }, e.prototype.load = function(c) {
      var d = this._core.$stage.children().eq(c),
        e = d && d.find(".owl-lazy");
      !e || a.inArray(d.get(0), this._loaded) > -1 || (e.each(a.proxy(function(c, d) {
        var e, f = a(d),
          g = b.devicePixelRatio > 1 && f.attr("data-src-retina") || f.attr("data-src");
        this._core.trigger("load", {
          element: f,
          url: g
        }, "lazy"), f.is("img") ? f.one("load.owl.lazy", a.proxy(function() {
          f.css("opacity", 1), this._core.trigger("loaded", {
            element: f,
            url: g
          }, "lazy")
        }, this)).attr("src", g) : (e = new Image, e.onload = a.proxy(function() {
          f.css({
            "background-image": 'url("' + g + '")',
            opacity: "1"
          }), this._core.trigger("loaded", {
            element: f,
            url: g
          }, "lazy")
        }, this), e.src = g)
      }, this)), this._loaded.push(d.get(0)))
    }, e.prototype.destroy = function() {
      var a, b;
      for (a in this.handlers) this._core.$element.off(a, this.handlers[a]);
      for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.Lazy = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this._core = b, this._handlers = {
        "initialized.owl.carousel refreshed.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.autoHeight && this.update()
        }, this),
        "changed.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.autoHeight && "position" == a.property.name && this.update()
        }, this),
        "loaded.owl.lazy": a.proxy(function(a) {
          a.namespace && this._core.settings.autoHeight && a.element.closest("." + this._core.settings.itemClass).index() === this._core.current() && this.update()
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this._core.$element.on(this._handlers)
    };
    e.Defaults = {
      autoHeight: !1,
      autoHeightClass: "owl-height"
    }, e.prototype.update = function() {
      var b = this._core._current,
        c = b + this._core.settings.items,
        d = this._core.$stage.children().toArray().slice(b, c),
        e = [],
        f = 0;
      a.each(d, function(b, c) {
        e.push(a(c).height())
      }), f = Math.max.apply(null, e), this._core.$stage.parent().height(f).addClass(this._core.settings.autoHeightClass)
    }, e.prototype.destroy = function() {
      var a, b;
      for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
      for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.AutoHeight = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this._core = b, this._videos = {}, this._playing = null, this._handlers = {
        "initialized.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.register({
            type: "state",
            name: "playing",
            tags: ["interacting"]
          })
        }, this),
        "resize.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.video && this.isInFullScreen() && a.preventDefault()
        }, this),
        "refreshed.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.is("resizing") && this._core.$stage.find(".cloned .owl-video-frame").remove()
        }, this),
        "changed.owl.carousel": a.proxy(function(a) {
          a.namespace && "position" === a.property.name && this._playing && this.stop()
        }, this),
        "prepared.owl.carousel": a.proxy(function(b) {
          if (b.namespace) {
            var c = a(b.content).find(".owl-video");
            c.length && (c.css("display", "none"), this.fetch(c, a(b.content)))
          }
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this._core.$element.on(this._handlers), this._core.$element.on("click.owl.video", ".owl-video-play-icon", a.proxy(function(a) {
        this.play(a)
      }, this))
    };
    e.Defaults = {
      video: !1,
      videoHeight: !1,
      videoWidth: !1
    }, e.prototype.fetch = function(a, b) {
      var c = function() {
          return a.attr("data-vimeo-id") ? "vimeo" : a.attr("data-vzaar-id") ? "vzaar" : "youtube"
        }(),
        d = a.attr("data-vimeo-id") || a.attr("data-youtube-id") || a.attr("data-vzaar-id"),
        e = a.attr("data-width") || this._core.settings.videoWidth,
        f = a.attr("data-height") || this._core.settings.videoHeight,
        g = a.attr("href");
      if (!g) throw new Error("Missing video URL.");
      if (d = g.match(/(http:|https:|)\/\/(player.|www.|app.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com)|vzaar\.com)\/(video\/|videos\/|embed\/|channels\/.+\/|groups\/.+\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/), d[3].indexOf("youtu") > -1) c = "youtube";
      else if (d[3].indexOf("vimeo") > -1) c = "vimeo";
      else {
        if (!(d[3].indexOf("vzaar") > -1)) throw new Error("Video URL not supported.");
        c = "vzaar"
      }
      d = d[6], this._videos[g] = {
        type: c,
        id: d,
        width: e,
        height: f
      }, b.attr("data-video", g), this.thumbnail(a, this._videos[g])
    }, e.prototype.thumbnail = function(b, c) {
      var d, e, f, g = c.width && c.height ? 'style="width:' + c.width + "px;height:" + c.height + 'px;"' : "",
        h = b.find("img"),
        i = "src",
        j = "",
        k = this._core.settings,
        l = function(a) {
          e = '<div class="owl-video-play-icon"></div>', d = k.lazyLoad ? '<div class="owl-video-tn ' + j + '" ' + i + '="' + a + '"></div>' : '<div class="owl-video-tn" style="opacity:1;background-image:url(' + a + ')"></div>', b.after(d), b.after(e)
        };
      if (b.wrap('<div class="owl-video-wrapper"' + g + "></div>"), this._core.settings.lazyLoad && (i = "data-src", j = "owl-lazy"), h.length) return l(h.attr(i)), h.remove(), !1;
      "youtube" === c.type ? (f = "//img.youtube.com/vi/" + c.id + "/hqdefault.jpg", l(f)) : "vimeo" === c.type ? a.ajax({
        type: "GET",
        url: "//vimeo.com/api/v2/video/" + c.id + ".json",
        jsonp: "callback",
        dataType: "jsonp",
        success: function(a) {
          f = a[0].thumbnail_large, l(f)
        }
      }) : "vzaar" === c.type && a.ajax({
        type: "GET",
        url: "//vzaar.com/api/videos/" + c.id + ".json",
        jsonp: "callback",
        dataType: "jsonp",
        success: function(a) {
          f = a.framegrab_url, l(f)
        }
      })
    }, e.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")
    }, e.prototype.play = function(b) {
      var c, d = a(b.target),
        e = d.closest("." + this._core.settings.itemClass),
        f = this._videos[e.attr("data-video")],
        g = f.width || "100%",
        h = f.height || this._core.$stage.height();
      this._playing || (this._core.enter("playing"), this._core.trigger("play", null, "video"), e = this._core.items(this._core.relative(e.index())), this._core.reset(e.index()), "youtube" === f.type ? c = '<iframe width="' + g + '" height="' + h + '" src="//www.youtube.com/embed/' + f.id + "?autoplay=1&rel=0&v=" + f.id + '" frameborder="0" allowfullscreen></iframe>' : "vimeo" === f.type ? c = '<iframe src="//player.vimeo.com/video/' + f.id + '?autoplay=1" width="' + g + '" height="' + h + '" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe>' : "vzaar" === f.type && (c = '<iframe frameborder="0"height="' + h + '"width="' + g + '" allowfullscreen mozallowfullscreen webkitAllowFullScreen src="//view.vzaar.com/' + f.id + '/player?autoplay=true"></iframe>'), a('<div class="owl-video-frame">' + c + "</div>").insertAfter(e.find(".owl-video")), this._playing = e.addClass("owl-video-playing"))
    }, e.prototype.isInFullScreen = function() {
      var b = c.fullscreenElement || c.mozFullScreenElement || c.webkitFullscreenElement;
      return b && a(b).parent().hasClass("owl-video-frame")
    }, e.prototype.destroy = function() {
      var a, b;
      this._core.$element.off("click.owl.video");
      for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
      for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.Video = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this.core = b, this.core.options = a.extend({}, e.Defaults, this.core.options), this.swapping = !0, this.previous = d, this.next = d, this.handlers = {
        "change.owl.carousel": a.proxy(function(a) {
          a.namespace && "position" == a.property.name && (this.previous = this.core.current(), this.next = a.property.value)
        }, this),
        "drag.owl.carousel dragged.owl.carousel translated.owl.carousel": a.proxy(function(a) {
          a.namespace && (this.swapping = "translated" == a.type)
        }, this),
        "translate.owl.carousel": a.proxy(function(a) {
          a.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 && a.support.animation && a.support.transition) {
          this.core.speed(0);
          var b, c = a.proxy(this.clear, this),
            d = this.core.$stage.children().eq(this.previous),
            e = this.core.$stage.children().eq(this.next),
            f = this.core.settings.animateIn,
            g = this.core.settings.animateOut;
          this.core.current() !== this.previous && (g && (b = this.core.coordinates(this.previous) - this.core.coordinates(this.next), d.one(a.support.animation.end, c).css({
            left: b + "px"
          }).addClass("animated owl-animated-out").addClass(g)), f && e.one(a.support.animation.end, c).addClass("animated owl-animated-in").addClass(f))
        }
      }, e.prototype.clear = function(b) {
        a(b.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 a, b;
        for (a in this.handlers) this.core.$element.off(a, this.handlers[a]);
        for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null)
      },
      a.fn.owlCarousel.Constructor.Plugins.Animate = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    var e = function(b) {
      this._core = b, this._timeout = null, this._paused = !1, this._handlers = {
        "changed.owl.carousel": a.proxy(function(a) {
          a.namespace && "settings" === a.property.name ? this._core.settings.autoplay ? this.play() : this.stop() : a.namespace && "position" === a.property.name && this._core.settings.autoplay && this._setAutoPlayInterval()
        }, this),
        "initialized.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.autoplay && this.play()
        }, this),
        "play.owl.autoplay": a.proxy(function(a, b, c) {
          a.namespace && this.play(b, c)
        }, this),
        "stop.owl.autoplay": a.proxy(function(a) {
          a.namespace && this.stop()
        }, this),
        "mouseover.owl.autoplay": a.proxy(function() {
          this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.pause()
        }, this),
        "mouseleave.owl.autoplay": a.proxy(function() {
          this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.play()
        }, this),
        "touchstart.owl.core": a.proxy(function() {
          this._core.settings.autoplayHoverPause && this._core.is("rotating") && this.pause()
        }, this),
        "touchend.owl.core": a.proxy(function() {
          this._core.settings.autoplayHoverPause && this.play()
        }, this)
      }, this._core.$element.on(this._handlers), this._core.options = a.extend({}, e.Defaults, this._core.options)
    };
    e.Defaults = {
      autoplay: !1,
      autoplayTimeout: 5e3,
      autoplayHoverPause: !1,
      autoplaySpeed: !1
    }, e.prototype.play = function(a, b) {
      this._paused = !1, this._core.is("rotating") || (this._core.enter("rotating"), this._setAutoPlayInterval())
    }, e.prototype._getNextTimeout = function(d, e) {
      return this._timeout && b.clearTimeout(this._timeout), b.setTimeout(a.proxy(function() {
        this._paused || this._core.is("busy") || this._core.is("interacting") || c.hidden || this._core.next(e || this._core.settings.autoplaySpeed)
      }, this), d || this._core.settings.autoplayTimeout)
    }, e.prototype._setAutoPlayInterval = function() {
      this._timeout = this._getNextTimeout()
    }, e.prototype.stop = function() {
      this._core.is("rotating") && (b.clearTimeout(this._timeout), this._core.leave("rotating"))
    }, e.prototype.pause = function() {
      this._core.is("rotating") && (this._paused = !0)
    }, e.prototype.destroy = function() {
      var a, b;
      this.stop();
      for (a in this._handlers) this._core.$element.off(a, this._handlers[a]);
      for (b in Object.getOwnPropertyNames(this)) "function" != typeof this[b] && (this[b] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.autoplay = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    "use strict";
    var e = function(b) {
      this._core = b, 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": a.proxy(function(b) {
          b.namespace && this._core.settings.dotsData && this._templates.push('<div class="' + this._core.settings.dotClass + '">' + a(b.content).find("[data-dot]").addBack("[data-dot]").attr("data-dot") + "</div>")
        }, this),
        "added.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 0, this._templates.pop())
        }, this),
        "remove.owl.carousel": a.proxy(function(a) {
          a.namespace && this._core.settings.dotsData && this._templates.splice(a.position, 1)
        }, this),
        "changed.owl.carousel": a.proxy(function(a) {
          a.namespace && "position" == a.property.name && this.draw()
        }, this),
        "initialized.owl.carousel": a.proxy(function(a) {
          a.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": a.proxy(function(a) {
          a.namespace && this._initialized && (this._core.trigger("refresh", null, "navigation"), this.update(), this.draw(), this._core.trigger("refreshed", null, "navigation"))
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers)
    };
    e.Defaults = {
      nav: !1,
      navText: ["prev", "next"],
      navSpeed: !1,
      navElement: "div",
      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 b, c = this._core.settings;
      this._controls.$relative = (c.navContainer ? a(c.navContainer) : a("<div>").addClass(c.navContainerClass).appendTo(this.$element)).addClass("disabled"), this._controls.$previous = a("<" + c.navElement + ">").addClass(c.navClass[0]).html(c.navText[0]).prependTo(this._controls.$relative).on("click", a.proxy(function(a) {
        this.prev(c.navSpeed)
      }, this)), this._controls.$next = a("<" + c.navElement + ">").addClass(c.navClass[1]).html(c.navText[1]).appendTo(this._controls.$relative).on("click", a.proxy(function(a) {
        this.next(c.navSpeed)
      }, this)), c.dotsData || (this._templates = [a("<div>").addClass(c.dotClass).append(a("<span>")).prop("outerHTML")]), this._controls.$absolute = (c.dotsContainer ? a(c.dotsContainer) : a("<div>").addClass(c.dotsClass).appendTo(this.$element)).addClass("disabled"), this._controls.$absolute.on("click", "div", a.proxy(function(b) {
        var d = a(b.target).parent().is(this._controls.$absolute) ? a(b.target).index() : a(b.target).parent().index();
        b.preventDefault(), this.to(d, c.dotsSpeed)
      }, this));
      for (b in this._overrides) this._core[b] = a.proxy(this[b], this)
    }, e.prototype.destroy = function() {
      var a, b, c, d;
      for (a in this._handlers) this.$element.off(a, this._handlers[a]);
      for (b in this._controls) this._controls[b].remove();
      for (d in this.overides) this._core[d] = this._overrides[d];
      for (c in Object.getOwnPropertyNames(this)) "function" != typeof this[c] && (this[c] = null)
    }, e.prototype.update = function() {
      var a, b, c, d = this._core.clones().length / 2,
        e = d + this._core.items().length,
        f = this._core.maximum(!0),
        g = this._core.settings,
        h = g.center || g.autoWidth || g.dotsData ? 1 : g.dotsEach || g.items;
      if ("page" !== g.slideBy && (g.slideBy = Math.min(g.slideBy, g.items)), g.dots || "page" == g.slideBy)
        for (this._pages = [], a = d, b = 0, c = 0; a < e; a++) {
          if (b >= h || 0 === b) {
            if (this._pages.push({
                start: Math.min(f, a - d),
                end: a - d + h - 1
              }), Math.min(f, a - d) === f) break;
            b = 0, ++c
          }
          b += this._core.mergers(this._core.relative(a))
        }
    }, e.prototype.draw = function() {
      var b, c = this._core.settings,
        d = this._core.items().length <= c.items,
        e = this._core.relative(this._core.current()),
        f = c.loop || c.rewind;
      this._controls.$relative.toggleClass("disabled", !c.nav || d), c.nav && (this._controls.$previous.toggleClass("disabled", !f && e <= this._core.minimum(!0)), this._controls.$next.toggleClass("disabled", !f && e >= this._core.maximum(!0))), this._controls.$absolute.toggleClass("disabled", !c.dots || d), c.dots && (b = this._pages.length - this._controls.$absolute.children().length, c.dotsData && 0 !== b ? this._controls.$absolute.html(this._templates.join("")) : b > 0 ? this._controls.$absolute.append(new Array(b + 1).join(this._templates[0])) : b < 0 && this._controls.$absolute.children().slice(b).remove(), this._controls.$absolute.find(".active").removeClass("active"), this._controls.$absolute.children().eq(a.inArray(this.current(), this._pages)).addClass("active"))
    }, e.prototype.onTrigger = function(b) {
      var c = this._core.settings;
      b.page = {
        index: a.inArray(this.current(), this._pages),
        count: this._pages.length,
        size: c && (c.center || c.autoWidth || c.dotsData ? 1 : c.dotsEach || c.items)
      }
    }, e.prototype.current = function() {
      var b = this._core.relative(this._core.current());
      return a.grep(this._pages, a.proxy(function(a, c) {
        return a.start <= b && a.end >= b
      }, this)).pop()
    }, e.prototype.getPosition = function(b) {
      var c, d, e = this._core.settings;
      return "page" == e.slideBy ? (c = a.inArray(this.current(), this._pages), d = this._pages.length, b ? ++c : --c, c = this._pages[(c % d + d) % d].start) : (c = this._core.relative(this._core.current()), d = this._core.items().length, b ? c += e.slideBy : c -= e.slideBy), c
    }, e.prototype.next = function(b) {
      a.proxy(this._overrides.to, this._core)(this.getPosition(!0), b)
    }, e.prototype.prev = function(b) {
      a.proxy(this._overrides.to, this._core)(this.getPosition(!1), b)
    }, e.prototype.to = function(b, c, d) {
      var e;
      !d && this._pages.length ? (e = this._pages.length, a.proxy(this._overrides.to, this._core)(this._pages[(b % e + e) % e].start, c)) : a.proxy(this._overrides.to, this._core)(b, c)
    }, a.fn.owlCarousel.Constructor.Plugins.Navigation = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    "use strict";
    var e = function(c) {
      this._core = c, this._hashes = {}, this.$element = this._core.$element, this._handlers = {
        "initialized.owl.carousel": a.proxy(function(c) {
          c.namespace && "URLHash" === this._core.settings.startPosition && a(b).trigger("hashchange.owl.navigation")
        }, this),
        "prepared.owl.carousel": a.proxy(function(b) {
          if (b.namespace) {
            var c = a(b.content).find("[data-hash]").addBack("[data-hash]").attr("data-hash");
            if (!c) return;
            this._hashes[c] = b.content
          }
        }, this),
        "changed.owl.carousel": a.proxy(function(c) {
          if (c.namespace && "position" === c.property.name) {
            var d = this._core.items(this._core.relative(this._core.current())),
              e = a.map(this._hashes, function(a, b) {
                return a === d ? b : null
              }).join();
            if (!e || b.location.hash.slice(1) === e) return;
            b.location.hash = e
          }
        }, this)
      }, this._core.options = a.extend({}, e.Defaults, this._core.options), this.$element.on(this._handlers), a(b).on("hashchange.owl.navigation", a.proxy(function(a) {
        var c = b.location.hash.substring(1),
          e = this._core.$stage.children(),
          f = this._hashes[c] && e.index(this._hashes[c]);
        f !== d && f !== this._core.current() && this._core.to(this._core.relative(f), !1, !0)
      }, this))
    };
    e.Defaults = {
      URLhashListener: !1
    }, e.prototype.destroy = function() {
      var c, d;
      a(b).off("hashchange.owl.navigation");
      for (c in this._handlers) this._core.$element.off(c, this._handlers[c]);
      for (d in Object.getOwnPropertyNames(this)) "function" != typeof this[d] && (this[d] = null)
    }, a.fn.owlCarousel.Constructor.Plugins.Hash = e
  }(window.Zepto || window.jQuery, window, document),
  function(a, b, c, d) {
    function e(b, c) {
      var e = !1,
        f = b.charAt(0).toUpperCase() + b.slice(1);
      return a.each((b + " " + h.join(f + " ") + f).split(" "), function(a, b) {
        if (g[b] !== d) return e = !c || b, !1
      }), e
    }
  
    function f(a) {
      return e(a, !0)
    }
    var g = a("<support>").get(0).style,
      h = "Webkit Moz O ms".split(" "),
      i = {
        transition: {
          end: {
            WebkitTransition: "webkitTransitionEnd",
            MozTransition: "transitionend",
            OTransition: "oTransitionEnd",
            transition: "transitionend"
          }
        },
        animation: {
          end: {
            WebkitAnimation: "webkitAnimationEnd",
            MozAnimation: "animationend",
            OAnimation: "oAnimationEnd",
            animation: "animationend"
          }
        }
      },
      j = {
        csstransforms: function() {
          return !!e("transform")
        },
        csstransforms3d: function() {
          return !!e("perspective")
        },
        csstransitions: function() {
          return !!e("transition")
        },
        cssanimations: function() {
          return !!e("animation")
        }
      };
    j.csstransitions() && (a.support.transition = new String(f("transition")), a.support.transition.end = i.transition.end[a.support.transition]), j.cssanimations() && (a.support.animation = new String(f("animation")), a.support.animation.end = i.animation.end[a.support.animation]), j.csstransforms() && (a.support.transform = new String(f("transform")), a.support.transform3d = j.csstransforms3d())
  }(window.Zepto || window.jQuery, window, document);
  
  /*! Magnific Popup - v1.1.0 - 2016-02-20
   * http://dimsemenov.com/plugins/magnific-popup/
   * Copyright (c) 2016 Dmitry Semenov; */
  ! function(a) {
    "function" == typeof define && define.amd ? define(["jquery"], a) : a("object" == typeof exports ? require("jquery") : window.jQuery || window.Zepto)
  }(function(a) {
    var b, c, d, e, f, g, h = "Close",
      i = "BeforeClose",
      j = "AfterClose",
      k = "BeforeAppend",
      l = "MarkupParse",
      m = "Open",
      n = "Change",
      o = "mfp",
      p = "." + o,
      q = "mfp-ready",
      r = "mfp-removing",
      s = "mfp-prevent-close",
      t = function() {},
      u = !!window.jQuery,
      v = a(window),
      w = function(a, c) {
        b.ev.on(o + a + p, c)
      },
      x = function(b, c, d, e) {
        var f = document.createElement("div");
        return f.className = "mfp-" + b, d && (f.innerHTML = d), e ? c && c.appendChild(f) : (f = a(f), c && f.appendTo(c)), f
      },
      y = function(c, d) {
        b.ev.triggerHandler(o + c, d), b.st.callbacks && (c = c.charAt(0).toLowerCase() + c.slice(1), b.st.callbacks[c] && b.st.callbacks[c].apply(b, a.isArray(d) ? d : [d]))
      },
      z = function(c) {
        return c === g && b.currTemplate.closeBtn || (b.currTemplate.closeBtn = a(b.st.closeMarkup.replace("%title%", b.st.tClose)), g = c), b.currTemplate.closeBtn
      },
      A = function() {
        a.magnificPopup.instance || (b = new t, b.init(), a.magnificPopup.instance = b)
      },
      B = function() {
        var a = document.createElement("p").style,
          b = ["ms", "O", "Moz", "Webkit"];
        if (void 0 !== a.transition) return !0;
        for (; b.length;)
          if (b.pop() + "Transition" in a) return !0;
        return !1
      };
    t.prototype = {
      constructor: t,
      init: function() {
        var c = navigator.appVersion;
        b.isLowIE = b.isIE8 = document.all && !document.addEventListener, b.isAndroid = /android/gi.test(c), b.isIOS = /iphone|ipad|ipod/gi.test(c), b.supportsTransition = B(), b.probablyMobile = b.isAndroid || b.isIOS || /(Opera Mini)|Kindle|webOS|BlackBerry|(Opera Mobi)|(Windows Phone)|IEMobile/i.test(navigator.userAgent), d = a(document), b.popupsCache = {}
      },
      open: function(c) {
        var e;
        if (c.isObj === !1) {
          b.items = c.items.toArray(), b.index = 0;
          var g, h = c.items;
          for (e = 0; e < h.length; e++)
            if (g = h[e], g.parsed && (g = g.el[0]), g === c.el[0]) {
              b.index = e;
              break
            }
        } else b.items = a.isArray(c.items) ? c.items : [c.items], b.index = c.index || 0;
        if (b.isOpen) return void b.updateItemHTML();
        b.types = [], f = "", c.mainEl && c.mainEl.length ? b.ev = c.mainEl.eq(0) : b.ev = d, c.key ? (b.popupsCache[c.key] || (b.popupsCache[c.key] = {}), b.currTemplate = b.popupsCache[c.key]) : b.currTemplate = {}, b.st = a.extend(!0, {}, a.magnificPopup.defaults, c), b.fixedContentPos = "auto" === b.st.fixedContentPos ? !b.probablyMobile : b.st.fixedContentPos, b.st.modal && (b.st.closeOnContentClick = !1, b.st.closeOnBgClick = !1, b.st.showCloseBtn = !1, b.st.enableEscapeKey = !1), b.bgOverlay || (b.bgOverlay = x("bg").on("click" + p, function() {
          b.close()
        }), b.wrap = x("wrap").attr("tabindex", -1).on("click" + p, function(a) {
          b._checkIfClose(a.target) && b.close()
        }), b.container = x("container", b.wrap)), b.contentContainer = x("content"), b.st.preloader && (b.preloader = x("preloader", b.container, b.st.tLoading));
        var i = a.magnificPopup.modules;
        for (e = 0; e < i.length; e++) {
          var j = i[e];
          j = j.charAt(0).toUpperCase() + j.slice(1), b["init" + j].call(b)
        }
        y("BeforeOpen"), b.st.showCloseBtn && (b.st.closeBtnInside ? (w(l, function(a, b, c, d) {
          c.close_replaceWith = z(d.type)
        }), f += " mfp-close-btn-in") : b.wrap.append(z())), b.st.alignTop && (f += " mfp-align-top"), b.fixedContentPos ? b.wrap.css({
          overflow: b.st.overflowY,
          overflowX: "hidden",
          overflowY: b.st.overflowY
        }) : b.wrap.css({
          top: v.scrollTop(),
          position: "absolute"
        }), (b.st.fixedBgPos === !1 || "auto" === b.st.fixedBgPos && !b.fixedContentPos) && b.bgOverlay.css({
          height: d.height(),
          position: "absolute"
        }), b.st.enableEscapeKey && d.on("keyup" + p, function(a) {
          27 === a.keyCode && b.close()
        }), v.on("resize" + p, function() {
          b.updateSize()
        }), b.st.closeOnContentClick || (f += " mfp-auto-cursor"), f && b.wrap.addClass(f);
        var k = b.wH = v.height(),
          n = {};
        if (b.fixedContentPos && b._hasScrollBar(k)) {
          var o = b._getScrollbarSize();
          o && (n.marginRight = o)
        }
        b.fixedContentPos && (b.isIE7 ? a("body, html").css("overflow", "hidden") : n.overflow = "hidden");
        var r = b.st.mainClass;
        return b.isIE7 && (r += " mfp-ie7"), r && b._addClassToMFP(r), b.updateItemHTML(), y("BuildControls"), a("html").css(n), b.bgOverlay.add(b.wrap).prependTo(b.st.prependTo || a(document.body)), b._lastFocusedEl = document.activeElement, setTimeout(function() {
          b.content ? (b._addClassToMFP(q), b._setFocus()) : b.bgOverlay.addClass(q), d.on("focusin" + p, b._onFocusIn)
        }, 16), b.isOpen = !0, b.updateSize(k), y(m), c
      },
      close: function() {
        b.isOpen && (y(i), b.isOpen = !1, b.st.removalDelay && !b.isLowIE && b.supportsTransition ? (b._addClassToMFP(r), setTimeout(function() {
          b._close()
        }, b.st.removalDelay)) : b._close())
      },
      _close: function() {
        y(h);
        var c = r + " " + q + " ";
        if (b.bgOverlay.detach(), b.wrap.detach(), b.container.empty(), b.st.mainClass && (c += b.st.mainClass + " "), b._removeClassFromMFP(c), b.fixedContentPos) {
          var e = {
            marginRight: ""
          };
          b.isIE7 ? a("body, html").css("overflow", "") : e.overflow = "", a("html").css(e)
        }
        d.off("keyup" + p + " focusin" + p), b.ev.off(p), b.wrap.attr("class", "mfp-wrap").removeAttr("style"), b.bgOverlay.attr("class", "mfp-bg"), b.container.attr("class", "mfp-container"), !b.st.showCloseBtn || b.st.closeBtnInside && b.currTemplate[b.currItem.type] !== !0 || b.currTemplate.closeBtn && b.currTemplate.closeBtn.detach(), b.st.autoFocusLast && b._lastFocusedEl && a(b._lastFocusedEl).focus(), b.currItem = null, b.content = null, b.currTemplate = null, b.prevHeight = 0, y(j)
      },
      updateSize: function(a) {
        if (b.isIOS) {
          var c = document.documentElement.clientWidth / window.innerWidth,
            d = window.innerHeight * c;
          b.wrap.css("height", d), b.wH = d
        } else b.wH = a || v.height();
        b.fixedContentPos || b.wrap.css("height", b.wH), y("Resize")
      },
      updateItemHTML: function() {
        var c = b.items[b.index];
        b.contentContainer.detach(), b.content && b.content.detach(), c.parsed || (c = b.parseEl(b.index));
        var d = c.type;
        if (y("BeforeChange", [b.currItem ? b.currItem.type : "", d]), b.currItem = c, !b.currTemplate[d]) {
          var f = b.st[d] ? b.st[d].markup : !1;
          y("FirstMarkupParse", f), f ? b.currTemplate[d] = a(f) : b.currTemplate[d] = !0
        }
        e && e !== c.type && b.container.removeClass("mfp-" + e + "-holder");
        var g = b["get" + d.charAt(0).toUpperCase() + d.slice(1)](c, b.currTemplate[d]);
        b.appendContent(g, d), c.preloaded = !0, y(n, c), e = c.type, b.container.prepend(b.contentContainer), y("AfterChange")
      },
      appendContent: function(a, c) {
        b.content = a, a ? b.st.showCloseBtn && b.st.closeBtnInside && b.currTemplate[c] === !0 ? b.content.find(".mfp-close").length || b.content.append(z()) : b.content = a : b.content = "", y(k), b.container.addClass("mfp-" + c + "-holder"), b.contentContainer.append(b.content)
      },
      parseEl: function(c) {
        var d, e = b.items[c];
        if (e.tagName ? e = {
            el: a(e)
          } : (d = e.type, e = {
            data: e,
            src: e.src
          }), e.el) {
          for (var f = b.types, g = 0; g < f.length; g++)
            if (e.el.hasClass("mfp-" + f[g])) {
              d = f[g];
              break
            } e.src = e.el.attr("data-mfp-src"), e.src || (e.src = e.el.attr("href"))
        }
        return e.type = d || b.st.type || "inline", e.index = c, e.parsed = !0, b.items[c] = e, y("ElementParse", e), b.items[c]
      },
      addGroup: function(a, c) {
        var d = function(d) {
          d.mfpEl = this, b._openClick(d, a, c)
        };
        c || (c = {});
        var e = "click.magnificPopup";
        c.mainEl = a, c.items ? (c.isObj = !0, a.off(e).on(e, d)) : (c.isObj = !1, c.delegate ? a.off(e).on(e, c.delegate, d) : (c.items = a, a.off(e).on(e, d)))
      },
      _openClick: function(c, d, e) {
        var f = void 0 !== e.midClick ? e.midClick : a.magnificPopup.defaults.midClick;
        if (f || !(2 === c.which || c.ctrlKey || c.metaKey || c.altKey || c.shiftKey)) {
          var g = void 0 !== e.disableOn ? e.disableOn : a.magnificPopup.defaults.disableOn;
          if (g)
            if (a.isFunction(g)) {
              if (!g.call(b)) return !0
            } else if (v.width() < g) return !0;
          c.type && (c.preventDefault(), b.isOpen && c.stopPropagation()), e.el = a(c.mfpEl), e.delegate && (e.items = d.find(e.delegate)), b.open(e)
        }
      },
      updateStatus: function(a, d) {
        if (b.preloader) {
          c !== a && b.container.removeClass("mfp-s-" + c), d || "loading" !== a || (d = b.st.tLoading);
          var e = {
            status: a,
            text: d
          };
          y("UpdateStatus", e), a = e.status, d = e.text, b.preloader.html(d), b.preloader.find("a").on("click", function(a) {
            a.stopImmediatePropagation()
          }), b.container.addClass("mfp-s-" + a), c = a
        }
      },
      _checkIfClose: function(c) {
        if (!a(c).hasClass(s)) {
          var d = b.st.closeOnContentClick,
            e = b.st.closeOnBgClick;
          if (d && e) return !0;
          if (!b.content || a(c).hasClass("mfp-close") || b.preloader && c === b.preloader[0]) return !0;
          if (c === b.content[0] || a.contains(b.content[0], c)) {
            if (d) return !0
          } else if (e && a.contains(document, c)) return !0;
          return !1
        }
      },
      _addClassToMFP: function(a) {
        b.bgOverlay.addClass(a), b.wrap.addClass(a)
      },
      _removeClassFromMFP: function(a) {
        this.bgOverlay.removeClass(a), b.wrap.removeClass(a)
      },
      _hasScrollBar: function(a) {
        return (b.isIE7 ? d.height() : document.body.scrollHeight) > (a || v.height())
      },
      _setFocus: function() {
        (b.st.focus ? b.content.find(b.st.focus).eq(0) : b.wrap).focus()
      },
      _onFocusIn: function(c) {
        return c.target === b.wrap[0] || a.contains(b.wrap[0], c.target) ? void 0 : (b._setFocus(), !1)
      },
      _parseMarkup: function(b, c, d) {
        var e;
        d.data && (c = a.extend(d.data, c)), y(l, [b, c, d]), a.each(c, function(c, d) {
          if (void 0 === d || d === !1) return !0;
          if (e = c.split("_"), e.length > 1) {
            var f = b.find(p + "-" + e[0]);
            if (f.length > 0) {
              var g = e[1];
              "replaceWith" === g ? f[0] !== d[0] && f.replaceWith(d) : "img" === g ? f.is("img") ? f.attr("src", d) : f.replaceWith(a("<img>").attr("src", d).attr("class", f.attr("class"))) : f.attr(e[1], d)
            }
          } else b.find(p + "-" + c).html(d)
        })
      },
      _getScrollbarSize: function() {
        if (void 0 === b.scrollbarSize) {
          var a = document.createElement("div");
          a.style.cssText = "width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;", document.body.appendChild(a), b.scrollbarSize = a.offsetWidth - a.clientWidth, document.body.removeChild(a)
        }
        return b.scrollbarSize
      }
    }, a.magnificPopup = {
      instance: null,
      proto: t.prototype,
      modules: [],
      open: function(b, c) {
        return A(), b = b ? a.extend(!0, {}, b) : {}, b.isObj = !0, b.index = c || 0, this.instance.open(b)
      },
      close: function() {
        return a.magnificPopup.instance && a.magnificPopup.instance.close()
      },
      registerModule: function(b, c) {
        c.options && (a.magnificPopup.defaults[b] = c.options), a.extend(this.proto, c.proto), this.modules.push(b)
      },
      defaults: {
        disableOn: 0,
        key: null,
        midClick: !1,
        mainClass: "",
        preloader: !0,
        focus: "",
        closeOnContentClick: !1,
        closeOnBgClick: !0,
        closeBtnInside: !0,
        showCloseBtn: !0,
        enableEscapeKey: !0,
        modal: !1,
        alignTop: !1,
        removalDelay: 0,
        prependTo: null,
        fixedContentPos: "auto",
        fixedBgPos: "auto",
        overflowY: "auto",
        closeMarkup: '<button title="%title%" type="button" class="mfp-close">&#215;</button>',
        tClose: "Close (Esc)",
        tLoading: "Loading...",
        autoFocusLast: !0
      }
    }, a.fn.magnificPopup = function(c) {
      A();
      var d = a(this);
      if ("string" == typeof c)
        if ("open" === c) {
          var e, f = u ? d.data("magnificPopup") : d[0].magnificPopup,
            g = parseInt(arguments[1], 10) || 0;
          f.items ? e = f.items[g] : (e = d, f.delegate && (e = e.find(f.delegate)), e = e.eq(g)), b._openClick({
            mfpEl: e
          }, d, f)
        } else b.isOpen && b[c].apply(b, Array.prototype.slice.call(arguments, 1));
      else c = a.extend(!0, {}, c), u ? d.data("magnificPopup", c) : d[0].magnificPopup = c, b.addGroup(d, c);
      return d
    };
    var C, D, E, F = "inline",
      G = function() {
        E && (D.after(E.addClass(C)).detach(), E = null)
      };
    a.magnificPopup.registerModule(F, {
      options: {
        hiddenClass: "hide",
        markup: "",
        tNotFound: "Content not found"
      },
      proto: {
        initInline: function() {
          b.types.push(F), w(h + "." + F, function() {
            G()
          })
        },
        getInline: function(c, d) {
          if (G(), c.src) {
            var e = b.st.inline,
              f = a(c.src);
            if (f.length) {
              var g = f[0].parentNode;
              g && g.tagName && (D || (C = e.hiddenClass, D = x(C), C = "mfp-" + C), E = f.after(D).detach().removeClass(C)), b.updateStatus("ready")
            } else b.updateStatus("error", e.tNotFound), f = a("<div>");
            return c.inlineElement = f, f
          }
          return b.updateStatus("ready"), b._parseMarkup(d, {}, c), d
        }
      }
    });
    var H, I = "ajax",
      J = function() {
        H && a(document.body).removeClass(H)
      },
      K = function() {
        J(), b.req && b.req.abort()
      };
    a.magnificPopup.registerModule(I, {
      options: {
        settings: null,
        cursor: "mfp-ajax-cur",
        tError: '<a href="%url%">The content</a> could not be loaded.'
      },
      proto: {
        initAjax: function() {
          b.types.push(I), H = b.st.ajax.cursor, w(h + "." + I, K), w("BeforeChange." + I, K)
        },
        getAjax: function(c) {
          H && a(document.body).addClass(H), b.updateStatus("loading");
          var d = a.extend({
            url: c.src,
            success: function(d, e, f) {
              var g = {
                data: d,
                xhr: f
              };
              y("ParseAjax", g), b.appendContent(a(g.data), I), c.finished = !0, J(), b._setFocus(), setTimeout(function() {
                b.wrap.addClass(q)
              }, 16), b.updateStatus("ready"), y("AjaxContentAdded")
            },
            error: function() {
              J(), c.finished = c.loadError = !0, b.updateStatus("error", b.st.ajax.tError.replace("%url%", c.src))
            }
          }, b.st.ajax.settings);
          return b.req = a.ajax(d), ""
        }
      }
    });
    var L, M = function(c) {
      if (c.data && void 0 !== c.data.title) return c.data.title;
      var d = b.st.image.titleSrc;
      if (d) {
        if (a.isFunction(d)) return d.call(b, c);
        if (c.el) return c.el.attr(d) || ""
      }
      return ""
    };
    a.magnificPopup.registerModule("image", {
      options: {
        markup: '<div class="mfp-figure"><div class="mfp-close"></div><figure><div class="mfp-img"></div><figcaption><div class="mfp-bottom-bar"><div class="mfp-title"></div><div class="mfp-counter"></div></div></figcaption></figure></div>',
        cursor: "mfp-zoom-out-cur",
        titleSrc: "title",
        verticalFit: !0,
        tError: '<a href="%url%">The image</a> could not be loaded.'
      },
      proto: {
        initImage: function() {
          var c = b.st.image,
            d = ".image";
          b.types.push("image"), w(m + d, function() {
            "image" === b.currItem.type && c.cursor && a(document.body).addClass(c.cursor)
          }), w(h + d, function() {
            c.cursor && a(document.body).removeClass(c.cursor), v.off("resize" + p)
          }), w("Resize" + d, b.resizeImage), b.isLowIE && w("AfterChange", b.resizeImage)
        },
        resizeImage: function() {
          var a = b.currItem;
          if (a && a.img && b.st.image.verticalFit) {
            var c = 0;
            b.isLowIE && (c = parseInt(a.img.css("padding-top"), 10) + parseInt(a.img.css("padding-bottom"), 10)), a.img.css("max-height", b.wH - c)
          }
        },
        _onImageHasSize: function(a) {
          a.img && (a.hasSize = !0, L && clearInterval(L), a.isCheckingImgSize = !1, y("ImageHasSize", a), a.imgHidden && (b.content && b.content.removeClass("mfp-loading"), a.imgHidden = !1))
        },
        findImageSize: function(a) {
          var c = 0,
            d = a.img[0],
            e = function(f) {
              L && clearInterval(L), L = setInterval(function() {
                return d.naturalWidth > 0 ? void b._onImageHasSize(a) : (c > 200 && clearInterval(L), c++, void(3 === c ? e(10) : 40 === c ? e(50) : 100 === c && e(500)))
              }, f)
            };
          e(1)
        },
        getImage: function(c, d) {
          var e = 0,
            f = function() {
              c && (c.img[0].complete ? (c.img.off(".mfploader"), c === b.currItem && (b._onImageHasSize(c), b.updateStatus("ready")), c.hasSize = !0, c.loaded = !0, y("ImageLoadComplete")) : (e++, 200 > e ? setTimeout(f, 100) : g()))
            },
            g = function() {
              c && (c.img.off(".mfploader"), c === b.currItem && (b._onImageHasSize(c), b.updateStatus("error", h.tError.replace("%url%", c.src))), c.hasSize = !0, c.loaded = !0, c.loadError = !0)
            },
            h = b.st.image,
            i = d.find(".mfp-img");
          if (i.length) {
            var j = document.createElement("img");
            j.className = "mfp-img", c.el && c.el.find("img").length && (j.alt = c.el.find("img").attr("alt")), c.img = a(j).on("load.mfploader", f).on("error.mfploader", g), j.src = c.src, i.is("img") && (c.img = c.img.clone()), j = c.img[0], j.naturalWidth > 0 ? c.hasSize = !0 : j.width || (c.hasSize = !1)
          }
          return b._parseMarkup(d, {
            title: M(c),
            img_replaceWith: c.img
          }, c), b.resizeImage(), c.hasSize ? (L && clearInterval(L), c.loadError ? (d.addClass("mfp-loading"), b.updateStatus("error", h.tError.replace("%url%", c.src))) : (d.removeClass("mfp-loading"), b.updateStatus("ready")), d) : (b.updateStatus("loading"), c.loading = !0, c.hasSize || (c.imgHidden = !0, d.addClass("mfp-loading"), b.findImageSize(c)), d)
        }
      }
    });
    var N, O = function() {
      return void 0 === N && (N = void 0 !== document.createElement("p").style.MozTransform), N
    };
    a.magnificPopup.registerModule("zoom", {
      options: {
        enabled: !1,
        easing: "ease-in-out",
        duration: 300,
        opener: function(a) {
          return a.is("img") ? a : a.find("img")
        }
      },
      proto: {
        initZoom: function() {
          var a, c = b.st.zoom,
            d = ".zoom";
          if (c.enabled && b.supportsTransition) {
            var e, f, g = c.duration,
              j = function(a) {
                var b = a.clone().removeAttr("style").removeAttr("class").addClass("mfp-animated-image"),
                  d = "all " + c.duration / 1e3 + "s " + c.easing,
                  e = {
                    position: "fixed",
                    zIndex: 9999,
                    left: 0,
                    top: 0,
                    "-webkit-backface-visibility": "hidden"
                  },
                  f = "transition";
                return e["-webkit-" + f] = e["-moz-" + f] = e["-o-" + f] = e[f] = d, b.css(e), b
              },
              k = function() {
                b.content.css("visibility", "visible")
              };
            w("BuildControls" + d, function() {
              if (b._allowZoom()) {
                if (clearTimeout(e), b.content.css("visibility", "hidden"), a = b._getItemToZoom(), !a) return void k();
                f = j(a), f.css(b._getOffset()), b.wrap.append(f), e = setTimeout(function() {
                  f.css(b._getOffset(!0)), e = setTimeout(function() {
                    k(), setTimeout(function() {
                      f.remove(), a = f = null, y("ZoomAnimationEnded")
                    }, 16)
                  }, g)
                }, 16)
              }
            }), w(i + d, function() {
              if (b._allowZoom()) {
                if (clearTimeout(e), b.st.removalDelay = g, !a) {
                  if (a = b._getItemToZoom(), !a) return;
                  f = j(a)
                }
                f.css(b._getOffset(!0)), b.wrap.append(f), b.content.css("visibility", "hidden"), setTimeout(function() {
                  f.css(b._getOffset())
                }, 16)
              }
            }), w(h + d, function() {
              b._allowZoom() && (k(), f && f.remove(), a = null)
            })
          }
        },
        _allowZoom: function() {
          return "image" === b.currItem.type
        },
        _getItemToZoom: function() {
          return b.currItem.hasSize ? b.currItem.img : !1
        },
        _getOffset: function(c) {
          var d;
          d = c ? b.currItem.img : b.st.zoom.opener(b.currItem.el || b.currItem);
          var e = d.offset(),
            f = parseInt(d.css("padding-top"), 10),
            g = parseInt(d.css("padding-bottom"), 10);
          e.top -= a(window).scrollTop() - f;
          var h = {
            width: d.width(),
            height: (u ? d.innerHeight() : d[0].offsetHeight) - g - f
          };
          return O() ? h["-moz-transform"] = h.transform = "translate(" + e.left + "px," + e.top + "px)" : (h.left = e.left, h.top = e.top), h
        }
      }
    });
    var P = "iframe",
      Q = "//about:blank",
      R = function(a) {
        if (b.currTemplate[P]) {
          var c = b.currTemplate[P].find("iframe");
          c.length && (a || (c[0].src = Q), b.isIE8 && c.css("display", a ? "block" : "none"))
        }
      };
    a.magnificPopup.registerModule(P, {
      options: {
        markup: '<div class="mfp-iframe-scaler"><div class="mfp-close"></div><iframe class="mfp-iframe" src="//about:blank" frameborder="0" allowfullscreen></iframe></div>',
        srcAction: "iframe_src",
        patterns: {
          youtube: {
            index: "youtube.com",
            id: "v=",
            src: "//www.youtube.com/embed/%id%?autoplay=1"
          },
          vimeo: {
            index: "vimeo.com/",
            id: "/",
            src: "//player.vimeo.com/video/%id%?autoplay=1"
          },
          gmaps: {
            index: "//maps.google.",
            src: "%id%&output=embed"
          }
        }
      },
      proto: {
        initIframe: function() {
          b.types.push(P), w("BeforeChange", function(a, b, c) {
            b !== c && (b === P ? R() : c === P && R(!0))
          }), w(h + "." + P, function() {
            R()
          })
        },
        getIframe: function(c, d) {
          var e = c.src,
            f = b.st.iframe;
          a.each(f.patterns, function() {
            return e.indexOf(this.index) > -1 ? (this.id && (e = "string" == typeof this.id ? e.substr(e.lastIndexOf(this.id) + this.id.length, e.length) : this.id.call(this, e)), e = this.src.replace("%id%", e), !1) : void 0
          });
          var g = {};
          return f.srcAction && (g[f.srcAction] = e), b._parseMarkup(d, g, c), b.updateStatus("ready"), d
        }
      }
    });
    var S = function(a) {
        var c = b.items.length;
        return a > c - 1 ? a - c : 0 > a ? c + a : a
      },
      T = function(a, b, c) {
        return a.replace(/%curr%/gi, b + 1).replace(/%total%/gi, c)
      };
    a.magnificPopup.registerModule("gallery", {
      options: {
        enabled: !1,
        arrowMarkup: '<button title="%title%" type="button" class="mfp-arrow mfp-arrow-%dir%"></button>',
        preload: [0, 2],
        navigateByImgClick: !0,
        arrows: !0,
        tPrev: "Previous (Left arrow key)",
        tNext: "Next (Right arrow key)",
        tCounter: "%curr% of %total%"
      },
      proto: {
        initGallery: function() {
          var c = b.st.gallery,
            e = ".mfp-gallery";
          return b.direction = !0, c && c.enabled ? (f += " mfp-gallery", w(m + e, function() {
            c.navigateByImgClick && b.wrap.on("click" + e, ".mfp-img", function() {
              return b.items.length > 1 ? (b.next(), !1) : void 0
            }), d.on("keydown" + e, function(a) {
              37 === a.keyCode ? b.prev() : 39 === a.keyCode && b.next()
            })
          }), w("UpdateStatus" + e, function(a, c) {
            c.text && (c.text = T(c.text, b.currItem.index, b.items.length))
          }), w(l + e, function(a, d, e, f) {
            var g = b.items.length;
            e.counter = g > 1 ? T(c.tCounter, f.index, g) : ""
          }), w("BuildControls" + e, function() {
            if (b.items.length > 1 && c.arrows && !b.arrowLeft) {
              var d = c.arrowMarkup,
                e = b.arrowLeft = a(d.replace(/%title%/gi, c.tPrev).replace(/%dir%/gi, "left")).addClass(s),
                f = b.arrowRight = a(d.replace(/%title%/gi, c.tNext).replace(/%dir%/gi, "right")).addClass(s);
              e.click(function() {
                b.prev()
              }), f.click(function() {
                b.next()
              }), b.container.append(e.add(f))
            }
          }), w(n + e, function() {
            b._preloadTimeout && clearTimeout(b._preloadTimeout), b._preloadTimeout = setTimeout(function() {
              b.preloadNearbyImages(), b._preloadTimeout = null
            }, 16)
          }), void w(h + e, function() {
            d.off(e), b.wrap.off("click" + e), b.arrowRight = b.arrowLeft = null
          })) : !1
        },
        next: function() {
          b.direction = !0, b.index = S(b.index + 1), b.updateItemHTML()
        },
        prev: function() {
          b.direction = !1, b.index = S(b.index - 1), b.updateItemHTML()
        },
        goTo: function(a) {
          b.direction = a >= b.index, b.index = a, b.updateItemHTML()
        },
        preloadNearbyImages: function() {
          var a, c = b.st.gallery.preload,
            d = Math.min(c[0], b.items.length),
            e = Math.min(c[1], b.items.length);
          for (a = 1; a <= (b.direction ? e : d); a++) b._preloadItem(b.index + a);
          for (a = 1; a <= (b.direction ? d : e); a++) b._preloadItem(b.index - a)
        },
        _preloadItem: function(c) {
          if (c = S(c), !b.items[c].preloaded) {
            var d = b.items[c];
            d.parsed || (d = b.parseEl(c)), y("LazyLoad", d), "image" === d.type && (d.img = a('<img class="mfp-img" />').on("load.mfploader", function() {
              d.hasSize = !0
            }).on("error.mfploader", function() {
              d.hasSize = !0, d.loadError = !0, y("LazyLoadError", d)
            }).attr("src", d.src)), d.preloaded = !0
          }
        }
      }
    });
    var U = "retina";
    a.magnificPopup.registerModule(U, {
      options: {
        replaceSrc: function(a) {
          return a.src.replace(/\.\w+$/, function(a) {
            return "@2x" + a
          })
        },
        ratio: 1
      },
      proto: {
        initRetina: function() {
          if (window.devicePixelRatio > 1) {
            var a = b.st.retina,
              c = a.ratio;
            c = isNaN(c) ? c() : c, c > 1 && (w("ImageHasSize." + U, function(a, b) {
              b.img.css({
                "max-width": b.img[0].naturalWidth / c,
                width: "100%"
              })
            }), w("ElementParse." + U, function(b, d) {
              d.src = a.replaceSrc(d, c)
            }))
          }
        }
      }
    }), A()
  });
  
  /*!
   * scrollup v2.4.1
   * Url: http://markgoodyear.com/labs/scrollup/
   * Copyright (c) Mark Goodyear — @markgdyr — http://markgoodyear.com
   * License: MIT
   */
  ! function(l, o, e) {
    "use strict";
    l.fn.scrollUp = function(o) {
      l.data(e.body, "scrollUp") || (l.data(e.body, "scrollUp", !0), l.fn.scrollUp.init(o))
    }, l.fn.scrollUp.init = function(r) {
      var s, t, c, i, n, a, d, p = l.fn.scrollUp.settings = l.extend({}, l.fn.scrollUp.defaults, r),
        f = !1;
      switch (d = p.scrollTrigger ? l(p.scrollTrigger) : l("<a/>", {
        id: p.scrollName,
        href: "#top"
      }), p.scrollTitle && d.attr("title", p.scrollTitle), d.appendTo("body"), p.scrollImg || p.scrollTrigger || d.html(p.scrollText), d.css({
        display: "none",
        position: "fixed",
        zIndex: p.zIndex
      }), p.activeOverlay && l("<div/>", {
        id: p.scrollName + "-active"
      }).css({
        position: "absolute",
        top: p.scrollDistance + "px",
        width: "100%",
        borderTop: "1px dotted" + p.activeOverlay,
        zIndex: p.zIndex
      }).appendTo("body"), p.animation) {
        case "fade":
          s = "fadeIn", t = "fadeOut", c = p.animationSpeed;
          break;
        case "slide":
          s = "slideDown", t = "slideUp", c = p.animationSpeed;
          break;
        default:
          s = "show", t = "hide", c = 0
      }
      i = "top" === p.scrollFrom ? p.scrollDistance : l(e).height() - l(o).height() - p.scrollDistance, n = l(o).scroll(function() {
        l(o).scrollTop() > i ? f || (d[s](c), f = !0) : f && (d[t](c), f = !1)
      }), p.scrollTarget ? "number" == typeof p.scrollTarget ? a = p.scrollTarget : "string" == typeof p.scrollTarget && (a = Math.floor(l(p.scrollTarget).offset().top)) : a = 0, d.click(function(o) {
        o.preventDefault(), l("html, body").animate({
          scrollTop: a
        }, p.scrollSpeed, p.easingType)
      })
    }, l.fn.scrollUp.defaults = {
      scrollName: "scrollUp",
      scrollDistance: 300,
      scrollFrom: "top",
      scrollSpeed: 300,
      easingType: "linear",
      animation: "fade",
      animationSpeed: 200,
      scrollTrigger: !1,
      scrollTarget: !1,
      scrollText: "Scroll to top",
      scrollTitle: !1,
      scrollImg: !1,
      activeOverlay: !1,
      zIndex: 2147483647
    }, l.fn.scrollUp.destroy = function(r) {
      l.removeData(e.body, "scrollUp"), l("#" + l.fn.scrollUp.settings.scrollName).remove(), l("#" + l.fn.scrollUp.settings.scrollName + "-active").remove(), l.fn.jquery.split(".")[1] >= 7 ? l(o).off("scroll", r) : l(o).unbind("scroll", r)
    }, l.scrollUp = l.fn.scrollUp
  }(jQuery, window, document);
  
  // Generated by CoffeeScript 1.6.2
  /*
  jQuery Waypoints - v2.0.3
  Copyright (c) 2011-2013 Caleb Troughton
  Dual licensed under the MIT license and GPL license.
  https://github.com/imakewebthings/jquery-waypoints/blob/master/licenses.txt
  */
  (function() {
    var t = [].indexOf || function(t) {
        for (var e = 0, n = this.length; e < n; e++) {
          if (e in this && this[e] === t) return e
        }
        return -1
      },
      e = [].slice;
    (function(t, e) {
      if (typeof define === "function" && define.amd) {
        return define("waypoints", ["jquery"], function(n) {
          return e(n, t)
        })
      } else {
        return e(t.jQuery, t)
      }
    })(this, function(n, r) {
      var i, o, l, s, f, u, a, c, h, d, p, y, v, w, g, m;
      i = n(r);
      c = t.call(r, "ontouchstart") >= 0;
      s = {
        horizontal: {},
        vertical: {}
      };
      f = 1;
      a = {};
      u = "waypoints-context-id";
      p = "resize.waypoints";
      y = "scroll.waypoints";
      v = 1;
      w = "waypoints-waypoint-ids";
      g = "waypoint";
      m = "waypoints";
      o = function() {
        function t(t) {
          var e = this;
          this.$element = t;
          this.element = t[0];
          this.didResize = false;
          this.didScroll = false;
          this.id = "context" + f++;
          this.oldScroll = {
            x: t.scrollLeft(),
            y: t.scrollTop()
          };
          this.waypoints = {
            horizontal: {},
            vertical: {}
          };
          t.data(u, this.id);
          a[this.id] = this;
          t.bind(y, function() {
            var t;
            if (!(e.didScroll || c)) {
              e.didScroll = true;
              t = function() {
                e.doScroll();
                return e.didScroll = false
              };
              return r.setTimeout(t, n[m].settings.scrollThrottle)
            }
          });
          t.bind(p, function() {
            var t;
            if (!e.didResize) {
              e.didResize = true;
              t = function() {
                n[m]("refresh");
                return e.didResize = false
              };
              return r.setTimeout(t, n[m].settings.resizeThrottle)
            }
          })
        }
        t.prototype.doScroll = function() {
          var t, e = this;
          t = {
            horizontal: {
              newScroll: this.$element.scrollLeft(),
              oldScroll: this.oldScroll.x,
              forward: "right",
              backward: "left"
            },
            vertical: {
              newScroll: this.$element.scrollTop(),
              oldScroll: this.oldScroll.y,
              forward: "down",
              backward: "up"
            }
          };
          if (c && (!t.vertical.oldScroll || !t.vertical.newScroll)) {
            n[m]("refresh")
          }
          n.each(t, function(t, r) {
            var i, o, l;
            l = [];
            o = r.newScroll > r.oldScroll;
            i = o ? r.forward : r.backward;
            n.each(e.waypoints[t], function(t, e) {
              var n, i;
              if (r.oldScroll < (n = e.offset) && n <= r.newScroll) {
                return l.push(e)
              } else if (r.newScroll < (i = e.offset) && i <= r.oldScroll) {
                return l.push(e)
              }
            });
            l.sort(function(t, e) {
              return t.offset - e.offset
            });
            if (!o) {
              l.reverse()
            }
            return n.each(l, function(t, e) {
              if (e.options.continuous || t === l.length - 1) {
                return e.trigger([i])
              }
            })
          });
          return this.oldScroll = {
            x: t.horizontal.newScroll,
            y: t.vertical.newScroll
          }
        };
        t.prototype.refresh = function() {
          var t, e, r, i = this;
          r = n.isWindow(this.element);
          e = this.$element.offset();
          this.doScroll();
          t = {
            horizontal: {
              contextOffset: r ? 0 : e.left,
              contextScroll: r ? 0 : this.oldScroll.x,
              contextDimension: this.$element.width(),
              oldScroll: this.oldScroll.x,
              forward: "right",
              backward: "left",
              offsetProp: "left"
            },
            vertical: {
              contextOffset: r ? 0 : e.top,
              contextScroll: r ? 0 : this.oldScroll.y,
              contextDimension: r ? n[m]("viewportHeight") : this.$element.height(),
              oldScroll: this.oldScroll.y,
              forward: "down",
              backward: "up",
              offsetProp: "top"
            }
          };
          return n.each(t, function(t, e) {
            return n.each(i.waypoints[t], function(t, r) {
              var i, o, l, s, f;
              i = r.options.offset;
              l = r.offset;
              o = n.isWindow(r.element) ? 0 : r.$element.offset()[e.offsetProp];
              if (n.isFunction(i)) {
                i = i.apply(r.element)
              } else if (typeof i === "string") {
                i = parseFloat(i);
                if (r.options.offset.indexOf("%") > -1) {
                  i = Math.ceil(e.contextDimension * i / 100)
                }
              }
              r.offset = o - e.contextOffset + e.contextScroll - i;
              if (r.options.onlyOnScroll && l != null || !r.enabled) {
                return
              }
              if (l !== null && l < (s = e.oldScroll) && s <= r.offset) {
                return r.trigger([e.backward])
              } else if (l !== null && l > (f = e.oldScroll) && f >= r.offset) {
                return r.trigger([e.forward])
              } else if (l === null && e.oldScroll >= r.offset) {
                return r.trigger([e.forward])
              }
            })
          })
        };
        t.prototype.checkEmpty = function() {
          if (n.isEmptyObject(this.waypoints.horizontal) && n.isEmptyObject(this.waypoints.vertical)) {
            this.$element.unbind([p, y].join(" "));
            return delete a[this.id]
          }
        };
        return t
      }();
      l = function() {
        function t(t, e, r) {
          var i, o;
          r = n.extend({}, n.fn[g].defaults, r);
          if (r.offset === "bottom-in-view") {
            r.offset = function() {
              var t;
              t = n[m]("viewportHeight");
              if (!n.isWindow(e.element)) {
                t = e.$element.height()
              }
              return t - n(this).outerHeight()
            }
          }
          this.$element = t;
          this.element = t[0];
          this.axis = r.horizontal ? "horizontal" : "vertical";
          this.callback = r.handler;
          this.context = e;
          this.enabled = r.enabled;
          this.id = "waypoints" + v++;
          this.offset = null;
          this.options = r;
          e.waypoints[this.axis][this.id] = this;
          s[this.axis][this.id] = this;
          i = (o = t.data(w)) != null ? o : [];
          i.push(this.id);
          t.data(w, i)
        }
        t.prototype.trigger = function(t) {
          if (!this.enabled) {
            return
          }
          if (this.callback != null) {
            this.callback.apply(this.element, t)
          }
          if (this.options.triggerOnce) {
            return this.destroy()
          }
        };
        t.prototype.disable = function() {
          return this.enabled = false
        };
        t.prototype.enable = function() {
          this.context.refresh();
          return this.enabled = true
        };
        t.prototype.destroy = function() {
          delete s[this.axis][this.id];
          delete this.context.waypoints[this.axis][this.id];
          return this.context.checkEmpty()
        };
        t.getWaypointsByElement = function(t) {
          var e, r;
          r = n(t).data(w);
          if (!r) {
            return []
          }
          e = n.extend({}, s.horizontal, s.vertical);
          return n.map(r, function(t) {
            return e[t]
          })
        };
        return t
      }();
      d = {
        init: function(t, e) {
          var r;
          if (e == null) {
            e = {}
          }
          if ((r = e.handler) == null) {
            e.handler = t
          }
          this.each(function() {
            var t, r, i, s;
            t = n(this);
            i = (s = e.context) != null ? s : n.fn[g].defaults.context;
            if (!n.isWindow(i)) {
              i = t.closest(i)
            }
            i = n(i);
            r = a[i.data(u)];
            if (!r) {
              r = new o(i)
            }
            return new l(t, r, e)
          });
          n[m]("refresh");
          return this
        },
        disable: function() {
          return d._invoke(this, "disable")
        },
        enable: function() {
          return d._invoke(this, "enable")
        },
        destroy: function() {
          return d._invoke(this, "destroy")
        },
        prev: function(t, e) {
          return d._traverse.call(this, t, e, function(t, e, n) {
            if (e > 0) {
              return t.push(n[e - 1])
            }
          })
        },
        next: function(t, e) {
          return d._traverse.call(this, t, e, function(t, e, n) {
            if (e < n.length - 1) {
              return t.push(n[e + 1])
            }
          })
        },
        _traverse: function(t, e, i) {
          var o, l;
          if (t == null) {
            t = "vertical"
          }
          if (e == null) {
            e = r
          }
          l = h.aggregate(e);
          o = [];
          this.each(function() {
            var e;
            e = n.inArray(this, l[t]);
            return i(o, e, l[t])
          });
          return this.pushStack(o)
        },
        _invoke: function(t, e) {
          t.each(function() {
            var t;
            t = l.getWaypointsByElement(this);
            return n.each(t, function(t, n) {
              n[e]();
              return true
            })
          });
          return this
        }
      };
      n.fn[g] = function() {
        var t, r;
        r = arguments[0], t = 2 <= arguments.length ? e.call(arguments, 1) : [];
        if (d[r]) {
          return d[r].apply(this, t)
        } else if (n.isFunction(r)) {
          return d.init.apply(this, arguments)
        } else if (n.isPlainObject(r)) {
          return d.init.apply(this, [null, r])
        } else if (!r) {
          return n.error("jQuery Waypoints needs a callback function or handler option.")
        } else {
          return n.error("The " + r + " method does not exist in jQuery Waypoints.")
        }
      };
      n.fn[g].defaults = {
        context: r,
        continuous: true,
        enabled: true,
        horizontal: false,
        offset: 0,
        triggerOnce: false
      };
      h = {
        refresh: function() {
          return n.each(a, function(t, e) {
            return e.refresh()
          })
        },
        viewportHeight: function() {
          var t;
          return (t = r.innerHeight) != null ? t : i.height()
        },
        aggregate: function(t) {
          var e, r, i;
          e = s;
          if (t) {
            e = (i = a[n(t).data(u)]) != null ? i.waypoints : void 0
          }
          if (!e) {
            return []
          }
          r = {
            horizontal: [],
            vertical: []
          };
          n.each(r, function(t, i) {
            n.each(e[t], function(t, e) {
              return i.push(e)
            });
            i.sort(function(t, e) {
              return t.offset - e.offset
            });
            r[t] = n.map(i, function(t) {
              return t.element
            });
            return r[t] = n.unique(r[t])
          });
          return r
        },
        above: function(t) {
          if (t == null) {
            t = r
          }
          return h._filter(t, "vertical", function(t, e) {
            return e.offset <= t.oldScroll.y
          })
        },
        below: function(t) {
          if (t == null) {
            t = r
          }
          return h._filter(t, "vertical", function(t, e) {
            return e.offset > t.oldScroll.y
          })
        },
        left: function(t) {
          if (t == null) {
            t = r
          }
          return h._filter(t, "horizontal", function(t, e) {
            return e.offset <= t.oldScroll.x
          })
        },
        right: function(t) {
          if (t == null) {
            t = r
          }
          return h._filter(t, "horizontal", function(t, e) {
            return e.offset > t.oldScroll.x
          })
        },
        enable: function() {
          return h._invoke("enable")
        },
        disable: function() {
          return h._invoke("disable")
        },
        destroy: function() {
          return h._invoke("destroy")
        },
        extendFn: function(t, e) {
          return d[t] = e
        },
        _invoke: function(t) {
          var e;
          e = n.extend({}, s.vertical, s.horizontal);
          return n.each(e, function(e, n) {
            n[t]();
            return true
          })
        },
        _filter: function(t, e, r) {
          var i, o;
          i = a[n(t).data(u)];
          if (!i) {
            return []
          }
          o = [];
          n.each(i.waypoints[e], function(t, e) {
            if (r(i, e)) {
              return o.push(e)
            }
          });
          o.sort(function(t, e) {
            return t.offset - e.offset
          });
          return n.map(o, function(t) {
            return t.element
          })
        }
      };
      n[m] = function() {
        var t, n;
        n = arguments[0], t = 2 <= arguments.length ? e.call(arguments, 1) : [];
        if (h[n]) {
          return h[n].apply(null, t)
        } else {
          return h.aggregate.call(null, n)
        }
      };
      n[m].settings = {
        resizeThrottle: 100,
        scrollThrottle: 30
      };
      return i.load(function() {
        return n[m]("refresh")
      })
    })
  }).call(this);
  
  /*! WOW - v1.1.3 - 2016-05-06
   * Copyright (c) 2016 Matthieu Aussaguel;*/
  (function() {
    var a, b, c, d, e, f = function(a, b) {
        return function() {
          return a.apply(b, arguments)
        }
      },
      g = [].indexOf || function(a) {
        for (var b = 0, c = this.length; c > b; b++)
          if (b in this && this[b] === a) return b;
        return -1
      };
    b = function() {
      function a() {}
      return a.prototype.extend = function(a, b) {
        var c, d;
        for (c in b) d = b[c], null == a[c] && (a[c] = d);
        return a
      }, a.prototype.isMobile = function(a) {
        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(a)
      }, a.prototype.createEvent = function(a, b, c, d) {
        var e;
        return null == b && (b = !1), null == c && (c = !1), null == d && (d = null), null != document.createEvent ? (e = document.createEvent("CustomEvent"), e.initCustomEvent(a, b, c, d)) : null != document.createEventObject ? (e = document.createEventObject(), e.eventType = a) : e.eventName = a, e
      }, a.prototype.emitEvent = function(a, b) {
        return null != a.dispatchEvent ? a.dispatchEvent(b) : b in (null != a) ? a[b]() : "on" + b in (null != a) ? a["on" + b]() : void 0
      }, a.prototype.addEvent = function(a, b, c) {
        return null != a.addEventListener ? a.addEventListener(b, c, !1) : null != a.attachEvent ? a.attachEvent("on" + b, c) : a[b] = c
      }, a.prototype.removeEvent = function(a, b, c) {
        return null != a.removeEventListener ? a.removeEventListener(b, c, !1) : null != a.detachEvent ? a.detachEvent("on" + b, c) : delete a[b]
      }, a.prototype.innerHeight = function() {
        return "innerHeight" in window ? window.innerHeight : document.documentElement.clientHeight
      }, a
    }(), c = this.WeakMap || this.MozWeakMap || (c = function() {
      function a() {
        this.keys = [], this.values = []
      }
      return a.prototype.get = function(a) {
        var b, c, d, e, f;
        for (f = this.keys, b = d = 0, e = f.length; e > d; b = ++d)
          if (c = f[b], c === a) return this.values[b]
      }, a.prototype.set = function(a, b) {
        var c, d, e, f, g;
        for (g = this.keys, c = e = 0, f = g.length; f > e; c = ++e)
          if (d = g[c], d === a) return void(this.values[c] = b);
        return this.keys.push(a), this.values.push(b)
      }, a
    }()), a = this.MutationObserver || this.WebkitMutationObserver || this.MozMutationObserver || (a = function() {
      function a() {
        "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.")
      }
      return a.notSupported = !0, a.prototype.observe = function() {}, a
    }()), d = this.getComputedStyle || function(a, b) {
      return this.getPropertyValue = function(b) {
        var c;
        return "float" === b && (b = "styleFloat"), e.test(b) && b.replace(e, function(a, b) {
          return b.toUpperCase()
        }), (null != (c = a.currentStyle) ? c[b] : void 0) || null
      }, this
    }, e = /(\-([a-z]){1})/g, this.WOW = function() {
      function e(a) {
        null == a && (a = {}), this.scrollCallback = f(this.scrollCallback, this), this.scrollHandler = f(this.scrollHandler, this), this.resetAnimation = f(this.resetAnimation, this), this.start = f(this.start, this), this.scrolled = !0, this.config = this.util().extend(a, this.defaults), null != a.scrollContainer && (this.config.scrollContainer = document.querySelector(a.scrollContainer)), this.animationNameCache = new c, this.wowEvent = this.util().createEvent(this.config.boxClass)
      }
      return e.prototype.defaults = {
        boxClass: "wow",
        animateClass: "animated",
        offset: 0,
        mobile: !0,
        live: !0,
        callback: null,
        scrollContainer: null
      }, e.prototype.init = function() {
        var a;
        return this.element = window.document.documentElement, "interactive" === (a = document.readyState) || "complete" === a ? this.start() : this.util().addEvent(document, "DOMContentLoaded", this.start), this.finished = []
      }, e.prototype.start = function() {
        var b, c, d, e;
        if (this.stopped = !1, this.boxes = function() {
            var a, c, d, e;
            for (d = this.element.querySelectorAll("." + this.config.boxClass), e = [], a = 0, c = d.length; c > a; a++) b = d[a], e.push(b);
            return e
          }.call(this), this.all = function() {
            var a, c, d, e;
            for (d = this.boxes, e = [], a = 0, c = d.length; c > a; a++) b = d[a], e.push(b);
            return e
          }.call(this), this.boxes.length)
          if (this.disabled()) this.resetStyle();
          else
            for (e = this.boxes, c = 0, d = e.length; d > c; c++) b = e[c], this.applyStyle(b, !0);
        return this.disabled() || (this.util().addEvent(this.config.scrollContainer || window, "scroll", this.scrollHandler), this.util().addEvent(window, "resize", this.scrollHandler), this.interval = setInterval(this.scrollCallback, 50)), this.config.live ? new a(function(a) {
          return function(b) {
            var c, d, e, f, g;
            for (g = [], c = 0, d = b.length; d > c; c++) f = b[c], g.push(function() {
              var a, b, c, d;
              for (c = f.addedNodes || [], d = [], a = 0, b = c.length; b > a; a++) e = c[a], d.push(this.doSync(e));
              return d
            }.call(a));
            return g
          }
        }(this)).observe(document.body, {
          childList: !0,
          subtree: !0
        }) : void 0
      }, e.prototype.stop = function() {
        return this.stopped = !0, this.util().removeEvent(this.config.scrollContainer || window, "scroll", this.scrollHandler), this.util().removeEvent(window, "resize", this.scrollHandler), null != this.interval ? clearInterval(this.interval) : void 0
      }, e.prototype.sync = function(b) {
        return a.notSupported ? this.doSync(this.element) : void 0
      }, e.prototype.doSync = function(a) {
        var b, c, d, e, f;
        if (null == a && (a = this.element), 1 === a.nodeType) {
          for (a = a.parentNode || a, e = a.querySelectorAll("." + this.config.boxClass), f = [], c = 0, d = e.length; d > c; c++) b = e[c], g.call(this.all, b) < 0 ? (this.boxes.push(b), this.all.push(b), this.stopped || this.disabled() ? this.resetStyle() : this.applyStyle(b, !0), f.push(this.scrolled = !0)) : f.push(void 0);
          return f
        }
      }, e.prototype.show = function(a) {
        return this.applyStyle(a), a.className = a.className + " " + this.config.animateClass, null != this.config.callback && this.config.callback(a), this.util().emitEvent(a, this.wowEvent), this.util().addEvent(a, "animationend", this.resetAnimation), this.util().addEvent(a, "oanimationend", this.resetAnimation), this.util().addEvent(a, "webkitAnimationEnd", this.resetAnimation), this.util().addEvent(a, "MSAnimationEnd", this.resetAnimation), a
      }, e.prototype.applyStyle = function(a, b) {
        var c, d, e;
        return d = a.getAttribute("data-wow-duration"), c = a.getAttribute("data-wow-delay"), e = a.getAttribute("data-wow-iteration"), this.animate(function(f) {
          return function() {
            return f.customStyle(a, b, d, c, e)
          }
        }(this))
      }, e.prototype.animate = function() {
        return "requestAnimationFrame" in window ? function(a) {
          return window.requestAnimationFrame(a)
        } : function(a) {
          return a()
        }
      }(), e.prototype.resetStyle = function() {
        var a, b, c, d, e;
        for (d = this.boxes, e = [], b = 0, c = d.length; c > b; b++) a = d[b], e.push(a.style.visibility = "visible");
        return e
      }, e.prototype.resetAnimation = function(a) {
        var b;
        return a.type.toLowerCase().indexOf("animationend") >= 0 ? (b = a.target || a.srcElement, b.className = b.className.replace(this.config.animateClass, "").trim()) : void 0
      }, e.prototype.customStyle = function(a, b, c, d, e) {
        return b && this.cacheAnimationName(a), a.style.visibility = b ? "hidden" : "visible", c && this.vendorSet(a.style, {
          animationDuration: c
        }), d && this.vendorSet(a.style, {
          animationDelay: d
        }), e && this.vendorSet(a.style, {
          animationIterationCount: e
        }), this.vendorSet(a.style, {
          animationName: b ? "none" : this.cachedAnimationName(a)
        }), a
      }, e.prototype.vendors = ["moz", "webkit"], e.prototype.vendorSet = function(a, b) {
        var c, d, e, f;
        d = [];
        for (c in b) e = b[c], a["" + c] = e, d.push(function() {
          var b, d, g, h;
          for (g = this.vendors, h = [], b = 0, d = g.length; d > b; b++) f = g[b], h.push(a["" + f + c.charAt(0).toUpperCase() + c.substr(1)] = e);
          return h
        }.call(this));
        return d
      }, e.prototype.vendorCSS = function(a, b) {
        var c, e, f, g, h, i;
        for (h = d(a), g = h.getPropertyCSSValue(b), f = this.vendors, c = 0, e = f.length; e > c; c++) i = f[c], g = g || h.getPropertyCSSValue("-" + i + "-" + b);
        return g
      }, e.prototype.animationName = function(a) {
        var b;
        try {
          b = this.vendorCSS(a, "animation-name").cssText
        } catch (c) {
          b = d(a).getPropertyValue("animation-name")
        }
        return "none" === b ? "" : b
      }, e.prototype.cacheAnimationName = function(a) {
        return this.animationNameCache.set(a, this.animationName(a))
      }, e.prototype.cachedAnimationName = function(a) {
        return this.animationNameCache.get(a)
      }, e.prototype.scrollHandler = function() {
        return this.scrolled = !0
      }, e.prototype.scrollCallback = function() {
        var a;
        return !this.scrolled || (this.scrolled = !1, this.boxes = function() {
          var b, c, d, e;
          for (d = this.boxes, e = [], b = 0, c = d.length; c > b; b++) a = d[b], a && (this.isVisible(a) ? this.show(a) : e.push(a));
          return e
        }.call(this), this.boxes.length || this.config.live) ? void 0 : this.stop()
      }, e.prototype.offsetTop = function(a) {
        for (var b; void 0 === a.offsetTop;) a = a.parentNode;
        for (b = a.offsetTop; a = a.offsetParent;) b += a.offsetTop;
        return b
      }, e.prototype.isVisible = function(a) {
        var b, c, d, e, f;
        return c = a.getAttribute("data-wow-offset") || this.config.offset, f = this.config.scrollContainer && this.config.scrollContainer.scrollTop || window.pageYOffset, e = f + Math.min(this.element.clientHeight, this.util().innerHeight()) - c, d = this.offsetTop(a), b = d + a.clientHeight, e >= d && b >= f
      }, e.prototype.util = function() {
        return null != this._util ? this._util : this._util = new b
      }, e.prototype.disabled = function() {
        return !this.config.mobile && this.util().isMobile(navigator.userAgent)
      }, e
    }()
  }).call(this);
  
  /**
   * jquery-circle-progress - jQuery Plugin to draw animated circular progress bars:
   * {@link http://kottenator.github.io/jquery-circle-progress/}
   *
   * @author Rostyslav Bryzgunov <kottenator@gmail.com>
   * @version 1.2.2
   * @licence MIT
   * @preserve
   */
  ! function(i) {
    if ("function" == typeof define && define.amd) define(["jquery"], i);
    else if ("object" == typeof module && module.exports) {
      var t = require("jquery");
      i(t), module.exports = t
    } else i(jQuery)
  }(function(i) {
    function t(i) {
      this.init(i)
    }
    t.prototype = {
      value: 0,
      size: 100,
      startAngle: -Math.PI,
      thickness: "auto",
      fill: {
        gradient: ["#3aeabb", "#fdd250"]
      },
      emptyFill: "rgba(0, 0, 0, .1)",
      animation: {
        duration: 1200,
        easing: "circleProgressEasing"
      },
      animationStartValue: 0,
      reverse: !1,
      lineCap: "butt",
      insertMode: "prepend",
      constructor: t,
      el: null,
      canvas: null,
      ctx: null,
      radius: 0,
      arcFill: null,
      lastFrameValue: 0,
      init: function(t) {
        i.extend(this, t), this.radius = this.size / 2, this.initWidget(), this.initFill(), this.draw(), this.el.trigger("circle-inited")
      },
      initWidget: function() {
        this.canvas || (this.canvas = i("<canvas>")["prepend" == this.insertMode ? "prependTo" : "appendTo"](this.el)[0]);
        var t = this.canvas;
        if (t.width = this.size, t.height = this.size, this.ctx = t.getContext("2d"), window.devicePixelRatio > 1) {
          var e = window.devicePixelRatio;
          t.style.width = t.style.height = this.size + "px", t.width = t.height = this.size * e, this.ctx.scale(e, e)
        }
      },
      initFill: function() {
        function t() {
          var t = i("<canvas>")[0];
          t.width = e.size, t.height = e.size, t.getContext("2d").drawImage(g, 0, 0, r, r), e.arcFill = e.ctx.createPattern(t, "no-repeat"), e.drawFrame(e.lastFrameValue)
        }
        var e = this,
          a = this.fill,
          n = this.ctx,
          r = this.size;
        if (!a) throw Error("The fill is not specified!");
        if ("string" == typeof a && (a = {
            color: a
          }), a.color && (this.arcFill = a.color), a.gradient) {
          var s = a.gradient;
          if (1 == s.length) this.arcFill = s[0];
          else if (s.length > 1) {
            for (var l = a.gradientAngle || 0, o = a.gradientDirection || [r / 2 * (1 - Math.cos(l)), r / 2 * (1 + Math.sin(l)), r / 2 * (1 + Math.cos(l)), r / 2 * (1 - Math.sin(l))], h = n.createLinearGradient.apply(n, o), c = 0; c < s.length; c++) {
              var d = s[c],
                u = c / (s.length - 1);
              i.isArray(d) && (u = d[1], d = d[0]), h.addColorStop(u, d)
            }
            this.arcFill = h
          }
        }
        if (a.image) {
          var g;
          a.image instanceof Image ? g = a.image : (g = new Image, g.src = a.image), g.complete ? t() : g.onload = t
        }
      },
      draw: function() {
        this.animation ? this.drawAnimated(this.value) : this.drawFrame(this.value)
      },
      drawFrame: function(i) {
        this.lastFrameValue = i, this.ctx.clearRect(0, 0, this.size, this.size), this.drawEmptyArc(i), this.drawArc(i)
      },
      drawArc: function(i) {
        if (0 !== i) {
          var t = this.ctx,
            e = this.radius,
            a = this.getThickness(),
            n = this.startAngle;
          t.save(), t.beginPath(), this.reverse ? t.arc(e, e, e - a / 2, n - 2 * Math.PI * i, n) : t.arc(e, e, e - a / 2, n, n + 2 * Math.PI * i), t.lineWidth = a, t.lineCap = this.lineCap, t.strokeStyle = this.arcFill, t.stroke(), t.restore()
        }
      },
      drawEmptyArc: function(i) {
        var t = this.ctx,
          e = this.radius,
          a = this.getThickness(),
          n = this.startAngle;
        i < 1 && (t.save(), t.beginPath(), i <= 0 ? t.arc(e, e, e - a / 2, 0, 2 * Math.PI) : this.reverse ? t.arc(e, e, e - a / 2, n, n - 2 * Math.PI * i) : t.arc(e, e, e - a / 2, n + 2 * Math.PI * i, n), t.lineWidth = a, t.strokeStyle = this.emptyFill, t.stroke(), t.restore())
      },
      drawAnimated: function(t) {
        var e = this,
          a = this.el,
          n = i(this.canvas);
        n.stop(!0, !1), a.trigger("circle-animation-start"), n.css({
          animationProgress: 0
        }).animate({
          animationProgress: 1
        }, i.extend({}, this.animation, {
          step: function(i) {
            var n = e.animationStartValue * (1 - i) + t * i;
            e.drawFrame(n), a.trigger("circle-animation-progress", [i, n])
          }
        })).promise().always(function() {
          a.trigger("circle-animation-end")
        })
      },
      getThickness: function() {
        return i.isNumeric(this.thickness) ? this.thickness : this.size / 14
      },
      getValue: function() {
        return this.value
      },
      setValue: function(i) {
        this.animation && (this.animationStartValue = this.lastFrameValue), this.value = i, this.draw()
      }
    }, i.circleProgress = {
      defaults: t.prototype
    }, i.easing.circleProgressEasing = function(i) {
      return i < .5 ? (i = 2 * i, .5 * i * i * i) : (i = 2 - 2 * i, 1 - .5 * i * i * i)
    }, i.fn.circleProgress = function(e, a) {
      var n = "circle-progress",
        r = this.data(n);
      if ("widget" == e) {
        if (!r) throw Error('Calling "widget" method on not initialized instance is forbidden');
        return r.canvas
      }
      if ("value" == e) {
        if (!r) throw Error('Calling "value" method on not initialized instance is forbidden');
        if ("undefined" == typeof a) return r.getValue();
        var s = arguments[1];
        return this.each(function() {
          i(this).data(n).setValue(s)
        })
      }
      return this.each(function() {
        var a = i(this),
          r = a.data(n),
          s = i.isPlainObject(e) ? e : {};
        if (r) r.init(s);
        else {
          var l = i.extend({}, a.data());
          "string" == typeof l.fill && (l.fill = JSON.parse(l.fill)), "string" == typeof l.animation && (l.animation = JSON.parse(l.animation)), s = i.extend(l, s), s.el = a, r = new t(s), a.data(n, r)
        }
      })
    }
  });
  
  // Sticky Plugin v1.0.4 for jQuery
  // =============
  // Author: Anthony Garand
  // Improvements by German M. Bravo (Kronuz) and Ruud Kamphuis (ruudk)
  // Improvements by Leonardo C. Daronco (daronco)
  // Created: 02/14/2011
  // Date: 07/20/2015
  // Website: http://stickyjs.com/
  // Description: Makes an element on the page stick on the screen as you scroll
  //              It will only set the 'top' and 'position' of your element, you
  //              might need to adjust the width in some cases.
  
  ! function(t) {
    "function" == typeof define && define.amd ? define(["jquery"], t) : "object" == typeof module && module.exports ? module.exports = t(require("jquery")) : t(jQuery)
  }(function(t) {
    var e = Array.prototype.slice,
      i = Array.prototype.splice,
      n = {
        topSpacing: 0,
        bottomSpacing: 0,
        className: "is-sticky",
        wrapperClassName: "sticky-wrapper",
        center: !1,
        getWidthFrom: "",
        widthFromWrapper: !0,
        responsiveWidth: !1,
        zIndex: "inherit"
      },
      r = t(window),
      s = t(document),
      o = [],
      c = r.height(),
      p = function() {
        for (var e = r.scrollTop(), i = s.height(), n = i - c, p = e > n ? n - e : 0, a = 0, d = o.length; a < d; a++) {
          var l = o[a],
            h = l.stickyWrapper.offset().top - l.topSpacing - p;
          if (l.stickyWrapper.css("height", l.stickyElement.outerHeight()), e <= h) null !== l.currentTop && (l.stickyElement.css({
            width: "",
            position: "",
            top: "",
            "z-index": ""
          }), l.stickyElement.parent().removeClass(l.className), l.stickyElement.trigger("sticky-end", [l]), l.currentTop = null);
          else {
            var u, g = i - l.stickyElement.outerHeight() - l.topSpacing - l.bottomSpacing - e - p;
            if (g < 0 ? g += l.topSpacing : g = l.topSpacing, l.currentTop !== g) l.getWidthFrom ? (padding = l.stickyElement.innerWidth() - l.stickyElement.width(), u = t(l.getWidthFrom).width() - padding || null) : l.widthFromWrapper && (u = l.stickyWrapper.width()), null == u && (u = l.stickyElement.width()), l.stickyElement.css("width", u).css("position", "fixed").css("top", g).css("z-index", l.zIndex), l.stickyElement.parent().addClass(l.className), null === l.currentTop ? l.stickyElement.trigger("sticky-start", [l]) : l.stickyElement.trigger("sticky-update", [l]), l.currentTop === l.topSpacing && l.currentTop > g || null === l.currentTop && g < l.topSpacing ? l.stickyElement.trigger("sticky-bottom-reached", [l]) : null !== l.currentTop && g === l.topSpacing && l.currentTop < g && l.stickyElement.trigger("sticky-bottom-unreached", [l]), l.currentTop = g;
            var m = l.stickyWrapper.parent();
            l.stickyElement.offset().top + l.stickyElement.outerHeight() >= m.offset().top + m.outerHeight() && l.stickyElement.offset().top <= l.topSpacing ? l.stickyElement.css("position", "absolute").css("top", "").css("bottom", 0).css("z-index", "") : l.stickyElement.css("position", "fixed").css("top", g).css("bottom", "").css("z-index", l.zIndex)
          }
        }
      },
      a = function() {
        c = r.height();
        for (var e = 0, i = o.length; e < i; e++) {
          var n = o[e],
            s = null;
          n.getWidthFrom ? n.responsiveWidth && (s = t(n.getWidthFrom).width()) : n.widthFromWrapper && (s = n.stickyWrapper.width()), null != s && n.stickyElement.css("width", s)
        }
      },
      d = {
        init: function(e) {
          return this.each(function() {
            var i = t.extend({}, n, e),
              r = t(this),
              s = r.attr("id"),
              c = s ? s + "-" + n.wrapperClassName : n.wrapperClassName,
              p = t("<div></div>").attr("id", c).addClass(i.wrapperClassName);
            r.wrapAll(function() {
              if (0 == t(this).parent("#" + c).length) return p
            });
            var a = r.parent();
            i.center && a.css({
              width: r.outerWidth(),
              marginLeft: "auto",
              marginRight: "auto"
            }), "right" === r.css("float") && r.css({
              float: "none"
            }).parent().css({
              float: "right"
            }), i.stickyElement = r, i.stickyWrapper = a, i.currentTop = null, o.push(i), d.setWrapperHeight(this), d.setupChangeListeners(this)
          })
        },
        setWrapperHeight: function(e) {
          var i = t(e),
            n = i.parent();
          n && n.css("height", i.outerHeight())
        },
        setupChangeListeners: function(t) {
          window.MutationObserver ? new window.MutationObserver(function(e) {
            (e[0].addedNodes.length || e[0].removedNodes.length) && d.setWrapperHeight(t)
          }).observe(t, {
            subtree: !0,
            childList: !0
          }) : window.addEventListener ? (t.addEventListener("DOMNodeInserted", function() {
            d.setWrapperHeight(t)
          }, !1), t.addEventListener("DOMNodeRemoved", function() {
            d.setWrapperHeight(t)
          }, !1)) : window.attachEvent && (t.attachEvent("onDOMNodeInserted", function() {
            d.setWrapperHeight(t)
          }), t.attachEvent("onDOMNodeRemoved", function() {
            d.setWrapperHeight(t)
          }))
        },
        update: p,
        unstick: function(e) {
          return this.each(function() {
            for (var e = t(this), n = -1, r = o.length; r-- > 0;) o[r].stickyElement.get(0) === this && (i.call(o, r, 1), n = r); - 1 !== n && (e.unwrap(), e.css({
              width: "",
              position: "",
              top: "",
              float: "",
              "z-index": ""
            }))
          })
        }
      };
    window.addEventListener ? (window.addEventListener("scroll", p, !1), window.addEventListener("resize", a, !1)) : window.attachEvent && (window.attachEvent("onscroll", p), window.attachEvent("onresize", a)), t.fn.sticky = function(i) {
      return d[i] ? d[i].apply(this, e.call(arguments, 1)) : "object" != typeof i && i ? void t.error("Method " + i + " does not exist on jQuery.sticky") : d.init.apply(this, arguments)
    }, t.fn.unstick = function(i) {
      return d[i] ? d[i].apply(this, e.call(arguments, 1)) : "object" != typeof i && i ? void t.error("Method " + i + " does not exist on jQuery.sticky") : d.unstick.apply(this, arguments)
    }, t(function() {
      setTimeout(p, 0)
    })
  });
  
  /*
   * classyNav.js 1.0.0
   * Responsive Megamenu plugins
   * Copyright (c) 2018 Designing World - https://themeforest.net/user/designing-world
   */
  
  (function($) {
    $.fn.classyNav = function(options) {
  
      // Variables
      var navContainer = $('.classy-nav-container');
      var classy_nav = $('.classynav ul');
      var classy_navli = $('.classynav > ul > li');
      var navbarToggler = $('.classy-navbar-toggler');
      var closeIcon = $('.classycloseIcon');
      var navToggler = $('.navbarToggler');
      var classyMenu = $('.classy-menu');
      var var_window = $(window);
  
      // default options
      var defaultOpt = $.extend({
        theme: 'light',
        breakpoint: 991,
        openCloseSpeed: 350,
        megaopenCloseSpeed: 700,
        alwaysHidden: false,
        openMobileMenu: 'left',
        dropdownRtl: false,
        stickyNav: false,
        stickyFooterNav: false
      }, options);
  
      return this.each(function() {
  
        // light or dark theme
        if (defaultOpt.theme === 'light' || defaultOpt.theme === 'dark') {
          navContainer.addClass(defaultOpt.theme);
        }
  
        // open mobile menu direction 'left' or 'right' side
        if (defaultOpt.openMobileMenu === 'left' || defaultOpt.openMobileMenu === 'right') {
          navContainer.addClass(defaultOpt.openMobileMenu);
        }
  
        // dropdown rtl
        if (defaultOpt.dropdownRtl === true) {
          navContainer.addClass('dropdown-rtl');
        }
  
        // navbar toggler
        navbarToggler.on('click', function() {
          navToggler.toggleClass('active');
          classyMenu.toggleClass('menu-on');
        });
  
        // close icon
        closeIcon.on('click', function() {
          classyMenu.removeClass('menu-on');
          navToggler.removeClass('active');
        });
  
        // add dropdown & megamenu class in parent li class
        classy_navli.has('.dropdown').addClass('cn-dropdown-item');
        classy_navli.has('.megamenu').addClass('megamenu-item');
  
        // adds toggle button to li items that have children
        classy_nav.find('li a').each(function() {
          if ($(this).next().length > 0) {
            $(this).parent('li').addClass('has-down').append('<span class="dd-trigger"></span>');
          }
        });
  
        // expands the dropdown menu on each click
        classy_nav.find('li .dd-trigger').on('click', function(e) {
          e.preventDefault();
          $(this).parent('li').children('ul').stop(true, true).slideToggle(defaultOpt.openCloseSpeed);
          $(this).parent('li').toggleClass('active');
        });
  
        // add padding in dropdown & megamenu item
        $('.megamenu-item').removeClass('has-down');
  
        // expands the megamenu on each click
        classy_nav.find('li .dd-trigger').on('click', function(e) {
          e.preventDefault();
          $(this).parent('li').children('.megamenu').slideToggle(defaultOpt.megaopenCloseSpeed);
        });
  
        // check browser width in real-time
        function breakpointCheck() {
          var windoWidth = window.innerWidth;
          if (windoWidth <= defaultOpt.breakpoint) {
            navContainer.removeClass('breakpoint-off').addClass('breakpoint-on');
          } else {
            navContainer.removeClass('breakpoint-on').addClass('breakpoint-off');
          }
        }
  
        breakpointCheck();
  
        var_window.on('resize', function() {
          breakpointCheck();
        });
  
        // always hidden enable
        if (defaultOpt.alwaysHidden === true) {
          navContainer.addClass('breakpoint-on').removeClass('breakpoint-off');
        }
      });
    };
  }(jQuery));
  
  // [End Include All Plugins]
  