text: (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  (function (process){
  
  // Use the fastest possible means to execute a task in a future turn
  // of the event loop.
  
  // linked list of tasks (single, with head node)
  var head = {task: void 0, next: null};
  var tail = head;
  var flushing = false;
  var requestFlush = void 0;
  var isNodeJS = false;
  
  function flush() {
      /* jshint loopfunc: true */
  
      while (head.next) {
          head = head.next;
          var task = head.task;
          head.task = void 0;
          var domain = head.domain;
  
          if (domain) {
              head.domain = void 0;
              domain.enter();
          }
  
          try {
              task();
  
          } catch (e) {
              if (isNodeJS) {
                  // In node, uncaught exceptions are considered fatal errors.
                  // Re-throw them synchronously to interrupt flushing!
  
                  // Ensure continuation if the uncaught exception is suppressed
                  // listening "uncaughtException" events (as domains does).
                  // Continue in next event to avoid tick recursion.
                  if (domain) {
                      domain.exit();
                  }
                  setTimeout(flush, 0);
                  if (domain) {
                      domain.enter();
                  }
  
                  throw e;
  
              } else {
                  // In browsers, uncaught exceptions are not fatal.
                  // Re-throw them asynchronously to avoid slow-downs.
                  setTimeout(function() {
                     throw e;
                  }, 0);
              }
          }
  
          if (domain) {
              domain.exit();
          }
      }
  
      flushing = false;
  }
  
  if (typeof process !== "undefined" && process.nextTick) {
      // Node.js before 0.9. Note that some fake-Node environments, like the
      // Mocha test runner, introduce a `process` global without a `nextTick`.
      isNodeJS = true;
  
      requestFlush = function () {
          process.nextTick(flush);
      };
  
  } else if (typeof setImmediate === "function") {
      // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
      if (typeof window !== "undefined") {
          requestFlush = setImmediate.bind(window, flush);
      } else {
          requestFlush = function () {
              setImmediate(flush);
          };
      }
  
  } else if (typeof MessageChannel !== "undefined") {
      // modern browsers
      // http://www.nonblocking.io/2011/06/windownexttick.html
      var channel = new MessageChannel();
      channel.port1.onmessage = flush;
      requestFlush = function () {
          channel.port2.postMessage(0);
      };
  
  } else {
      // old browsers
      requestFlush = function () {
          setTimeout(flush, 0);
      };
  }
  
  function asap(task) {
      tail = tail.next = {
          task: task,
          domain: isNodeJS && process.domain,
          next: null
      };
  
      if (!flushing) {
          flushing = true;
          requestFlush();
      }
  };
  
  module.exports = asap;
  
  
  }).call(this,require('_process'))
  },{"_process":5}],2:[function(require,module,exports){
  /*!
   * Bootstrap v3.3.5 (http://getbootstrap.com)
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under the MIT license
   */
  
  if (typeof jQuery === 'undefined') {
    throw new Error('Bootstrap\'s JavaScript requires jQuery')
  }
  
  +function ($) {
    'use strict';
    var version = $.fn.jquery.split(' ')[0].split('.')
    if ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1)) {
      throw new Error('Bootstrap\'s JavaScript requires jQuery version 1.9.1 or higher')
    }
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: transition.js v3.3.5
   * http://getbootstrap.com/javascript/#transitions
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
    // ============================================================
  
    function transitionEnd() {
      var el = document.createElement('bootstrap')
  
      var transEndEventNames = {
        WebkitTransition : 'webkitTransitionEnd',
        MozTransition    : 'transitionend',
        OTransition      : 'oTransitionEnd otransitionend',
        transition       : 'transitionend'
      }
  
      for (var name in transEndEventNames) {
        if (el.style[name] !== undefined) {
          return { end: transEndEventNames[name] }
        }
      }
  
      return false // explicit for ie8 (  ._.)
    }
  
    // http://blog.alexmaccaw.com/css-transitions
    $.fn.emulateTransitionEnd = function (duration) {
      var called = false
      var $el = this
      $(this).one('bsTransitionEnd', function () { called = true })
      var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
      setTimeout(callback, duration)
      return this
    }
  
    $(function () {
      $.support.transition = transitionEnd()
  
      if (!$.support.transition) return
  
      $.event.special.bsTransitionEnd = {
        bindType: $.support.transition.end,
        delegateType: $.support.transition.end,
        handle: function (e) {
          if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
        }
      }
    })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: alert.js v3.3.5
   * http://getbootstrap.com/javascript/#alerts
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // ALERT CLASS DEFINITION
    // ======================
  
    var dismiss = '[data-dismiss="alert"]'
    var Alert   = function (el) {
      $(el).on('click', dismiss, this.close)
    }
  
    Alert.VERSION = '3.3.5'
  
    Alert.TRANSITION_DURATION = 150
  
    Alert.prototype.close = function (e) {
      var $this    = $(this)
      var selector = $this.attr('data-target')
  
      if (!selector) {
        selector = $this.attr('href')
        selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
      }
  
      var $parent = $(selector)
  
      if (e) e.preventDefault()
  
      if (!$parent.length) {
        $parent = $this.closest('.alert')
      }
  
      $parent.trigger(e = $.Event('close.bs.alert'))
  
      if (e.isDefaultPrevented()) return
  
      $parent.removeClass('in')
  
      function removeElement() {
        // detach from parent, fire event then clean up data
        $parent.detach().trigger('closed.bs.alert').remove()
      }
  
      $.support.transition && $parent.hasClass('fade') ?
        $parent
          .one('bsTransitionEnd', removeElement)
          .emulateTransitionEnd(Alert.TRANSITION_DURATION) :
        removeElement()
    }
  
  
    // ALERT PLUGIN DEFINITION
    // =======================
  
    function Plugin(option) {
      return this.each(function () {
        var $this = $(this)
        var data  = $this.data('bs.alert')
  
        if (!data) $this.data('bs.alert', (data = new Alert(this)))
        if (typeof option == 'string') data[option].call($this)
      })
    }
  
    var old = $.fn.alert
  
    $.fn.alert             = Plugin
    $.fn.alert.Constructor = Alert
  
  
    // ALERT NO CONFLICT
    // =================
  
    $.fn.alert.noConflict = function () {
      $.fn.alert = old
      return this
    }
  
  
    // ALERT DATA-API
    // ==============
  
    $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: button.js v3.3.5
   * http://getbootstrap.com/javascript/#buttons
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // BUTTON PUBLIC CLASS DEFINITION
    // ==============================
  
    var Button = function (element, options) {
      this.$element  = $(element)
      this.options   = $.extend({}, Button.DEFAULTS, options)
      this.isLoading = false
    }
  
    Button.VERSION  = '3.3.5'
  
    Button.DEFAULTS = {
      loadingText: 'loading...'
    }
  
    Button.prototype.setState = function (state) {
      var d    = 'disabled'
      var $el  = this.$element
      var val  = $el.is('input') ? 'val' : 'html'
      var data = $el.data()
  
      state += 'Text'
  
      if (data.resetText == null) $el.data('resetText', $el[val]())
  
      // push to event loop to allow forms to submit
      setTimeout($.proxy(function () {
        $el[val](data[state] == null ? this.options[state] : data[state])
  
        if (state == 'loadingText') {
          this.isLoading = true
          $el.addClass(d).attr(d, d)
        } else if (this.isLoading) {
          this.isLoading = false
          $el.removeClass(d).removeAttr(d)
        }
      }, this), 0)
    }
  
    Button.prototype.toggle = function () {
      var changed = true
      var $parent = this.$element.closest('[data-toggle="buttons"]')
  
      if ($parent.length) {
        var $input = this.$element.find('input')
        if ($input.prop('type') == 'radio') {
          if ($input.prop('checked')) changed = false
          $parent.find('.active').removeClass('active')
          this.$element.addClass('active')
        } else if ($input.prop('type') == 'checkbox') {
          if (($input.prop('checked')) !== this.$element.hasClass('active')) changed = false
          this.$element.toggleClass('active')
        }
        $input.prop('checked', this.$element.hasClass('active'))
        if (changed) $input.trigger('change')
      } else {
        this.$element.attr('aria-pressed', !this.$element.hasClass('active'))
        this.$element.toggleClass('active')
      }
    }
  
  
    // BUTTON PLUGIN DEFINITION
    // ========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.button')
        var options = typeof option == 'object' && option
  
        if (!data) $this.data('bs.button', (data = new Button(this, options)))
  
        if (option == 'toggle') data.toggle()
        else if (option) data.setState(option)
      })
    }
  
    var old = $.fn.button
  
    $.fn.button             = Plugin
    $.fn.button.Constructor = Button
  
  
    // BUTTON NO CONFLICT
    // ==================
  
    $.fn.button.noConflict = function () {
      $.fn.button = old
      return this
    }
  
  
    // BUTTON DATA-API
    // ===============
  
    $(document)
      .on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {
        var $btn = $(e.target)
        if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
        Plugin.call($btn, 'toggle')
        if (!($(e.target).is('input[type="radio"]') || $(e.target).is('input[type="checkbox"]'))) e.preventDefault()
      })
      .on('focus.bs.button.data-api blur.bs.button.data-api', '[data-toggle^="button"]', function (e) {
        $(e.target).closest('.btn').toggleClass('focus', /^focus(in)?$/.test(e.type))
      })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: carousel.js v3.3.5
   * http://getbootstrap.com/javascript/#carousel
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // CAROUSEL CLASS DEFINITION
    // =========================
  
    var Carousel = function (element, options) {
      this.$element    = $(element)
      this.$indicators = this.$element.find('.carousel-indicators')
      this.options     = options
      this.paused      = null
      this.sliding     = null
      this.interval    = null
      this.$active     = null
      this.$items      = null
  
      this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this))
  
      this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element
        .on('mouseenter.bs.carousel', $.proxy(this.pause, this))
        .on('mouseleave.bs.carousel', $.proxy(this.cycle, this))
    }
  
    Carousel.VERSION  = '3.3.5'
  
    Carousel.TRANSITION_DURATION = 600
  
    Carousel.DEFAULTS = {
      interval: 5000,
      pause: 'hover',
      wrap: true,
      keyboard: true
    }
  
    Carousel.prototype.keydown = function (e) {
      if (/input|textarea/i.test(e.target.tagName)) return
      switch (e.which) {
        case 37: this.prev(); break
        case 39: this.next(); break
        default: return
      }
  
      e.preventDefault()
    }
  
    Carousel.prototype.cycle = function (e) {
      e || (this.paused = false)
  
      this.interval && clearInterval(this.interval)
  
      this.options.interval
        && !this.paused
        && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
  
      return this
    }
  
    Carousel.prototype.getItemIndex = function (item) {
      this.$items = item.parent().children('.item')
      return this.$items.index(item || this.$active)
    }
  
    Carousel.prototype.getItemForDirection = function (direction, active) {
      var activeIndex = this.getItemIndex(active)
      var willWrap = (direction == 'prev' && activeIndex === 0)
                  || (direction == 'next' && activeIndex == (this.$items.length - 1))
      if (willWrap && !this.options.wrap) return active
      var delta = direction == 'prev' ? -1 : 1
      var itemIndex = (activeIndex + delta) % this.$items.length
      return this.$items.eq(itemIndex)
    }
  
    Carousel.prototype.to = function (pos) {
      var that        = this
      var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))
  
      if (pos > (this.$items.length - 1) || pos < 0) return
  
      if (this.sliding)       return this.$element.one('slid.bs.carousel', function () { that.to(pos) }) // yes, "slid"
      if (activeIndex == pos) return this.pause().cycle()
  
      return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos))
    }
  
    Carousel.prototype.pause = function (e) {
      e || (this.paused = true)
  
      if (this.$element.find('.next, .prev').length && $.support.transition) {
        this.$element.trigger($.support.transition.end)
        this.cycle(true)
      }
  
      this.interval = clearInterval(this.interval)
  
      return this
    }
  
    Carousel.prototype.next = function () {
      if (this.sliding) return
      return this.slide('next')
    }
  
    Carousel.prototype.prev = function () {
      if (this.sliding) return
      return this.slide('prev')
    }
  
    Carousel.prototype.slide = function (type, next) {
      var $active   = this.$element.find('.item.active')
      var $next     = next || this.getItemForDirection(type, $active)
      var isCycling = this.interval
      var direction = type == 'next' ? 'left' : 'right'
      var that      = this
  
      if ($next.hasClass('active')) return (this.sliding = false)
  
      var relatedTarget = $next[0]
      var slideEvent = $.Event('slide.bs.carousel', {
        relatedTarget: relatedTarget,
        direction: direction
      })
      this.$element.trigger(slideEvent)
      if (slideEvent.isDefaultPrevented()) return
  
      this.sliding = true
  
      isCycling && this.pause()
  
      if (this.$indicators.length) {
        this.$indicators.find('.active').removeClass('active')
        var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])
        $nextIndicator && $nextIndicator.addClass('active')
      }
  
      var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }) // yes, "slid"
      if ($.support.transition && this.$element.hasClass('slide')) {
        $next.addClass(type)
        $next[0].offsetWidth // force reflow
        $active.addClass(direction)
        $next.addClass(direction)
        $active
          .one('bsTransitionEnd', function () {
            $next.removeClass([type, direction].join(' ')).addClass('active')
            $active.removeClass(['active', direction].join(' '))
            that.sliding = false
            setTimeout(function () {
              that.$element.trigger(slidEvent)
            }, 0)
          })
          .emulateTransitionEnd(Carousel.TRANSITION_DURATION)
      } else {
        $active.removeClass('active')
        $next.addClass('active')
        this.sliding = false
        this.$element.trigger(slidEvent)
      }
  
      isCycling && this.cycle()
  
      return this
    }
  
  
    // CAROUSEL PLUGIN DEFINITION
    // ==========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.carousel')
        var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
        var action  = typeof option == 'string' ? option : options.slide
  
        if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))
        if (typeof option == 'number') data.to(option)
        else if (action) data[action]()
        else if (options.interval) data.pause().cycle()
      })
    }
  
    var old = $.fn.carousel
  
    $.fn.carousel             = Plugin
    $.fn.carousel.Constructor = Carousel
  
  
    // CAROUSEL NO CONFLICT
    // ====================
  
    $.fn.carousel.noConflict = function () {
      $.fn.carousel = old
      return this
    }
  
  
    // CAROUSEL DATA-API
    // =================
  
    var clickHandler = function (e) {
      var href
      var $this   = $(this)
      var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
      if (!$target.hasClass('carousel')) return
      var options = $.extend({}, $target.data(), $this.data())
      var slideIndex = $this.attr('data-slide-to')
      if (slideIndex) options.interval = false
  
      Plugin.call($target, options)
  
      if (slideIndex) {
        $target.data('bs.carousel').to(slideIndex)
      }
  
      e.preventDefault()
    }
  
    $(document)
      .on('click.bs.carousel.data-api', '[data-slide]', clickHandler)
      .on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)
  
    $(window).on('load', function () {
      $('[data-ride="carousel"]').each(function () {
        var $carousel = $(this)
        Plugin.call($carousel, $carousel.data())
      })
    })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: collapse.js v3.3.5
   * http://getbootstrap.com/javascript/#collapse
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // COLLAPSE PUBLIC CLASS DEFINITION
    // ================================
  
    var Collapse = function (element, options) {
      this.$element      = $(element)
      this.options       = $.extend({}, Collapse.DEFAULTS, options)
      this.$trigger      = $('[data-toggle="collapse"][href="#' + element.id + '"],' +
                             '[data-toggle="collapse"][data-target="#' + element.id + '"]')
      this.transitioning = null
  
      if (this.options.parent) {
        this.$parent = this.getParent()
      } else {
        this.addAriaAndCollapsedClass(this.$element, this.$trigger)
      }
  
      if (this.options.toggle) this.toggle()
    }
  
    Collapse.VERSION  = '3.3.5'
  
    Collapse.TRANSITION_DURATION = 350
  
    Collapse.DEFAULTS = {
      toggle: true
    }
  
    Collapse.prototype.dimension = function () {
      var hasWidth = this.$element.hasClass('width')
      return hasWidth ? 'width' : 'height'
    }
  
    Collapse.prototype.show = function () {
      if (this.transitioning || this.$element.hasClass('in')) return
  
      var activesData
      var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')
  
      if (actives && actives.length) {
        activesData = actives.data('bs.collapse')
        if (activesData && activesData.transitioning) return
      }
  
      var startEvent = $.Event('show.bs.collapse')
      this.$element.trigger(startEvent)
      if (startEvent.isDefaultPrevented()) return
  
      if (actives && actives.length) {
        Plugin.call(actives, 'hide')
        activesData || actives.data('bs.collapse', null)
      }
  
      var dimension = this.dimension()
  
      this.$element
        .removeClass('collapse')
        .addClass('collapsing')[dimension](0)
        .attr('aria-expanded', true)
  
      this.$trigger
        .removeClass('collapsed')
        .attr('aria-expanded', true)
  
      this.transitioning = 1
  
      var complete = function () {
        this.$element
          .removeClass('collapsing')
          .addClass('collapse in')[dimension]('')
        this.transitioning = 0
        this.$element
          .trigger('shown.bs.collapse')
      }
  
      if (!$.support.transition) return complete.call(this)
  
      var scrollSize = $.camelCase(['scroll', dimension].join('-'))
  
      this.$element
        .one('bsTransitionEnd', $.proxy(complete, this))
        .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])
    }
  
    Collapse.prototype.hide = function () {
      if (this.transitioning || !this.$element.hasClass('in')) return
  
      var startEvent = $.Event('hide.bs.collapse')
      this.$element.trigger(startEvent)
      if (startEvent.isDefaultPrevented()) return
  
      var dimension = this.dimension()
  
      this.$element[dimension](this.$element[dimension]())[0].offsetHeight
  
      this.$element
        .addClass('collapsing')
        .removeClass('collapse in')
        .attr('aria-expanded', false)
  
      this.$trigger
        .addClass('collapsed')
        .attr('aria-expanded', false)
  
      this.transitioning = 1
  
      var complete = function () {
        this.transitioning = 0
        this.$element
          .removeClass('collapsing')
          .addClass('collapse')
          .trigger('hidden.bs.collapse')
      }
  
      if (!$.support.transition) return complete.call(this)
  
      this.$element
        [dimension](0)
        .one('bsTransitionEnd', $.proxy(complete, this))
        .emulateTransitionEnd(Collapse.TRANSITION_DURATION)
    }
  
    Collapse.prototype.toggle = function () {
      this[this.$element.hasClass('in') ? 'hide' : 'show']()
    }
  
    Collapse.prototype.getParent = function () {
      return $(this.options.parent)
        .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
        .each($.proxy(function (i, element) {
          var $element = $(element)
          this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)
        }, this))
        .end()
    }
  
    Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
      var isOpen = $element.hasClass('in')
  
      $element.attr('aria-expanded', isOpen)
      $trigger
        .toggleClass('collapsed', !isOpen)
        .attr('aria-expanded', isOpen)
    }
  
    function getTargetFromTrigger($trigger) {
      var href
      var target = $trigger.attr('data-target')
        || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
  
      return $(target)
    }
  
  
    // COLLAPSE PLUGIN DEFINITION
    // ==========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.collapse')
        var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
  
        if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false
        if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.collapse
  
    $.fn.collapse             = Plugin
    $.fn.collapse.Constructor = Collapse
  
  
    // COLLAPSE NO CONFLICT
    // ====================
  
    $.fn.collapse.noConflict = function () {
      $.fn.collapse = old
      return this
    }
  
  
    // COLLAPSE DATA-API
    // =================
  
    $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
      var $this   = $(this)
  
      if (!$this.attr('data-target')) e.preventDefault()
  
      var $target = getTargetFromTrigger($this)
      var data    = $target.data('bs.collapse')
      var option  = data ? 'toggle' : $this.data()
  
      Plugin.call($target, option)
    })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: dropdown.js v3.3.5
   * http://getbootstrap.com/javascript/#dropdowns
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // DROPDOWN CLASS DEFINITION
    // =========================
  
    var backdrop = '.dropdown-backdrop'
    var toggle   = '[data-toggle="dropdown"]'
    var Dropdown = function (element) {
      $(element).on('click.bs.dropdown', this.toggle)
    }
  
    Dropdown.VERSION = '3.3.5'
  
    function getParent($this) {
      var selector = $this.attr('data-target')
  
      if (!selector) {
        selector = $this.attr('href')
        selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
      }
  
      var $parent = selector && $(selector)
  
      return $parent && $parent.length ? $parent : $this.parent()
    }
  
    function clearMenus(e) {
      if (e && e.which === 3) return
      $(backdrop).remove()
      $(toggle).each(function () {
        var $this         = $(this)
        var $parent       = getParent($this)
        var relatedTarget = { relatedTarget: this }
  
        if (!$parent.hasClass('open')) return
  
        if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return
  
        $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
  
        if (e.isDefaultPrevented()) return
  
        $this.attr('aria-expanded', 'false')
        $parent.removeClass('open').trigger('hidden.bs.dropdown', relatedTarget)
      })
    }
  
    Dropdown.prototype.toggle = function (e) {
      var $this = $(this)
  
      if ($this.is('.disabled, :disabled')) return
  
      var $parent  = getParent($this)
      var isActive = $parent.hasClass('open')
  
      clearMenus()
  
      if (!isActive) {
        if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
          // if mobile we use a backdrop because click events don't delegate
          $(document.createElement('div'))
            .addClass('dropdown-backdrop')
            .insertAfter($(this))
            .on('click', clearMenus)
        }
  
        var relatedTarget = { relatedTarget: this }
        $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
  
        if (e.isDefaultPrevented()) return
  
        $this
          .trigger('focus')
          .attr('aria-expanded', 'true')
  
        $parent
          .toggleClass('open')
          .trigger('shown.bs.dropdown', relatedTarget)
      }
  
      return false
    }
  
    Dropdown.prototype.keydown = function (e) {
      if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return
  
      var $this = $(this)
  
      e.preventDefault()
      e.stopPropagation()
  
      if ($this.is('.disabled, :disabled')) return
  
      var $parent  = getParent($this)
      var isActive = $parent.hasClass('open')
  
      if (!isActive && e.which != 27 || isActive && e.which == 27) {
        if (e.which == 27) $parent.find(toggle).trigger('focus')
        return $this.trigger('click')
      }
  
      var desc = ' li:not(.disabled):visible a'
      var $items = $parent.find('.dropdown-menu' + desc)
  
      if (!$items.length) return
  
      var index = $items.index(e.target)
  
      if (e.which == 38 && index > 0)                 index--         // up
      if (e.which == 40 && index < $items.length - 1) index++         // down
      if (!~index)                                    index = 0
  
      $items.eq(index).trigger('focus')
    }
  
  
    // DROPDOWN PLUGIN DEFINITION
    // ==========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this = $(this)
        var data  = $this.data('bs.dropdown')
  
        if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
        if (typeof option == 'string') data[option].call($this)
      })
    }
  
    var old = $.fn.dropdown
  
    $.fn.dropdown             = Plugin
    $.fn.dropdown.Constructor = Dropdown
  
  
    // DROPDOWN NO CONFLICT
    // ====================
  
    $.fn.dropdown.noConflict = function () {
      $.fn.dropdown = old
      return this
    }
  
  
    // APPLY TO STANDARD DROPDOWN ELEMENTS
    // ===================================
  
    $(document)
      .on('click.bs.dropdown.data-api', clearMenus)
      .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
      .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
      .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)
      .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: modal.js v3.3.5
   * http://getbootstrap.com/javascript/#modals
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // MODAL CLASS DEFINITION
    // ======================
  
    var Modal = function (element, options) {
      this.options             = options
      this.$body               = $(document.body)
      this.$element            = $(element)
      this.$dialog             = this.$element.find('.modal-dialog')
      this.$backdrop           = null
      this.isShown             = null
      this.originalBodyPad     = null
      this.scrollbarWidth      = 0
      this.ignoreBackdropClick = false
  
      if (this.options.remote) {
        this.$element
          .find('.modal-content')
          .load(this.options.remote, $.proxy(function () {
            this.$element.trigger('loaded.bs.modal')
          }, this))
      }
    }
  
    Modal.VERSION  = '3.3.5'
  
    Modal.TRANSITION_DURATION = 300
    Modal.BACKDROP_TRANSITION_DURATION = 150
  
    Modal.DEFAULTS = {
      backdrop: true,
      keyboard: true,
      show: true
    }
  
    Modal.prototype.toggle = function (_relatedTarget) {
      return this.isShown ? this.hide() : this.show(_relatedTarget)
    }
  
    Modal.prototype.show = function (_relatedTarget) {
      var that = this
      var e    = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
  
      this.$element.trigger(e)
  
      if (this.isShown || e.isDefaultPrevented()) return
  
      this.isShown = true
  
      this.checkScrollbar()
      this.setScrollbar()
      this.$body.addClass('modal-open')
  
      this.escape()
      this.resize()
  
      this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
  
      this.$dialog.on('mousedown.dismiss.bs.modal', function () {
        that.$element.one('mouseup.dismiss.bs.modal', function (e) {
          if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
        })
      })
  
      this.backdrop(function () {
        var transition = $.support.transition && that.$element.hasClass('fade')
  
        if (!that.$element.parent().length) {
          that.$element.appendTo(that.$body) // don't move modals dom position
        }
  
        that.$element
          .show()
          .scrollTop(0)
  
        that.adjustDialog()
  
        if (transition) {
          that.$element[0].offsetWidth // force reflow
        }
  
        that.$element.addClass('in')
  
        that.enforceFocus()
  
        var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
  
        transition ?
          that.$dialog // wait for modal to slide in
            .one('bsTransitionEnd', function () {
              that.$element.trigger('focus').trigger(e)
            })
            .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
          that.$element.trigger('focus').trigger(e)
      })
    }
  
    Modal.prototype.hide = function (e) {
      if (e) e.preventDefault()
  
      e = $.Event('hide.bs.modal')
  
      this.$element.trigger(e)
  
      if (!this.isShown || e.isDefaultPrevented()) return
  
      this.isShown = false
  
      this.escape()
      this.resize()
  
      $(document).off('focusin.bs.modal')
  
      this.$element
        .removeClass('in')
        .off('click.dismiss.bs.modal')
        .off('mouseup.dismiss.bs.modal')
  
      this.$dialog.off('mousedown.dismiss.bs.modal')
  
      $.support.transition && this.$element.hasClass('fade') ?
        this.$element
          .one('bsTransitionEnd', $.proxy(this.hideModal, this))
          .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
        this.hideModal()
    }
  
    Modal.prototype.enforceFocus = function () {
      $(document)
        .off('focusin.bs.modal') // guard against infinite focus loop
        .on('focusin.bs.modal', $.proxy(function (e) {
          if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {
            this.$element.trigger('focus')
          }
        }, this))
    }
  
    Modal.prototype.escape = function () {
      if (this.isShown && this.options.keyboard) {
        this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
          e.which == 27 && this.hide()
        }, this))
      } else if (!this.isShown) {
        this.$element.off('keydown.dismiss.bs.modal')
      }
    }
  
    Modal.prototype.resize = function () {
      if (this.isShown) {
        $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
      } else {
        $(window).off('resize.bs.modal')
      }
    }
  
    Modal.prototype.hideModal = function () {
      var that = this
      this.$element.hide()
      this.backdrop(function () {
        that.$body.removeClass('modal-open')
        that.resetAdjustments()
        that.resetScrollbar()
        that.$element.trigger('hidden.bs.modal')
      })
    }
  
    Modal.prototype.removeBackdrop = function () {
      this.$backdrop && this.$backdrop.remove()
      this.$backdrop = null
    }
  
    Modal.prototype.backdrop = function (callback) {
      var that = this
      var animate = this.$element.hasClass('fade') ? 'fade' : ''
  
      if (this.isShown && this.options.backdrop) {
        var doAnimate = $.support.transition && animate
  
        this.$backdrop = $(document.createElement('div'))
          .addClass('modal-backdrop ' + animate)
          .appendTo(this.$body)
  
        this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
          if (this.ignoreBackdropClick) {
            this.ignoreBackdropClick = false
            return
          }
          if (e.target !== e.currentTarget) return
          this.options.backdrop == 'static'
            ? this.$element[0].focus()
            : this.hide()
        }, this))
  
        if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
  
        this.$backdrop.addClass('in')
  
        if (!callback) return
  
        doAnimate ?
          this.$backdrop
            .one('bsTransitionEnd', callback)
            .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
          callback()
  
      } else if (!this.isShown && this.$backdrop) {
        this.$backdrop.removeClass('in')
  
        var callbackRemove = function () {
          that.removeBackdrop()
          callback && callback()
        }
        $.support.transition && this.$element.hasClass('fade') ?
          this.$backdrop
            .one('bsTransitionEnd', callbackRemove)
            .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
          callbackRemove()
  
      } else if (callback) {
        callback()
      }
    }
  
    // these following methods are used to handle overflowing modals
  
    Modal.prototype.handleUpdate = function () {
      this.adjustDialog()
    }
  
    Modal.prototype.adjustDialog = function () {
      var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight
  
      this.$element.css({
        paddingLeft:  !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
        paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
      })
    }
  
    Modal.prototype.resetAdjustments = function () {
      this.$element.css({
        paddingLeft: '',
        paddingRight: ''
      })
    }
  
    Modal.prototype.checkScrollbar = function () {
      var fullWindowWidth = window.innerWidth
      if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
        var documentElementRect = document.documentElement.getBoundingClientRect()
        fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
      }
      this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
      this.scrollbarWidth = this.measureScrollbar()
    }
  
    Modal.prototype.setScrollbar = function () {
      var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
      this.originalBodyPad = document.body.style.paddingRight || ''
      if (this.bodyIsOverflowing) this.$body.css('padding-right', bodyPad + this.scrollbarWidth)
    }
  
    Modal.prototype.resetScrollbar = function () {
      this.$body.css('padding-right', this.originalBodyPad)
    }
  
    Modal.prototype.measureScrollbar = function () { // thx walsh
      var scrollDiv = document.createElement('div')
      scrollDiv.className = 'modal-scrollbar-measure'
      this.$body.append(scrollDiv)
      var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
      this.$body[0].removeChild(scrollDiv)
      return scrollbarWidth
    }
  
  
    // MODAL PLUGIN DEFINITION
    // =======================
  
    function Plugin(option, _relatedTarget) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.modal')
        var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
  
        if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
        if (typeof option == 'string') data[option](_relatedTarget)
        else if (options.show) data.show(_relatedTarget)
      })
    }
  
    var old = $.fn.modal
  
    $.fn.modal             = Plugin
    $.fn.modal.Constructor = Modal
  
  
    // MODAL NO CONFLICT
    // =================
  
    $.fn.modal.noConflict = function () {
      $.fn.modal = old
      return this
    }
  
  
    // MODAL DATA-API
    // ==============
  
    $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
      var $this   = $(this)
      var href    = $this.attr('href')
      var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) // strip for ie7
      var option  = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
  
      if ($this.is('a')) e.preventDefault()
  
      $target.one('show.bs.modal', function (showEvent) {
        if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
        $target.one('hidden.bs.modal', function () {
          $this.is(':visible') && $this.trigger('focus')
        })
      })
      Plugin.call($target, option, this)
    })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: tooltip.js v3.3.5
   * http://getbootstrap.com/javascript/#tooltip
   * Inspired by the original jQuery.tipsy by Jason Frame
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // TOOLTIP PUBLIC CLASS DEFINITION
    // ===============================
  
    var Tooltip = function (element, options) {
      this.type       = null
      this.options    = null
      this.enabled    = null
      this.timeout    = null
      this.hoverState = null
      this.$element   = null
      this.inState    = null
  
      this.init('tooltip', element, options)
    }
  
    Tooltip.VERSION  = '3.3.5'
  
    Tooltip.TRANSITION_DURATION = 150
  
    Tooltip.DEFAULTS = {
      animation: true,
      placement: 'top',
      selector: false,
      template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
      trigger: 'hover focus',
      title: '',
      delay: 0,
      html: false,
      container: false,
      viewport: {
        selector: 'body',
        padding: 0
      }
    }
  
    Tooltip.prototype.init = function (type, element, options) {
      this.enabled   = true
      this.type      = type
      this.$element  = $(element)
      this.options   = this.getOptions(options)
      this.$viewport = this.options.viewport && $($.isFunction(this.options.viewport) ? this.options.viewport.call(this, this.$element) : (this.options.viewport.selector || this.options.viewport))
      this.inState   = { click: false, hover: false, focus: false }
  
      if (this.$element[0] instanceof document.constructor && !this.options.selector) {
        throw new Error('`selector` option must be specified when initializing ' + this.type + ' on the window.document object!')
      }
  
      var triggers = this.options.trigger.split(' ')
  
      for (var i = triggers.length; i--;) {
        var trigger = triggers[i]
  
        if (trigger == 'click') {
          this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
        } else if (trigger != 'manual') {
          var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
          var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
  
          this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
          this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
        }
      }
  
      this.options.selector ?
        (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
        this.fixTitle()
    }
  
    Tooltip.prototype.getDefaults = function () {
      return Tooltip.DEFAULTS
    }
  
    Tooltip.prototype.getOptions = function (options) {
      options = $.extend({}, this.getDefaults(), this.$element.data(), options)
  
      if (options.delay && typeof options.delay == 'number') {
        options.delay = {
          show: options.delay,
          hide: options.delay
        }
      }
  
      return options
    }
  
    Tooltip.prototype.getDelegateOptions = function () {
      var options  = {}
      var defaults = this.getDefaults()
  
      this._options && $.each(this._options, function (key, value) {
        if (defaults[key] != value) options[key] = value
      })
  
      return options
    }
  
    Tooltip.prototype.enter = function (obj) {
      var self = obj instanceof this.constructor ?
        obj : $(obj.currentTarget).data('bs.' + this.type)
  
      if (!self) {
        self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
        $(obj.currentTarget).data('bs.' + this.type, self)
      }
  
      if (obj instanceof $.Event) {
        self.inState[obj.type == 'focusin' ? 'focus' : 'hover'] = true
      }
  
      if (self.tip().hasClass('in') || self.hoverState == 'in') {
        self.hoverState = 'in'
        return
      }
  
      clearTimeout(self.timeout)
  
      self.hoverState = 'in'
  
      if (!self.options.delay || !self.options.delay.show) return self.show()
  
      self.timeout = setTimeout(function () {
        if (self.hoverState == 'in') self.show()
      }, self.options.delay.show)
    }
  
    Tooltip.prototype.isInStateTrue = function () {
      for (var key in this.inState) {
        if (this.inState[key]) return true
      }
  
      return false
    }
  
    Tooltip.prototype.leave = function (obj) {
      var self = obj instanceof this.constructor ?
        obj : $(obj.currentTarget).data('bs.' + this.type)
  
      if (!self) {
        self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
        $(obj.currentTarget).data('bs.' + this.type, self)
      }
  
      if (obj instanceof $.Event) {
        self.inState[obj.type == 'focusout' ? 'focus' : 'hover'] = false
      }
  
      if (self.isInStateTrue()) return
  
      clearTimeout(self.timeout)
  
      self.hoverState = 'out'
  
      if (!self.options.delay || !self.options.delay.hide) return self.hide()
  
      self.timeout = setTimeout(function () {
        if (self.hoverState == 'out') self.hide()
      }, self.options.delay.hide)
    }
  
    Tooltip.prototype.show = function () {
      var e = $.Event('show.bs.' + this.type)
  
      if (this.hasContent() && this.enabled) {
        this.$element.trigger(e)
  
        var inDom = $.contains(this.$element[0].ownerDocument.documentElement, this.$element[0])
        if (e.isDefaultPrevented() || !inDom) return
        var that = this
  
        var $tip = this.tip()
  
        var tipId = this.getUID(this.type)
  
        this.setContent()
        $tip.attr('id', tipId)
        this.$element.attr('aria-describedby', tipId)
  
        if (this.options.animation) $tip.addClass('fade')
  
        var placement = typeof this.options.placement == 'function' ?
          this.options.placement.call(this, $tip[0], this.$element[0]) :
          this.options.placement
  
        var autoToken = /\s?auto?\s?/i
        var autoPlace = autoToken.test(placement)
        if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
  
        $tip
          .detach()
          .css({ top: 0, left: 0, display: 'block' })
          .addClass(placement)
          .data('bs.' + this.type, this)
  
        this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
        this.$element.trigger('inserted.bs.' + this.type)
  
        var pos          = this.getPosition()
        var actualWidth  = $tip[0].offsetWidth
        var actualHeight = $tip[0].offsetHeight
  
        if (autoPlace) {
          var orgPlacement = placement
          var viewportDim = this.getPosition(this.$viewport)
  
          placement = placement == 'bottom' && pos.bottom + actualHeight > viewportDim.bottom ? 'top'    :
                      placement == 'top'    && pos.top    - actualHeight < viewportDim.top    ? 'bottom' :
                      placement == 'right'  && pos.right  + actualWidth  > viewportDim.width  ? 'left'   :
                      placement == 'left'   && pos.left   - actualWidth  < viewportDim.left   ? 'right'  :
                      placement
  
          $tip
            .removeClass(orgPlacement)
            .addClass(placement)
        }
  
        var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
  
        this.applyPlacement(calculatedOffset, placement)
  
        var complete = function () {
          var prevHoverState = that.hoverState
          that.$element.trigger('shown.bs.' + that.type)
          that.hoverState = null
  
          if (prevHoverState == 'out') that.leave(that)
        }
  
        $.support.transition && this.$tip.hasClass('fade') ?
          $tip
            .one('bsTransitionEnd', complete)
            .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
          complete()
      }
    }
  
    Tooltip.prototype.applyPlacement = function (offset, placement) {
      var $tip   = this.tip()
      var width  = $tip[0].offsetWidth
      var height = $tip[0].offsetHeight
  
      // manually read margins because getBoundingClientRect includes difference
      var marginTop = parseInt($tip.css('margin-top'), 10)
      var marginLeft = parseInt($tip.css('margin-left'), 10)
  
      // we must check for NaN for ie 8/9
      if (isNaN(marginTop))  marginTop  = 0
      if (isNaN(marginLeft)) marginLeft = 0
  
      offset.top  += marginTop
      offset.left += marginLeft
  
      // $.fn.offset doesn't round pixel values
      // so we use setOffset directly with our own function B-0
      $.offset.setOffset($tip[0], $.extend({
        using: function (props) {
          $tip.css({
            top: Math.round(props.top),
            left: Math.round(props.left)
          })
        }
      }, offset), 0)
  
      $tip.addClass('in')
  
      // check to see if placing tip in new offset caused the tip to resize itself
      var actualWidth  = $tip[0].offsetWidth
      var actualHeight = $tip[0].offsetHeight
  
      if (placement == 'top' && actualHeight != height) {
        offset.top = offset.top + height - actualHeight
      }
  
      var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
  
      if (delta.left) offset.left += delta.left
      else offset.top += delta.top
  
      var isVertical          = /top|bottom/.test(placement)
      var arrowDelta          = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
      var arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight'
  
      $tip.offset(offset)
      this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], isVertical)
    }
  
    Tooltip.prototype.replaceArrow = function (delta, dimension, isVertical) {
      this.arrow()
        .css(isVertical ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')
        .css(isVertical ? 'top' : 'left', '')
    }
  
    Tooltip.prototype.setContent = function () {
      var $tip  = this.tip()
      var title = this.getTitle()
  
      $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
      $tip.removeClass('fade in top bottom left right')
    }
  
    Tooltip.prototype.hide = function (callback) {
      var that = this
      var $tip = $(this.$tip)
      var e    = $.Event('hide.bs.' + this.type)
  
      function complete() {
        if (that.hoverState != 'in') $tip.detach()
        that.$element
          .removeAttr('aria-describedby')
          .trigger('hidden.bs.' + that.type)
        callback && callback()
      }
  
      this.$element.trigger(e)
  
      if (e.isDefaultPrevented()) return
  
      $tip.removeClass('in')
  
      $.support.transition && $tip.hasClass('fade') ?
        $tip
          .one('bsTransitionEnd', complete)
          .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
        complete()
  
      this.hoverState = null
  
      return this
    }
  
    Tooltip.prototype.fixTitle = function () {
      var $e = this.$element
      if ($e.attr('title') || typeof $e.attr('data-original-title') != 'string') {
        $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
      }
    }
  
    Tooltip.prototype.hasContent = function () {
      return this.getTitle()
    }
  
    Tooltip.prototype.getPosition = function ($element) {
      $element   = $element || this.$element
  
      var el     = $element[0]
      var isBody = el.tagName == 'BODY'
  
      var elRect    = el.getBoundingClientRect()
      if (elRect.width == null) {
        // width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093
        elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })
      }
      var elOffset  = isBody ? { top: 0, left: 0 } : $element.offset()
      var scroll    = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }
      var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null
  
      return $.extend({}, elRect, scroll, outerDims, elOffset)
    }
  
    Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
      return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2 } :
             placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
             placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
          /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
  
    }
  
    Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
      var delta = { top: 0, left: 0 }
      if (!this.$viewport) return delta
  
      var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
      var viewportDimensions = this.getPosition(this.$viewport)
  
      if (/right|left/.test(placement)) {
        var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll
        var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
        if (topEdgeOffset < viewportDimensions.top) { // top overflow
          delta.top = viewportDimensions.top - topEdgeOffset
        } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
          delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
        }
      } else {
        var leftEdgeOffset  = pos.left - viewportPadding
        var rightEdgeOffset = pos.left + viewportPadding + actualWidth
        if (leftEdgeOffset < viewportDimensions.left) { // left overflow
          delta.left = viewportDimensions.left - leftEdgeOffset
        } else if (rightEdgeOffset > viewportDimensions.right) { // right overflow
          delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
        }
      }
  
      return delta
    }
  
    Tooltip.prototype.getTitle = function () {
      var title
      var $e = this.$element
      var o  = this.options
  
      title = $e.attr('data-original-title')
        || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
  
      return title
    }
  
    Tooltip.prototype.getUID = function (prefix) {
      do prefix += ~~(Math.random() * 1000000)
      while (document.getElementById(prefix))
      return prefix
    }
  
    Tooltip.prototype.tip = function () {
      if (!this.$tip) {
        this.$tip = $(this.options.template)
        if (this.$tip.length != 1) {
          throw new Error(this.type + ' `template` option must consist of exactly 1 top-level element!')
        }
      }
      return this.$tip
    }
  
    Tooltip.prototype.arrow = function () {
      return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
    }
  
    Tooltip.prototype.enable = function () {
      this.enabled = true
    }
  
    Tooltip.prototype.disable = function () {
      this.enabled = false
    }
  
    Tooltip.prototype.toggleEnabled = function () {
      this.enabled = !this.enabled
    }
  
    Tooltip.prototype.toggle = function (e) {
      var self = this
      if (e) {
        self = $(e.currentTarget).data('bs.' + this.type)
        if (!self) {
          self = new this.constructor(e.currentTarget, this.getDelegateOptions())
          $(e.currentTarget).data('bs.' + this.type, self)
        }
      }
  
      if (e) {
        self.inState.click = !self.inState.click
        if (self.isInStateTrue()) self.enter(self)
        else self.leave(self)
      } else {
        self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
      }
    }
  
    Tooltip.prototype.destroy = function () {
      var that = this
      clearTimeout(this.timeout)
      this.hide(function () {
        that.$element.off('.' + that.type).removeData('bs.' + that.type)
        if (that.$tip) {
          that.$tip.detach()
        }
        that.$tip = null
        that.$arrow = null
        that.$viewport = null
      })
    }
  
  
    // TOOLTIP PLUGIN DEFINITION
    // =========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.tooltip')
        var options = typeof option == 'object' && option
  
        if (!data && /destroy|hide/.test(option)) return
        if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.tooltip
  
    $.fn.tooltip             = Plugin
    $.fn.tooltip.Constructor = Tooltip
  
  
    // TOOLTIP NO CONFLICT
    // ===================
  
    $.fn.tooltip.noConflict = function () {
      $.fn.tooltip = old
      return this
    }
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: popover.js v3.3.5
   * http://getbootstrap.com/javascript/#popovers
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // POPOVER PUBLIC CLASS DEFINITION
    // ===============================
  
    var Popover = function (element, options) {
      this.init('popover', element, options)
    }
  
    if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
  
    Popover.VERSION  = '3.3.5'
  
    Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
      placement: 'right',
      trigger: 'click',
      content: '',
      template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
    })
  
  
    // NOTE: POPOVER EXTENDS tooltip.js
    // ================================
  
    Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
  
    Popover.prototype.constructor = Popover
  
    Popover.prototype.getDefaults = function () {
      return Popover.DEFAULTS
    }
  
    Popover.prototype.setContent = function () {
      var $tip    = this.tip()
      var title   = this.getTitle()
      var content = this.getContent()
  
      $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
      $tip.find('.popover-content').children().detach().end()[ // we use append for html objects to maintain js events
        this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
      ](content)
  
      $tip.removeClass('fade top bottom left right in')
  
      // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
      // this manually by checking the contents.
      if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
    }
  
    Popover.prototype.hasContent = function () {
      return this.getTitle() || this.getContent()
    }
  
    Popover.prototype.getContent = function () {
      var $e = this.$element
      var o  = this.options
  
      return $e.attr('data-content')
        || (typeof o.content == 'function' ?
              o.content.call($e[0]) :
              o.content)
    }
  
    Popover.prototype.arrow = function () {
      return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
    }
  
  
    // POPOVER PLUGIN DEFINITION
    // =========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.popover')
        var options = typeof option == 'object' && option
  
        if (!data && /destroy|hide/.test(option)) return
        if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.popover
  
    $.fn.popover             = Plugin
    $.fn.popover.Constructor = Popover
  
  
    // POPOVER NO CONFLICT
    // ===================
  
    $.fn.popover.noConflict = function () {
      $.fn.popover = old
      return this
    }
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: scrollspy.js v3.3.5
   * http://getbootstrap.com/javascript/#scrollspy
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // SCROLLSPY CLASS DEFINITION
    // ==========================
  
    function ScrollSpy(element, options) {
      this.$body          = $(document.body)
      this.$scrollElement = $(element).is(document.body) ? $(window) : $(element)
      this.options        = $.extend({}, ScrollSpy.DEFAULTS, options)
      this.selector       = (this.options.target || '') + ' .nav li > a'
      this.offsets        = []
      this.targets        = []
      this.activeTarget   = null
      this.scrollHeight   = 0
  
      this.$scrollElement.on('scroll.bs.scrollspy', $.proxy(this.process, this))
      this.refresh()
      this.process()
    }
  
    ScrollSpy.VERSION  = '3.3.5'
  
    ScrollSpy.DEFAULTS = {
      offset: 10
    }
  
    ScrollSpy.prototype.getScrollHeight = function () {
      return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
    }
  
    ScrollSpy.prototype.refresh = function () {
      var that          = this
      var offsetMethod  = 'offset'
      var offsetBase    = 0
  
      this.offsets      = []
      this.targets      = []
      this.scrollHeight = this.getScrollHeight()
  
      if (!$.isWindow(this.$scrollElement[0])) {
        offsetMethod = 'position'
        offsetBase   = this.$scrollElement.scrollTop()
      }
  
      this.$body
        .find(this.selector)
        .map(function () {
          var $el   = $(this)
          var href  = $el.data('target') || $el.attr('href')
          var $href = /^#./.test(href) && $(href)
  
          return ($href
            && $href.length
            && $href.is(':visible')
            && [[$href[offsetMethod]().top + offsetBase, href]]) || null
        })
        .sort(function (a, b) { return a[0] - b[0] })
        .each(function () {
          that.offsets.push(this[0])
          that.targets.push(this[1])
        })
    }
  
    ScrollSpy.prototype.process = function () {
      var scrollTop    = this.$scrollElement.scrollTop() + this.options.offset
      var scrollHeight = this.getScrollHeight()
      var maxScroll    = this.options.offset + scrollHeight - this.$scrollElement.height()
      var offsets      = this.offsets
      var targets      = this.targets
      var activeTarget = this.activeTarget
      var i
  
      if (this.scrollHeight != scrollHeight) {
        this.refresh()
      }
  
      if (scrollTop >= maxScroll) {
        return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
      }
  
      if (activeTarget && scrollTop < offsets[0]) {
        this.activeTarget = null
        return this.clear()
      }
  
      for (i = offsets.length; i--;) {
        activeTarget != targets[i]
          && scrollTop >= offsets[i]
          && (offsets[i + 1] === undefined || scrollTop < offsets[i + 1])
          && this.activate(targets[i])
      }
    }
  
    ScrollSpy.prototype.activate = function (target) {
      this.activeTarget = target
  
      this.clear()
  
      var selector = this.selector +
        '[data-target="' + target + '"],' +
        this.selector + '[href="' + target + '"]'
  
      var active = $(selector)
        .parents('li')
        .addClass('active')
  
      if (active.parent('.dropdown-menu').length) {
        active = active
          .closest('li.dropdown')
          .addClass('active')
      }
  
      active.trigger('activate.bs.scrollspy')
    }
  
    ScrollSpy.prototype.clear = function () {
      $(this.selector)
        .parentsUntil(this.options.target, '.active')
        .removeClass('active')
    }
  
  
    // SCROLLSPY PLUGIN DEFINITION
    // ===========================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.scrollspy')
        var options = typeof option == 'object' && option
  
        if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.scrollspy
  
    $.fn.scrollspy             = Plugin
    $.fn.scrollspy.Constructor = ScrollSpy
  
  
    // SCROLLSPY NO CONFLICT
    // =====================
  
    $.fn.scrollspy.noConflict = function () {
      $.fn.scrollspy = old
      return this
    }
  
  
    // SCROLLSPY DATA-API
    // ==================
  
    $(window).on('load.bs.scrollspy.data-api', function () {
      $('[data-spy="scroll"]').each(function () {
        var $spy = $(this)
        Plugin.call($spy, $spy.data())
      })
    })
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: tab.js v3.3.5
   * http://getbootstrap.com/javascript/#tabs
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // TAB CLASS DEFINITION
    // ====================
  
    var Tab = function (element) {
      // jscs:disable requireDollarBeforejQueryAssignment
      this.element = $(element)
      // jscs:enable requireDollarBeforejQueryAssignment
    }
  
    Tab.VERSION = '3.3.5'
  
    Tab.TRANSITION_DURATION = 150
  
    Tab.prototype.show = function () {
      var $this    = this.element
      var $ul      = $this.closest('ul:not(.dropdown-menu)')
      var selector = $this.data('target')
  
      if (!selector) {
        selector = $this.attr('href')
        selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
      }
  
      if ($this.parent('li').hasClass('active')) return
  
      var $previous = $ul.find('.active:last a')
      var hideEvent = $.Event('hide.bs.tab', {
        relatedTarget: $this[0]
      })
      var showEvent = $.Event('show.bs.tab', {
        relatedTarget: $previous[0]
      })
  
      $previous.trigger(hideEvent)
      $this.trigger(showEvent)
  
      if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return
  
      var $target = $(selector)
  
      this.activate($this.closest('li'), $ul)
      this.activate($target, $target.parent(), function () {
        $previous.trigger({
          type: 'hidden.bs.tab',
          relatedTarget: $this[0]
        })
        $this.trigger({
          type: 'shown.bs.tab',
          relatedTarget: $previous[0]
        })
      })
    }
  
    Tab.prototype.activate = function (element, container, callback) {
      var $active    = container.find('> .active')
      var transition = callback
        && $.support.transition
        && ($active.length && $active.hasClass('fade') || !!container.find('> .fade').length)
  
      function next() {
        $active
          .removeClass('active')
          .find('> .dropdown-menu > .active')
            .removeClass('active')
          .end()
          .find('[data-toggle="tab"]')
            .attr('aria-expanded', false)
  
        element
          .addClass('active')
          .find('[data-toggle="tab"]')
            .attr('aria-expanded', true)
  
        if (transition) {
          element[0].offsetWidth // reflow for transition
          element.addClass('in')
        } else {
          element.removeClass('fade')
        }
  
        if (element.parent('.dropdown-menu').length) {
          element
            .closest('li.dropdown')
              .addClass('active')
            .end()
            .find('[data-toggle="tab"]')
              .attr('aria-expanded', true)
        }
  
        callback && callback()
      }
  
      $active.length && transition ?
        $active
          .one('bsTransitionEnd', next)
          .emulateTransitionEnd(Tab.TRANSITION_DURATION) :
        next()
  
      $active.removeClass('in')
    }
  
  
    // TAB PLUGIN DEFINITION
    // =====================
  
    function Plugin(option) {
      return this.each(function () {
        var $this = $(this)
        var data  = $this.data('bs.tab')
  
        if (!data) $this.data('bs.tab', (data = new Tab(this)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.tab
  
    $.fn.tab             = Plugin
    $.fn.tab.Constructor = Tab
  
  
    // TAB NO CONFLICT
    // ===============
  
    $.fn.tab.noConflict = function () {
      $.fn.tab = old
      return this
    }
  
  
    // TAB DATA-API
    // ============
  
    var clickHandler = function (e) {
      e.preventDefault()
      Plugin.call($(this), 'show')
    }
  
    $(document)
      .on('click.bs.tab.data-api', '[data-toggle="tab"]', clickHandler)
      .on('click.bs.tab.data-api', '[data-toggle="pill"]', clickHandler)
  
  }(jQuery);
  
  /* ========================================================================
   * Bootstrap: affix.js v3.3.5
   * http://getbootstrap.com/javascript/#affix
   * ========================================================================
   * Copyright 2011-2015 Twitter, Inc.
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * ======================================================================== */
  
  
  +function ($) {
    'use strict';
  
    // AFFIX CLASS DEFINITION
    // ======================
  
    var Affix = function (element, options) {
      this.options = $.extend({}, Affix.DEFAULTS, options)
  
      this.$target = $(this.options.target)
        .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
        .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))
  
      this.$element     = $(element)
      this.affixed      = null
      this.unpin        = null
      this.pinnedOffset = null
  
      this.checkPosition()
    }
  
    Affix.VERSION  = '3.3.5'
  
    Affix.RESET    = 'affix affix-top affix-bottom'
  
    Affix.DEFAULTS = {
      offset: 0,
      target: window
    }
  
    Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {
      var scrollTop    = this.$target.scrollTop()
      var position     = this.$element.offset()
      var targetHeight = this.$target.height()
  
      if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false
  
      if (this.affixed == 'bottom') {
        if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'
        return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'
      }
  
      var initializing   = this.affixed == null
      var colliderTop    = initializing ? scrollTop : position.top
      var colliderHeight = initializing ? targetHeight : height
  
      if (offsetTop != null && scrollTop <= offsetTop) return 'top'
      if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'
  
      return false
    }
  
    Affix.prototype.getPinnedOffset = function () {
      if (this.pinnedOffset) return this.pinnedOffset
      this.$element.removeClass(Affix.RESET).addClass('affix')
      var scrollTop = this.$target.scrollTop()
      var position  = this.$element.offset()
      return (this.pinnedOffset = position.top - scrollTop)
    }
  
    Affix.prototype.checkPositionWithEventLoop = function () {
      setTimeout($.proxy(this.checkPosition, this), 1)
    }
  
    Affix.prototype.checkPosition = function () {
      if (!this.$element.is(':visible')) return
  
      var height       = this.$element.height()
      var offset       = this.options.offset
      var offsetTop    = offset.top
      var offsetBottom = offset.bottom
      var scrollHeight = Math.max($(document).height(), $(document.body).height())
  
      if (typeof offset != 'object')         offsetBottom = offsetTop = offset
      if (typeof offsetTop == 'function')    offsetTop    = offset.top(this.$element)
      if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
  
      var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)
  
      if (this.affixed != affix) {
        if (this.unpin != null) this.$element.css('top', '')
  
        var affixType = 'affix' + (affix ? '-' + affix : '')
        var e         = $.Event(affixType + '.bs.affix')
  
        this.$element.trigger(e)
  
        if (e.isDefaultPrevented()) return
  
        this.affixed = affix
        this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
  
        this.$element
          .removeClass(Affix.RESET)
          .addClass(affixType)
          .trigger(affixType.replace('affix', 'affixed') + '.bs.affix')
      }
  
      if (affix == 'bottom') {
        this.$element.offset({
          top: scrollHeight - height - offsetBottom
        })
      }
    }
  
  
    // AFFIX PLUGIN DEFINITION
    // =======================
  
    function Plugin(option) {
      return this.each(function () {
        var $this   = $(this)
        var data    = $this.data('bs.affix')
        var options = typeof option == 'object' && option
  
        if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
        if (typeof option == 'string') data[option]()
      })
    }
  
    var old = $.fn.affix
  
    $.fn.affix             = Plugin
    $.fn.affix.Constructor = Affix
  
  
    // AFFIX NO CONFLICT
    // =================
  
    $.fn.affix.noConflict = function () {
      $.fn.affix = old
      return this
    }
  
  
    // AFFIX DATA-API
    // ==============
  
    $(window).on('load', function () {
      $('[data-spy="affix"]').each(function () {
        var $spy = $(this)
        var data = $spy.data()
  
        data.offset = data.offset || {}
  
        if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom
        if (data.offsetTop    != null) data.offset.top    = data.offsetTop
  
        Plugin.call($spy, data)
      })
    })
  
  }(jQuery);
  
  },{}],3:[function(require,module,exports){
  /*!
   * jQuery JavaScript Library v2.1.4
   * http://jquery.com/
   *
   * Includes Sizzle.js
   * http://sizzlejs.com/
   *
   * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
   * Released under the MIT license
   * http://jquery.org/license
   *
   * Date: 2015-04-28T16:01Z
   */
  
  (function( global, factory ) {
  
  	if ( typeof module === "object" && typeof module.exports === "object" ) {
  		// For CommonJS and CommonJS-like environments where a proper `window`
  		// is present, execute the factory and get jQuery.
  		// For environments that do not have a `window` with a `document`
  		// (such as Node.js), expose a factory as module.exports.
  		// This accentuates the need for the creation of a real `window`.
  		// e.g. var jQuery = require("jquery")(window);
  		// See ticket #14549 for more info.
  		module.exports = global.document ?
  			factory( global, true ) :
  			function( w ) {
  				if ( !w.document ) {
  					throw new Error( "jQuery requires a window with a document" );
  				}
  				return factory( w );
  			};
  	} else {
  		factory( global );
  	}
  
  // Pass this if window is not defined yet
  }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
  
  // Support: Firefox 18+
  // Can't be in strict mode, several libs including ASP.NET trace
  // the stack via arguments.caller.callee and Firefox dies if
  // you try to trace through "use strict" call chains. (#13335)
  //
  
  var arr = [];
  
  var slice = arr.slice;
  
  var concat = arr.concat;
  
  var push = arr.push;
  
  var indexOf = arr.indexOf;
  
  var class2type = {};
  
  var toString = class2type.toString;
  
  var hasOwn = class2type.hasOwnProperty;
  
  var support = {};
  
  
  
  var
  	// Use the correct document accordingly with window argument (sandbox)
  	document = window.document,
  
  	version = "2.1.4",
  
  	// Define a local copy of jQuery
  	jQuery = function( selector, context ) {
  		// The jQuery object is actually just the init constructor 'enhanced'
  		// Need init if jQuery is called (just allow error to be thrown if not included)
  		return new jQuery.fn.init( selector, context );
  	},
  
  	// Support: Android<4.1
  	// Make sure we trim BOM and NBSP
  	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
  
  	// Matches dashed string for camelizing
  	rmsPrefix = /^-ms-/,
  	rdashAlpha = /-([\da-z])/gi,
  
  	// Used by jQuery.camelCase as callback to replace()
  	fcamelCase = function( all, letter ) {
  		return letter.toUpperCase();
  	};
  
  jQuery.fn = jQuery.prototype = {
  	// The current version of jQuery being used
  	jquery: version,
  
  	constructor: jQuery,
  
  	// Start with an empty selector
  	selector: "",
  
  	// The default length of a jQuery object is 0
  	length: 0,
  
  	toArray: function() {
  		return slice.call( this );
  	},
  
  	// Get the Nth element in the matched element set OR
  	// Get the whole matched element set as a clean array
  	get: function( num ) {
  		return num != null ?
  
  			// Return just the one element from the set
  			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
  
  			// Return all the elements in a clean array
  			slice.call( this );
  	},
  
  	// Take an array of elements and push it onto the stack
  	// (returning the new matched element set)
  	pushStack: function( elems ) {
  
  		// Build a new jQuery matched element set
  		var ret = jQuery.merge( this.constructor(), elems );
  
  		// Add the old object onto the stack (as a reference)
  		ret.prevObject = this;
  		ret.context = this.context;
  
  		// Return the newly-formed element set
  		return ret;
  	},
  
  	// Execute a callback for every element in the matched set.
  	// (You can seed the arguments with an array of args, but this is
  	// only used internally.)
  	each: function( callback, args ) {
  		return jQuery.each( this, callback, args );
  	},
  
  	map: function( callback ) {
  		return this.pushStack( jQuery.map(this, function( elem, i ) {
  			return callback.call( elem, i, elem );
  		}));
  	},
  
  	slice: function() {
  		return this.pushStack( slice.apply( this, arguments ) );
  	},
  
  	first: function() {
  		return this.eq( 0 );
  	},
  
  	last: function() {
  		return this.eq( -1 );
  	},
  
  	eq: function( i ) {
  		var len = this.length,
  			j = +i + ( i < 0 ? len : 0 );
  		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
  	},
  
  	end: function() {
  		return this.prevObject || this.constructor(null);
  	},
  
  	// For internal use only.
  	// Behaves like an Array's method, not like a jQuery method.
  	push: push,
  	sort: arr.sort,
  	splice: arr.splice
  };
  
  jQuery.extend = jQuery.fn.extend = function() {
  	var options, name, src, copy, copyIsArray, clone,
  		target = arguments[0] || {},
  		i = 1,
  		length = arguments.length,
  		deep = false;
  
  	// Handle a deep copy situation
  	if ( typeof target === "boolean" ) {
  		deep = target;
  
  		// Skip the boolean and the target
  		target = arguments[ i ] || {};
  		i++;
  	}
  
  	// Handle case when target is a string or something (possible in deep copy)
  	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
  		target = {};
  	}
  
  	// Extend jQuery itself if only one argument is passed
  	if ( i === length ) {
  		target = this;
  		i--;
  	}
  
  	for ( ; i < length; i++ ) {
  		// Only deal with non-null/undefined values
  		if ( (options = arguments[ i ]) != null ) {
  			// Extend the base object
  			for ( name in options ) {
  				src = target[ name ];
  				copy = options[ name ];
  
  				// Prevent never-ending loop
  				if ( target === copy ) {
  					continue;
  				}
  
  				// Recurse if we're merging plain objects or arrays
  				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
  					if ( copyIsArray ) {
  						copyIsArray = false;
  						clone = src && jQuery.isArray(src) ? src : [];
  
  					} else {
  						clone = src && jQuery.isPlainObject(src) ? src : {};
  					}
  
  					// Never move original objects, clone them
  					target[ name ] = jQuery.extend( deep, clone, copy );
  
  				// Don't bring in undefined values
  				} else if ( copy !== undefined ) {
  					target[ name ] = copy;
  				}
  			}
  		}
  	}
  
  	// Return the modified object
  	return target;
  };
  
  jQuery.extend({
  	// Unique for each copy of jQuery on the page
  	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
  
  	// Assume jQuery is ready without the ready module
  	isReady: true,
  
  	error: function( msg ) {
  		throw new Error( msg );
  	},
  
  	noop: function() {},
  
  	isFunction: function( obj ) {
  		return jQuery.type(obj) === "function";
  	},
  
  	isArray: Array.isArray,
  
  	isWindow: function( obj ) {
  		return obj != null && obj === obj.window;
  	},
  
  	isNumeric: function( obj ) {
  		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
  		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  		// subtraction forces infinities to NaN
  		// adding 1 corrects loss of precision from parseFloat (#15100)
  		return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
  	},
  
  	isPlainObject: function( obj ) {
  		// Not plain objects:
  		// - Any object or value whose internal [[Class]] property is not "[object Object]"
  		// - DOM nodes
  		// - window
  		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
  			return false;
  		}
  
  		if ( obj.constructor &&
  				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
  			return false;
  		}
  
  		// If the function hasn't returned already, we're confident that
  		// |obj| is a plain object, created by {} or constructed with new Object
  		return true;
  	},
  
  	isEmptyObject: function( obj ) {
  		var name;
  		for ( name in obj ) {
  			return false;
  		}
  		return true;
  	},
  
  	type: function( obj ) {
  		if ( obj == null ) {
  			return obj + "";
  		}
  		// Support: Android<4.0, iOS<6 (functionish RegExp)
  		return typeof obj === "object" || typeof obj === "function" ?
  			class2type[ toString.call(obj) ] || "object" :
  			typeof obj;
  	},
  
  	// Evaluates a script in a global context
  	globalEval: function( code ) {
  		var script,
  			indirect = eval;
  
  		code = jQuery.trim( code );
  
  		if ( code ) {
  			// If the code includes a valid, prologue position
  			// strict mode pragma, execute code by injecting a
  			// script tag into the document.
  			if ( code.indexOf("use strict") === 1 ) {
  				script = document.createElement("script");
  				script.text = code;
  				document.head.appendChild( script ).parentNode.removeChild( script );
  			} else {
  			// Otherwise, avoid the DOM node creation, insertion
  			// and removal by using an indirect global eval
  				indirect( code );
  			}
  		}
  	},
  
  	// Convert dashed to camelCase; used by the css and data modules
  	// Support: IE9-11+
  	// Microsoft forgot to hump their vendor prefix (#9572)
  	camelCase: function( string ) {
  		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
  	},
  
  	nodeName: function( elem, name ) {
  		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  	},
  
  	// args is for internal usage only
  	each: function( obj, callback, args ) {
  		var value,
  			i = 0,
  			length = obj.length,
  			isArray = isArraylike( obj );
  
  		if ( args ) {
  			if ( isArray ) {
  				for ( ; i < length; i++ ) {
  					value = callback.apply( obj[ i ], args );
  
  					if ( value === false ) {
  						break;
  					}
  				}
  			} else {
  				for ( i in obj ) {
  					value = callback.apply( obj[ i ], args );
  
  					if ( value === false ) {
  						break;
  					}
  				}
  			}
  
  		// A special, fast, case for the most common use of each
  		} else {
  			if ( isArray ) {
  				for ( ; i < length; i++ ) {
  					value = callback.call( obj[ i ], i, obj[ i ] );
  
  					if ( value === false ) {
  						break;
  					}
  				}
  			} else {
  				for ( i in obj ) {
  					value = callback.call( obj[ i ], i, obj[ i ] );
  
  					if ( value === false ) {
  						break;
  					}
  				}
  			}
  		}
  
  		return obj;
  	},
  
  	// Support: Android<4.1
  	trim: function( text ) {
  		return text == null ?
  			"" :
  			( text + "" ).replace( rtrim, "" );
  	},
  
  	// results is for internal usage only
  	makeArray: function( arr, results ) {
  		var ret = results || [];
  
  		if ( arr != null ) {
  			if ( isArraylike( Object(arr) ) ) {
  				jQuery.merge( ret,
  					typeof arr === "string" ?
  					[ arr ] : arr
  				);
  			} else {
  				push.call( ret, arr );
  			}
  		}
  
  		return ret;
  	},
  
  	inArray: function( elem, arr, i ) {
  		return arr == null ? -1 : indexOf.call( arr, elem, i );
  	},
  
  	merge: function( first, second ) {
  		var len = +second.length,
  			j = 0,
  			i = first.length;
  
  		for ( ; j < len; j++ ) {
  			first[ i++ ] = second[ j ];
  		}
  
  		first.length = i;
  
  		return first;
  	},
  
  	grep: function( elems, callback, invert ) {
  		var callbackInverse,
  			matches = [],
  			i = 0,
  			length = elems.length,
  			callbackExpect = !invert;
  
  		// Go through the array, only saving the items
  		// that pass the validator function
  		for ( ; i < length; i++ ) {
  			callbackInverse = !callback( elems[ i ], i );
  			if ( callbackInverse !== callbackExpect ) {
  				matches.push( elems[ i ] );
  			}
  		}
  
  		return matches;
  	},
  
  	// arg is for internal usage only
  	map: function( elems, callback, arg ) {
  		var value,
  			i = 0,
  			length = elems.length,
  			isArray = isArraylike( elems ),
  			ret = [];
  
  		// Go through the array, translating each of the items to their new values
  		if ( isArray ) {
  			for ( ; i < length; i++ ) {
  				value = callback( elems[ i ], i, arg );
  
  				if ( value != null ) {
  					ret.push( value );
  				}
  			}
  
  		// Go through every key on the object,
  		} else {
  			for ( i in elems ) {
  				value = callback( elems[ i ], i, arg );
  
  				if ( value != null ) {
  					ret.push( value );
  				}
  			}
  		}
  
  		// Flatten any nested arrays
  		return concat.apply( [], ret );
  	},
  
  	// A global GUID counter for objects
  	guid: 1,
  
  	// Bind a function to a context, optionally partially applying any
  	// arguments.
  	proxy: function( fn, context ) {
  		var tmp, args, proxy;
  
  		if ( typeof context === "string" ) {
  			tmp = fn[ context ];
  			context = fn;
  			fn = tmp;
  		}
  
  		// Quick check to determine if target is callable, in the spec
  		// this throws a TypeError, but we will just return undefined.
  		if ( !jQuery.isFunction( fn ) ) {
  			return undefined;
  		}
  
  		// Simulated bind
  		args = slice.call( arguments, 2 );
  		proxy = function() {
  			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
  		};
  
  		// Set the guid of unique handler to the same of original handler, so it can be removed
  		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
  
  		return proxy;
  	},
  
  	now: Date.now,
  
  	// jQuery.support is not used in Core but other projects attach their
  	// properties to it so it needs to exist.
  	support: support
  });
  
  // Populate the class2type map
  jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
  	class2type[ "[object " + name + "]" ] = name.toLowerCase();
  });
  
  function isArraylike( obj ) {
  
  	// Support: iOS 8.2 (not reproducible in simulator)
  	// `in` check used to prevent JIT error (gh-2145)
  	// hasOwn isn't used here due to false negatives
  	// regarding Nodelist length in IE
  	var length = "length" in obj && obj.length,
  		type = jQuery.type( obj );
  
  	if ( type === "function" || jQuery.isWindow( obj ) ) {
  		return false;
  	}
  
  	if ( obj.nodeType === 1 && length ) {
  		return true;
  	}
  
  	return type === "array" || length === 0 ||
  		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
  }
  var Sizzle =
  /*!
   * Sizzle CSS Selector Engine v2.2.0-pre
   * http://sizzlejs.com/
   *
   * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
   * Released under the MIT license
   * http://jquery.org/license
   *
   * Date: 2014-12-16
   */
  (function( window ) {
  
  var i,
  	support,
  	Expr,
  	getText,
  	isXML,
  	tokenize,
  	compile,
  	select,
  	outermostContext,
  	sortInput,
  	hasDuplicate,
  
  	// Local document vars
  	setDocument,
  	document,
  	docElem,
  	documentIsHTML,
  	rbuggyQSA,
  	rbuggyMatches,
  	matches,
  	contains,
  
  	// Instance-specific data
  	expando = "sizzle" + 1 * new Date(),
  	preferredDoc = window.document,
  	dirruns = 0,
  	done = 0,
  	classCache = createCache(),
  	tokenCache = createCache(),
  	compilerCache = createCache(),
  	sortOrder = function( a, b ) {
  		if ( a === b ) {
  			hasDuplicate = true;
  		}
  		return 0;
  	},
  
  	// General-purpose constants
  	MAX_NEGATIVE = 1 << 31,
  
  	// Instance methods
  	hasOwn = ({}).hasOwnProperty,
  	arr = [],
  	pop = arr.pop,
  	push_native = arr.push,
  	push = arr.push,
  	slice = arr.slice,
  	// Use a stripped-down indexOf as it's faster than native
  	// http://jsperf.com/thor-indexof-vs-for/5
  	indexOf = function( list, elem ) {
  		var i = 0,
  			len = list.length;
  		for ( ; i < len; i++ ) {
  			if ( list[i] === elem ) {
  				return i;
  			}
  		}
  		return -1;
  	},
  
  	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
  
  	// Regular expressions
  
  	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
  	whitespace = "[\\x20\\t\\r\\n\\f]",
  	// http://www.w3.org/TR/css3-syntax/#characters
  	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
  
  	// Loosely modeled on CSS identifier characters
  	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
  	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
  	identifier = characterEncoding.replace( "w", "w#" ),
  
  	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
  	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
  		// Operator (capture 2)
  		"*([*^$|!~]?=)" + whitespace +
  		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
  		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
  		"*\\]",
  
  	pseudos = ":(" + characterEncoding + ")(?:\\((" +
  		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
  		// 1. quoted (capture 3; capture 4 or capture 5)
  		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
  		// 2. simple (capture 6)
  		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
  		// 3. anything else (capture 2)
  		".*" +
  		")\\)|)",
  
  	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
  	rwhitespace = new RegExp( whitespace + "+", "g" ),
  	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
  
  	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
  	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
  
  	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
  
  	rpseudo = new RegExp( pseudos ),
  	ridentifier = new RegExp( "^" + identifier + "$" ),
  
  	matchExpr = {
  		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
  		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
  		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
  		"ATTR": new RegExp( "^" + attributes ),
  		"PSEUDO": new RegExp( "^" + pseudos ),
  		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
  			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
  			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
  		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
  		// For use in libraries implementing .is()
  		// We use this for POS matching in `select`
  		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
  			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
  	},
  
  	rinputs = /^(?:input|select|textarea|button)$/i,
  	rheader = /^h\d$/i,
  
  	rnative = /^[^{]+\{\s*\[native \w/,
  
  	// Easily-parseable/retrievable ID or TAG or CLASS selectors
  	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
  
  	rsibling = /[+~]/,
  	rescape = /'|\\/g,
  
  	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
  	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
  	funescape = function( _, escaped, escapedWhitespace ) {
  		var high = "0x" + escaped - 0x10000;
  		// NaN means non-codepoint
  		// Support: Firefox<24
  		// Workaround erroneous numeric interpretation of +"0x"
  		return high !== high || escapedWhitespace ?
  			escaped :
  			high < 0 ?
  				// BMP codepoint
  				String.fromCharCode( high + 0x10000 ) :
  				// Supplemental Plane codepoint (surrogate pair)
  				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
  	},
  
  	// Used for iframes
  	// See setDocument()
  	// Removing the function wrapper causes a "Permission Denied"
  	// error in IE
  	unloadHandler = function() {
  		setDocument();
  	};
  
  // Optimize for push.apply( _, NodeList )
  try {
  	push.apply(
  		(arr = slice.call( preferredDoc.childNodes )),
  		preferredDoc.childNodes
  	);
  	// Support: Android<4.0
  	// Detect silently failing push.apply
  	arr[ preferredDoc.childNodes.length ].nodeType;
  } catch ( e ) {
  	push = { apply: arr.length ?
  
  		// Leverage slice if possible
  		function( target, els ) {
  			push_native.apply( target, slice.call(els) );
  		} :
  
  		// Support: IE<9
  		// Otherwise append directly
  		function( target, els ) {
  			var j = target.length,
  				i = 0;
  			// Can't trust NodeList.length
  			while ( (target[j++] = els[i++]) ) {}
  			target.length = j - 1;
  		}
  	};
  }
  
  function Sizzle( selector, context, results, seed ) {
  	var match, elem, m, nodeType,
  		// QSA vars
  		i, groups, old, nid, newContext, newSelector;
  
  	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
  		setDocument( context );
  	}
  
  	context = context || document;
  	results = results || [];
  	nodeType = context.nodeType;
  
  	if ( typeof selector !== "string" || !selector ||
  		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
  
  		return results;
  	}
  
  	if ( !seed && documentIsHTML ) {
  
  		// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
  		if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
  			// Speed-up: Sizzle("#ID")
  			if ( (m = match[1]) ) {
  				if ( nodeType === 9 ) {
  					elem = context.getElementById( m );
  					// Check parentNode to catch when Blackberry 4.6 returns
  					// nodes that are no longer in the document (jQuery #6963)
  					if ( elem && elem.parentNode ) {
  						// Handle the case where IE, Opera, and Webkit return items
  						// by name instead of ID
  						if ( elem.id === m ) {
  							results.push( elem );
  							return results;
  						}
  					} else {
  						return results;
  					}
  				} else {
  					// Context is not a document
  					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
  						contains( context, elem ) && elem.id === m ) {
  						results.push( elem );
  						return results;
  					}
  				}
  
  			// Speed-up: Sizzle("TAG")
  			} else if ( match[2] ) {
  				push.apply( results, context.getElementsByTagName( selector ) );
  				return results;
  
  			// Speed-up: Sizzle(".CLASS")
  			} else if ( (m = match[3]) && support.getElementsByClassName ) {
  				push.apply( results, context.getElementsByClassName( m ) );
  				return results;
  			}
  		}
  
  		// QSA path
  		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
  			nid = old = expando;
  			newContext = context;
  			newSelector = nodeType !== 1 && selector;
  
  			// qSA works strangely on Element-rooted queries
  			// We can work around this by specifying an extra ID on the root
  			// and working up from there (Thanks to Andrew Dupont for the technique)
  			// IE 8 doesn't work on object elements
  			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
  				groups = tokenize( selector );
  
  				if ( (old = context.getAttribute("id")) ) {
  					nid = old.replace( rescape, "\\$&" );
  				} else {
  					context.setAttribute( "id", nid );
  				}
  				nid = "[id='" + nid + "'] ";
  
  				i = groups.length;
  				while ( i-- ) {
  					groups[i] = nid + toSelector( groups[i] );
  				}
  				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
  				newSelector = groups.join(",");
  			}
  
  			if ( newSelector ) {
  				try {
  					push.apply( results,
  						newContext.querySelectorAll( newSelector )
  					);
  					return results;
  				} catch(qsaError) {
  				} finally {
  					if ( !old ) {
  						context.removeAttribute("id");
  					}
  				}
  			}
  		}
  	}
  
  	// All others
  	return select( selector.replace( rtrim, "$1" ), context, results, seed );
  }
  
  /**
   * Create key-value caches of limited size
   * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
   *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
   *	deleting the oldest entry
   */
  function createCache() {
  	var keys = [];
  
  	function cache( key, value ) {
  		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
  		if ( keys.push( key + " " ) > Expr.cacheLength ) {
  			// Only keep the most recent entries
  			delete cache[ keys.shift() ];
  		}
  		return (cache[ key + " " ] = value);
  	}
  	return cache;
  }
  
  /**
   * Mark a function for special use by Sizzle
   * @param {Function} fn The function to mark
   */
  function markFunction( fn ) {
  	fn[ expando ] = true;
  	return fn;
  }
  
  /**
   * Support testing using an element
   * @param {Function} fn Passed the created div and expects a boolean result
   */
  function assert( fn ) {
  	var div = document.createElement("div");
  
  	try {
  		return !!fn( div );
  	} catch (e) {
  		return false;
  	} finally {
  		// Remove from its parent by default
  		if ( div.parentNode ) {
  			div.parentNode.removeChild( div );
  		}
  		// release memory in IE
  		div = null;
  	}
  }
  
  /**
   * Adds the same handler for all of the specified attrs
   * @param {String} attrs Pipe-separated list of attributes
   * @param {Function} handler The method that will be applied
   */
  function addHandle( attrs, handler ) {
  	var arr = attrs.split("|"),
  		i = attrs.length;
  
  	while ( i-- ) {
  		Expr.attrHandle[ arr[i] ] = handler;
  	}
  }
  
  /**
   * Checks document order of two siblings
   * @param {Element} a
   * @param {Element} b
   * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
   */
  function siblingCheck( a, b ) {
  	var cur = b && a,
  		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
  			( ~b.sourceIndex || MAX_NEGATIVE ) -
  			( ~a.sourceIndex || MAX_NEGATIVE );
  
  	// Use IE sourceIndex if available on both nodes
  	if ( diff ) {
  		return diff;
  	}
  
  	// Check if b follows a
  	if ( cur ) {
  		while ( (cur = cur.nextSibling) ) {
  			if ( cur === b ) {
  				return -1;
  			}
  		}
  	}
  
  	return a ? 1 : -1;
  }
  
  /**
   * Returns a function to use in pseudos for input types
   * @param {String} type
   */
  function createInputPseudo( type ) {
  	return function( elem ) {
  		var name = elem.nodeName.toLowerCase();
  		return name === "input" && elem.type === type;
  	};
  }
  
  /**
   * Returns a function to use in pseudos for buttons
   * @param {String} type
   */
  function createButtonPseudo( type ) {
  	return function( elem ) {
  		var name = elem.nodeName.toLowerCase();
  		return (name === "input" || name === "button") && elem.type === type;
  	};
  }
  
  /**
   * Returns a function to use in pseudos for positionals
   * @param {Function} fn
   */
  function createPositionalPseudo( fn ) {
  	return markFunction(function( argument ) {
  		argument = +argument;
  		return markFunction(function( seed, matches ) {
  			var j,
  				matchIndexes = fn( [], seed.length, argument ),
  				i = matchIndexes.length;
  
  			// Match elements found at the specified indexes
  			while ( i-- ) {
  				if ( seed[ (j = matchIndexes[i]) ] ) {
  					seed[j] = !(matches[j] = seed[j]);
  				}
  			}
  		});
  	});
  }
  
  /**
   * Checks a node for validity as a Sizzle context
   * @param {Element|Object=} context
   * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
   */
  function testContext( context ) {
  	return context && typeof context.getElementsByTagName !== "undefined" && context;
  }
  
  // Expose support vars for convenience
  support = Sizzle.support = {};
  
  /**
   * Detects XML nodes
   * @param {Element|Object} elem An element or a document
   * @returns {Boolean} True iff elem is a non-HTML XML node
   */
  isXML = Sizzle.isXML = function( elem ) {
  	// documentElement is verified for cases where it doesn't yet exist
  	// (such as loading iframes in IE - #4833)
  	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
  	return documentElement ? documentElement.nodeName !== "HTML" : false;
  };
  
  /**
   * Sets document-related variables once based on the current document
   * @param {Element|Object} [doc] An element or document object to use to set the document
   * @returns {Object} Returns the current document
   */
  setDocument = Sizzle.setDocument = function( node ) {
  	var hasCompare, parent,
  		doc = node ? node.ownerDocument || node : preferredDoc;
  
  	// If no document and documentElement is available, return
  	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
  		return document;
  	}
  
  	// Set our document
  	document = doc;
  	docElem = doc.documentElement;
  	parent = doc.defaultView;
  
  	// Support: IE>8
  	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
  	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
  	// IE6-8 do not support the defaultView property so parent will be undefined
  	if ( parent && parent !== parent.top ) {
  		// IE11 does not have attachEvent, so all must suffer
  		if ( parent.addEventListener ) {
  			parent.addEventListener( "unload", unloadHandler, false );
  		} else if ( parent.attachEvent ) {
  			parent.attachEvent( "onunload", unloadHandler );
  		}
  	}
  
  	/* Support tests
  	---------------------------------------------------------------------- */
  	documentIsHTML = !isXML( doc );
  
  	/* Attributes
  	---------------------------------------------------------------------- */
  
  	// Support: IE<8
  	// Verify that getAttribute really returns attributes and not properties
  	// (excepting IE8 booleans)
  	support.attributes = assert(function( div ) {
  		div.className = "i";
  		return !div.getAttribute("className");
  	});
  
  	/* getElement(s)By*
  	---------------------------------------------------------------------- */
  
  	// Check if getElementsByTagName("*") returns only elements
  	support.getElementsByTagName = assert(function( div ) {
  		div.appendChild( doc.createComment("") );
  		return !div.getElementsByTagName("*").length;
  	});
  
  	// Support: IE<9
  	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
  
  	// Support: IE<10
  	// Check if getElementById returns elements by name
  	// The broken getElementById methods don't pick up programatically-set names,
  	// so use a roundabout getElementsByName test
  	support.getById = assert(function( div ) {
  		docElem.appendChild( div ).id = expando;
  		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
  	});
  
  	// ID find and filter
  	if ( support.getById ) {
  		Expr.find["ID"] = function( id, context ) {
  			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
  				var m = context.getElementById( id );
  				// Check parentNode to catch when Blackberry 4.6 returns
  				// nodes that are no longer in the document #6963
  				return m && m.parentNode ? [ m ] : [];
  			}
  		};
  		Expr.filter["ID"] = function( id ) {
  			var attrId = id.replace( runescape, funescape );
  			return function( elem ) {
  				return elem.getAttribute("id") === attrId;
  			};
  		};
  	} else {
  		// Support: IE6/7
  		// getElementById is not reliable as a find shortcut
  		delete Expr.find["ID"];
  
  		Expr.filter["ID"] =  function( id ) {
  			var attrId = id.replace( runescape, funescape );
  			return function( elem ) {
  				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
  				return node && node.value === attrId;
  			};
  		};
  	}
  
  	// Tag
  	Expr.find["TAG"] = support.getElementsByTagName ?
  		function( tag, context ) {
  			if ( typeof context.getElementsByTagName !== "undefined" ) {
  				return context.getElementsByTagName( tag );
  
  			// DocumentFragment nodes don't have gEBTN
  			} else if ( support.qsa ) {
  				return context.querySelectorAll( tag );
  			}
  		} :
  
  		function( tag, context ) {
  			var elem,
  				tmp = [],
  				i = 0,
  				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
  				results = context.getElementsByTagName( tag );
  
  			// Filter out possible comments
  			if ( tag === "*" ) {
  				while ( (elem = results[i++]) ) {
  					if ( elem.nodeType === 1 ) {
  						tmp.push( elem );
  					}
  				}
  
  				return tmp;
  			}
  			return results;
  		};
  
  	// Class
  	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
  		if ( documentIsHTML ) {
  			return context.getElementsByClassName( className );
  		}
  	};
  
  	/* QSA/matchesSelector
  	---------------------------------------------------------------------- */
  
  	// QSA and matchesSelector support
  
  	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
  	rbuggyMatches = [];
  
  	// qSa(:focus) reports false when true (Chrome 21)
  	// We allow this because of a bug in IE8/9 that throws an error
  	// whenever `document.activeElement` is accessed on an iframe
  	// So, we allow :focus to pass through QSA all the time to avoid the IE error
  	// See http://bugs.jquery.com/ticket/13378
  	rbuggyQSA = [];
  
  	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
  		// Build QSA regex
  		// Regex strategy adopted from Diego Perini
  		assert(function( div ) {
  			// Select is set to empty string on purpose
  			// This is to test IE's treatment of not explicitly
  			// setting a boolean content attribute,
  			// since its presence should be enough
  			// http://bugs.jquery.com/ticket/12359
  			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
  				"<select id='" + expando + "-\f]' msallowcapture=''>" +
  				"<option selected=''></option></select>";
  
  			// Support: IE8, Opera 11-12.16
  			// Nothing should be selected when empty strings follow ^= or $= or *=
  			// The test attribute must be unknown in Opera but "safe" for WinRT
  			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
  			if ( div.querySelectorAll("[msallowcapture^='']").length ) {
  				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
  			}
  
  			// Support: IE8
  			// Boolean attributes and "value" are not treated correctly
  			if ( !div.querySelectorAll("[selected]").length ) {
  				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
  			}
  
  			// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
  			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
  				rbuggyQSA.push("~=");
  			}
  
  			// Webkit/Opera - :checked should return selected option elements
  			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  			// IE8 throws error here and will not see later tests
  			if ( !div.querySelectorAll(":checked").length ) {
  				rbuggyQSA.push(":checked");
  			}
  
  			// Support: Safari 8+, iOS 8+
  			// https://bugs.webkit.org/show_bug.cgi?id=136851
  			// In-page `selector#id sibing-combinator selector` fails
  			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
  				rbuggyQSA.push(".#.+[+~]");
  			}
  		});
  
  		assert(function( div ) {
  			// Support: Windows 8 Native Apps
  			// The type and name attributes are restricted during .innerHTML assignment
  			var input = doc.createElement("input");
  			input.setAttribute( "type", "hidden" );
  			div.appendChild( input ).setAttribute( "name", "D" );
  
  			// Support: IE8
  			// Enforce case-sensitivity of name attribute
  			if ( div.querySelectorAll("[name=d]").length ) {
  				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
  			}
  
  			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
  			// IE8 throws error here and will not see later tests
  			if ( !div.querySelectorAll(":enabled").length ) {
  				rbuggyQSA.push( ":enabled", ":disabled" );
  			}
  
  			// Opera 10-11 does not throw on post-comma invalid pseudos
  			div.querySelectorAll("*,:x");
  			rbuggyQSA.push(",.*:");
  		});
  	}
  
  	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
  		docElem.webkitMatchesSelector ||
  		docElem.mozMatchesSelector ||
  		docElem.oMatchesSelector ||
  		docElem.msMatchesSelector) )) ) {
  
  		assert(function( div ) {
  			// Check to see if it's possible to do matchesSelector
  			// on a disconnected node (IE 9)
  			support.disconnectedMatch = matches.call( div, "div" );
  
  			// This should fail with an exception
  			// Gecko does not error, returns false instead
  			matches.call( div, "[s!='']:x" );
  			rbuggyMatches.push( "!=", pseudos );
  		});
  	}
  
  	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
  	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
  
  	/* Contains
  	---------------------------------------------------------------------- */
  	hasCompare = rnative.test( docElem.compareDocumentPosition );
  
  	// Element contains another
  	// Purposefully does not implement inclusive descendent
  	// As in, an element does not contain itself
  	contains = hasCompare || rnative.test( docElem.contains ) ?
  		function( a, b ) {
  			var adown = a.nodeType === 9 ? a.documentElement : a,
  				bup = b && b.parentNode;
  			return a === bup || !!( bup && bup.nodeType === 1 && (
  				adown.contains ?
  					adown.contains( bup ) :
  					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
  			));
  		} :
  		function( a, b ) {
  			if ( b ) {
  				while ( (b = b.parentNode) ) {
  					if ( b === a ) {
  						return true;
  					}
  				}
  			}
  			return false;
  		};
  
  	/* Sorting
  	---------------------------------------------------------------------- */
  
  	// Document order sorting
  	sortOrder = hasCompare ?
  	function( a, b ) {
  
  		// Flag for duplicate removal
  		if ( a === b ) {
  			hasDuplicate = true;
  			return 0;
  		}
  
  		// Sort on method existence if only one input has compareDocumentPosition
  		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  		if ( compare ) {
  			return compare;
  		}
  
  		// Calculate position if both inputs belong to the same document
  		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
  			a.compareDocumentPosition( b ) :
  
  			// Otherwise we know they are disconnected
  			1;
  
  		// Disconnected nodes
  		if ( compare & 1 ||
  			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
  
  			// Choose the first element that is related to our preferred document
  			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
  				return -1;
  			}
  			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
  				return 1;
  			}
  
  			// Maintain original order
  			return sortInput ?
  				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  				0;
  		}
  
  		return compare & 4 ? -1 : 1;
  	} :
  	function( a, b ) {
  		// Exit early if the nodes are identical
  		if ( a === b ) {
  			hasDuplicate = true;
  			return 0;
  		}
  
  		var cur,
  			i = 0,
  			aup = a.parentNode,
  			bup = b.parentNode,
  			ap = [ a ],
  			bp = [ b ];
  
  		// Parentless nodes are either documents or disconnected
  		if ( !aup || !bup ) {
  			return a === doc ? -1 :
  				b === doc ? 1 :
  				aup ? -1 :
  				bup ? 1 :
  				sortInput ?
  				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  				0;
  
  		// If the nodes are siblings, we can do a quick check
  		} else if ( aup === bup ) {
  			return siblingCheck( a, b );
  		}
  
  		// Otherwise we need full lists of their ancestors for comparison
  		cur = a;
  		while ( (cur = cur.parentNode) ) {
  			ap.unshift( cur );
  		}
  		cur = b;
  		while ( (cur = cur.parentNode) ) {
  			bp.unshift( cur );
  		}
  
  		// Walk down the tree looking for a discrepancy
  		while ( ap[i] === bp[i] ) {
  			i++;
  		}
  
  		return i ?
  			// Do a sibling check if the nodes have a common ancestor
  			siblingCheck( ap[i], bp[i] ) :
  
  			// Otherwise nodes in our document sort first
  			ap[i] === preferredDoc ? -1 :
  			bp[i] === preferredDoc ? 1 :
  			0;
  	};
  
  	return doc;
  };
  
  Sizzle.matches = function( expr, elements ) {
  	return Sizzle( expr, null, null, elements );
  };
  
  Sizzle.matchesSelector = function( elem, expr ) {
  	// Set document vars if needed
  	if ( ( elem.ownerDocument || elem ) !== document ) {
  		setDocument( elem );
  	}
  
  	// Make sure that attribute selectors are quoted
  	expr = expr.replace( rattributeQuotes, "='$1']" );
  
  	if ( support.matchesSelector && documentIsHTML &&
  		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
  		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
  
  		try {
  			var ret = matches.call( elem, expr );
  
  			// IE 9's matchesSelector returns false on disconnected nodes
  			if ( ret || support.disconnectedMatch ||
  					// As well, disconnected nodes are said to be in a document
  					// fragment in IE 9
  					elem.document && elem.document.nodeType !== 11 ) {
  				return ret;
  			}
  		} catch (e) {}
  	}
  
  	return Sizzle( expr, document, null, [ elem ] ).length > 0;
  };
  
  Sizzle.contains = function( context, elem ) {
  	// Set document vars if needed
  	if ( ( context.ownerDocument || context ) !== document ) {
  		setDocument( context );
  	}
  	return contains( context, elem );
  };
  
  Sizzle.attr = function( elem, name ) {
  	// Set document vars if needed
  	if ( ( elem.ownerDocument || elem ) !== document ) {
  		setDocument( elem );
  	}
  
  	var fn = Expr.attrHandle[ name.toLowerCase() ],
  		// Don't get fooled by Object.prototype properties (jQuery #13807)
  		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
  			fn( elem, name, !documentIsHTML ) :
  			undefined;
  
  	return val !== undefined ?
  		val :
  		support.attributes || !documentIsHTML ?
  			elem.getAttribute( name ) :
  			(val = elem.getAttributeNode(name)) && val.specified ?
  				val.value :
  				null;
  };
  
  Sizzle.error = function( msg ) {
  	throw new Error( "Syntax error, unrecognized expression: " + msg );
  };
  
  /**
   * Document sorting and removing duplicates
   * @param {ArrayLike} results
   */
  Sizzle.uniqueSort = function( results ) {
  	var elem,
  		duplicates = [],
  		j = 0,
  		i = 0;
  
  	// Unless we *know* we can detect duplicates, assume their presence
  	hasDuplicate = !support.detectDuplicates;
  	sortInput = !support.sortStable && results.slice( 0 );
  	results.sort( sortOrder );
  
  	if ( hasDuplicate ) {
  		while ( (elem = results[i++]) ) {
  			if ( elem === results[ i ] ) {
  				j = duplicates.push( i );
  			}
  		}
  		while ( j-- ) {
  			results.splice( duplicates[ j ], 1 );
  		}
  	}
  
  	// Clear input after sorting to release objects
  	// See https://github.com/jquery/sizzle/pull/225
  	sortInput = null;
  
  	return results;
  };
  
  /**
   * Utility function for retrieving the text value of an array of DOM nodes
   * @param {Array|Element} elem
   */
  getText = Sizzle.getText = function( elem ) {
  	var node,
  		ret = "",
  		i = 0,
  		nodeType = elem.nodeType;
  
  	if ( !nodeType ) {
  		// If no nodeType, this is expected to be an array
  		while ( (node = elem[i++]) ) {
  			// Do not traverse comment nodes
  			ret += getText( node );
  		}
  	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
  		// Use textContent for elements
  		// innerText usage removed for consistency of new lines (jQuery #11153)
  		if ( typeof elem.textContent === "string" ) {
  			return elem.textContent;
  		} else {
  			// Traverse its children
  			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  				ret += getText( elem );
  			}
  		}
  	} else if ( nodeType === 3 || nodeType === 4 ) {
  		return elem.nodeValue;
  	}
  	// Do not include comment or processing instruction nodes
  
  	return ret;
  };
  
  Expr = Sizzle.selectors = {
  
  	// Can be adjusted by the user
  	cacheLength: 50,
  
  	createPseudo: markFunction,
  
  	match: matchExpr,
  
  	attrHandle: {},
  
  	find: {},
  
  	relative: {
  		">": { dir: "parentNode", first: true },
  		" ": { dir: "parentNode" },
  		"+": { dir: "previousSibling", first: true },
  		"~": { dir: "previousSibling" }
  	},
  
  	preFilter: {
  		"ATTR": function( match ) {
  			match[1] = match[1].replace( runescape, funescape );
  
  			// Move the given value to match[3] whether quoted or unquoted
  			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
  
  			if ( match[2] === "~=" ) {
  				match[3] = " " + match[3] + " ";
  			}
  
  			return match.slice( 0, 4 );
  		},
  
  		"CHILD": function( match ) {
  			/* matches from matchExpr["CHILD"]
  				1 type (only|nth|...)
  				2 what (child|of-type)
  				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
  				4 xn-component of xn+y argument ([+-]?\d*n|)
  				5 sign of xn-component
  				6 x of xn-component
  				7 sign of y-component
  				8 y of y-component
  			*/
  			match[1] = match[1].toLowerCase();
  
  			if ( match[1].slice( 0, 3 ) === "nth" ) {
  				// nth-* requires argument
  				if ( !match[3] ) {
  					Sizzle.error( match[0] );
  				}
  
  				// numeric x and y parameters for Expr.filter.CHILD
  				// remember that false/true cast respectively to 0/1
  				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
  				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
  
  			// other types prohibit arguments
  			} else if ( match[3] ) {
  				Sizzle.error( match[0] );
  			}
  
  			return match;
  		},
  
  		"PSEUDO": function( match ) {
  			var excess,
  				unquoted = !match[6] && match[2];
  
  			if ( matchExpr["CHILD"].test( match[0] ) ) {
  				return null;
  			}
  
  			// Accept quoted arguments as-is
  			if ( match[3] ) {
  				match[2] = match[4] || match[5] || "";
  
  			// Strip excess characters from unquoted arguments
  			} else if ( unquoted && rpseudo.test( unquoted ) &&
  				// Get excess from tokenize (recursively)
  				(excess = tokenize( unquoted, true )) &&
  				// advance to the next closing parenthesis
  				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
  
  				// excess is a negative index
  				match[0] = match[0].slice( 0, excess );
  				match[2] = unquoted.slice( 0, excess );
  			}
  
  			// Return only captures needed by the pseudo filter method (type and argument)
  			return match.slice( 0, 3 );
  		}
  	},
  
  	filter: {
  
  		"TAG": function( nodeNameSelector ) {
  			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
  			return nodeNameSelector === "*" ?
  				function() { return true; } :
  				function( elem ) {
  					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  				};
  		},
  
  		"CLASS": function( className ) {
  			var pattern = classCache[ className + " " ];
  
  			return pattern ||
  				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
  				classCache( className, function( elem ) {
  					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
  				});
  		},
  
  		"ATTR": function( name, operator, check ) {
  			return function( elem ) {
  				var result = Sizzle.attr( elem, name );
  
  				if ( result == null ) {
  					return operator === "!=";
  				}
  				if ( !operator ) {
  					return true;
  				}
  
  				result += "";
  
  				return operator === "=" ? result === check :
  					operator === "!=" ? result !== check :
  					operator === "^=" ? check && result.indexOf( check ) === 0 :
  					operator === "*=" ? check && result.indexOf( check ) > -1 :
  					operator === "$=" ? check && result.slice( -check.length ) === check :
  					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
  					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
  					false;
  			};
  		},
  
  		"CHILD": function( type, what, argument, first, last ) {
  			var simple = type.slice( 0, 3 ) !== "nth",
  				forward = type.slice( -4 ) !== "last",
  				ofType = what === "of-type";
  
  			return first === 1 && last === 0 ?
  
  				// Shortcut for :nth-*(n)
  				function( elem ) {
  					return !!elem.parentNode;
  				} :
  
  				function( elem, context, xml ) {
  					var cache, outerCache, node, diff, nodeIndex, start,
  						dir = simple !== forward ? "nextSibling" : "previousSibling",
  						parent = elem.parentNode,
  						name = ofType && elem.nodeName.toLowerCase(),
  						useCache = !xml && !ofType;
  
  					if ( parent ) {
  
  						// :(first|last|only)-(child|of-type)
  						if ( simple ) {
  							while ( dir ) {
  								node = elem;
  								while ( (node = node[ dir ]) ) {
  									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
  										return false;
  									}
  								}
  								// Reverse direction for :only-* (if we haven't yet done so)
  								start = dir = type === "only" && !start && "nextSibling";
  							}
  							return true;
  						}
  
  						start = [ forward ? parent.firstChild : parent.lastChild ];
  
  						// non-xml :nth-child(...) stores cache data on `parent`
  						if ( forward && useCache ) {
  							// Seek `elem` from a previously-cached index
  							outerCache = parent[ expando ] || (parent[ expando ] = {});
  							cache = outerCache[ type ] || [];
  							nodeIndex = cache[0] === dirruns && cache[1];
  							diff = cache[0] === dirruns && cache[2];
  							node = nodeIndex && parent.childNodes[ nodeIndex ];
  
  							while ( (node = ++nodeIndex && node && node[ dir ] ||
  
  								// Fallback to seeking `elem` from the start
  								(diff = nodeIndex = 0) || start.pop()) ) {
  
  								// When found, cache indexes on `parent` and break
  								if ( node.nodeType === 1 && ++diff && node === elem ) {
  									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
  									break;
  								}
  							}
  
  						// Use previously-cached element index if available
  						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
  							diff = cache[1];
  
  						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
  						} else {
  							// Use the same loop as above to seek `elem` from the start
  							while ( (node = ++nodeIndex && node && node[ dir ] ||
  								(diff = nodeIndex = 0) || start.pop()) ) {
  
  								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
  									// Cache the index of each encountered element
  									if ( useCache ) {
  										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
  									}
  
  									if ( node === elem ) {
  										break;
  									}
  								}
  							}
  						}
  
  						// Incorporate the offset, then check against cycle size
  						diff -= last;
  						return diff === first || ( diff % first === 0 && diff / first >= 0 );
  					}
  				};
  		},
  
  		"PSEUDO": function( pseudo, argument ) {
  			// pseudo-class names are case-insensitive
  			// http://www.w3.org/TR/selectors/#pseudo-classes
  			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
  			// Remember that setFilters inherits from pseudos
  			var args,
  				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
  					Sizzle.error( "unsupported pseudo: " + pseudo );
  
  			// The user may use createPseudo to indicate that
  			// arguments are needed to create the filter function
  			// just as Sizzle does
  			if ( fn[ expando ] ) {
  				return fn( argument );
  			}
  
  			// But maintain support for old signatures
  			if ( fn.length > 1 ) {
  				args = [ pseudo, pseudo, "", argument ];
  				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
  					markFunction(function( seed, matches ) {
  						var idx,
  							matched = fn( seed, argument ),
  							i = matched.length;
  						while ( i-- ) {
  							idx = indexOf( seed, matched[i] );
  							seed[ idx ] = !( matches[ idx ] = matched[i] );
  						}
  					}) :
  					function( elem ) {
  						return fn( elem, 0, args );
  					};
  			}
  
  			return fn;
  		}
  	},
  
  	pseudos: {
  		// Potentially complex pseudos
  		"not": markFunction(function( selector ) {
  			// Trim the selector passed to compile
  			// to avoid treating leading and trailing
  			// spaces as combinators
  			var input = [],
  				results = [],
  				matcher = compile( selector.replace( rtrim, "$1" ) );
  
  			return matcher[ expando ] ?
  				markFunction(function( seed, matches, context, xml ) {
  					var elem,
  						unmatched = matcher( seed, null, xml, [] ),
  						i = seed.length;
  
  					// Match elements unmatched by `matcher`
  					while ( i-- ) {
  						if ( (elem = unmatched[i]) ) {
  							seed[i] = !(matches[i] = elem);
  						}
  					}
  				}) :
  				function( elem, context, xml ) {
  					input[0] = elem;
  					matcher( input, null, xml, results );
  					// Don't keep the element (issue #299)
  					input[0] = null;
  					return !results.pop();
  				};
  		}),
  
  		"has": markFunction(function( selector ) {
  			return function( elem ) {
  				return Sizzle( selector, elem ).length > 0;
  			};
  		}),
  
  		"contains": markFunction(function( text ) {
  			text = text.replace( runescape, funescape );
  			return function( elem ) {
  				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
  			};
  		}),
  
  		// "Whether an element is represented by a :lang() selector
  		// is based solely on the element's language value
  		// being equal to the identifier C,
  		// or beginning with the identifier C immediately followed by "-".
  		// The matching of C against the element's language value is performed case-insensitively.
  		// The identifier C does not have to be a valid language name."
  		// http://www.w3.org/TR/selectors/#lang-pseudo
  		"lang": markFunction( function( lang ) {
  			// lang value must be a valid identifier
  			if ( !ridentifier.test(lang || "") ) {
  				Sizzle.error( "unsupported lang: " + lang );
  			}
  			lang = lang.replace( runescape, funescape ).toLowerCase();
  			return function( elem ) {
  				var elemLang;
  				do {
  					if ( (elemLang = documentIsHTML ?
  						elem.lang :
  						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
  
  						elemLang = elemLang.toLowerCase();
  						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
  					}
  				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
  				return false;
  			};
  		}),
  
  		// Miscellaneous
  		"target": function( elem ) {
  			var hash = window.location && window.location.hash;
  			return hash && hash.slice( 1 ) === elem.id;
  		},
  
  		"root": function( elem ) {
  			return elem === docElem;
  		},
  
  		"focus": function( elem ) {
  			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  		},
  
  		// Boolean properties
  		"enabled": function( elem ) {
  			return elem.disabled === false;
  		},
  
  		"disabled": function( elem ) {
  			return elem.disabled === true;
  		},
  
  		"checked": function( elem ) {
  			// In CSS3, :checked should return both checked and selected elements
  			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  			var nodeName = elem.nodeName.toLowerCase();
  			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
  		},
  
  		"selected": function( elem ) {
  			// Accessing this property makes selected-by-default
  			// options in Safari work properly
  			if ( elem.parentNode ) {
  				elem.parentNode.selectedIndex;
  			}
  
  			return elem.selected === true;
  		},
  
  		// Contents
  		"empty": function( elem ) {
  			// http://www.w3.org/TR/selectors/#empty-pseudo
  			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
  			//   but not by others (comment: 8; processing instruction: 7; etc.)
  			// nodeType < 6 works because attributes (2) do not appear as children
  			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  				if ( elem.nodeType < 6 ) {
  					return false;
  				}
  			}
  			return true;
  		},
  
  		"parent": function( elem ) {
  			return !Expr.pseudos["empty"]( elem );
  		},
  
  		// Element/input types
  		"header": function( elem ) {
  			return rheader.test( elem.nodeName );
  		},
  
  		"input": function( elem ) {
  			return rinputs.test( elem.nodeName );
  		},
  
  		"button": function( elem ) {
  			var name = elem.nodeName.toLowerCase();
  			return name === "input" && elem.type === "button" || name === "button";
  		},
  
  		"text": function( elem ) {
  			var attr;
  			return elem.nodeName.toLowerCase() === "input" &&
  				elem.type === "text" &&
  
  				// Support: IE<8
  				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
  				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
  		},
  
  		// Position-in-collection
  		"first": createPositionalPseudo(function() {
  			return [ 0 ];
  		}),
  
  		"last": createPositionalPseudo(function( matchIndexes, length ) {
  			return [ length - 1 ];
  		}),
  
  		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
  			return [ argument < 0 ? argument + length : argument ];
  		}),
  
  		"even": createPositionalPseudo(function( matchIndexes, length ) {
  			var i = 0;
  			for ( ; i < length; i += 2 ) {
  				matchIndexes.push( i );
  			}
  			return matchIndexes;
  		}),
  
  		"odd": createPositionalPseudo(function( matchIndexes, length ) {
  			var i = 1;
  			for ( ; i < length; i += 2 ) {
  				matchIndexes.push( i );
  			}
  			return matchIndexes;
  		}),
  
  		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  			var i = argument < 0 ? argument + length : argument;
  			for ( ; --i >= 0; ) {
  				matchIndexes.push( i );
  			}
  			return matchIndexes;
  		}),
  
  		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  			var i = argument < 0 ? argument + length : argument;
  			for ( ; ++i < length; ) {
  				matchIndexes.push( i );
  			}
  			return matchIndexes;
  		})
  	}
  };
  
  Expr.pseudos["nth"] = Expr.pseudos["eq"];
  
  // Add button/input type pseudos
  for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
  	Expr.pseudos[ i ] = createInputPseudo( i );
  }
  for ( i in { submit: true, reset: true } ) {
  	Expr.pseudos[ i ] = createButtonPseudo( i );
  }
  
  // Easy API for creating new setFilters
  function setFilters() {}
  setFilters.prototype = Expr.filters = Expr.pseudos;
  Expr.setFilters = new setFilters();
  
  tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
  	var matched, match, tokens, type,
  		soFar, groups, preFilters,
  		cached = tokenCache[ selector + " " ];
  
  	if ( cached ) {
  		return parseOnly ? 0 : cached.slice( 0 );
  	}
  
  	soFar = selector;
  	groups = [];
  	preFilters = Expr.preFilter;
  
  	while ( soFar ) {
  
  		// Comma and first run
  		if ( !matched || (match = rcomma.exec( soFar )) ) {
  			if ( match ) {
  				// Don't consume trailing commas as valid
  				soFar = soFar.slice( match[0].length ) || soFar;
  			}
  			groups.push( (tokens = []) );
  		}
  
  		matched = false;
  
  		// Combinators
  		if ( (match = rcombinators.exec( soFar )) ) {
  			matched = match.shift();
  			tokens.push({
  				value: matched,
  				// Cast descendant combinators to space
  				type: match[0].replace( rtrim, " " )
  			});
  			soFar = soFar.slice( matched.length );
  		}
  
  		// Filters
  		for ( type in Expr.filter ) {
  			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
  				(match = preFilters[ type ]( match ))) ) {
  				matched = match.shift();
  				tokens.push({
  					value: matched,
  					type: type,
  					matches: match
  				});
  				soFar = soFar.slice( matched.length );
  			}
  		}
  
  		if ( !matched ) {
  			break;
  		}
  	}
  
  	// Return the length of the invalid excess
  	// if we're just parsing
  	// Otherwise, throw an error or return tokens
  	return parseOnly ?
  		soFar.length :
  		soFar ?
  			Sizzle.error( selector ) :
  			// Cache the tokens
  			tokenCache( selector, groups ).slice( 0 );
  };
  
  function toSelector( tokens ) {
  	var i = 0,
  		len = tokens.length,
  		selector = "";
  	for ( ; i < len; i++ ) {
  		selector += tokens[i].value;
  	}
  	return selector;
  }
  
  function addCombinator( matcher, combinator, base ) {
  	var dir = combinator.dir,
  		checkNonElements = base && dir === "parentNode",
  		doneName = done++;
  
  	return combinator.first ?
  		// Check against closest ancestor/preceding element
  		function( elem, context, xml ) {
  			while ( (elem = elem[ dir ]) ) {
  				if ( elem.nodeType === 1 || checkNonElements ) {
  					return matcher( elem, context, xml );
  				}
  			}
  		} :
  
  		// Check against all ancestor/preceding elements
  		function( elem, context, xml ) {
  			var oldCache, outerCache,
  				newCache = [ dirruns, doneName ];
  
  			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
  			if ( xml ) {
  				while ( (elem = elem[ dir ]) ) {
  					if ( elem.nodeType === 1 || checkNonElements ) {
  						if ( matcher( elem, context, xml ) ) {
  							return true;
  						}
  					}
  				}
  			} else {
  				while ( (elem = elem[ dir ]) ) {
  					if ( elem.nodeType === 1 || checkNonElements ) {
  						outerCache = elem[ expando ] || (elem[ expando ] = {});
  						if ( (oldCache = outerCache[ dir ]) &&
  							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
  
  							// Assign to newCache so results back-propagate to previous elements
  							return (newCache[ 2 ] = oldCache[ 2 ]);
  						} else {
  							// Reuse newcache so results back-propagate to previous elements
  							outerCache[ dir ] = newCache;
  
  							// A match means we're done; a fail means we have to keep checking
  							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
  								return true;
  							}
  						}
  					}
  				}
  			}
  		};
  }
  
  function elementMatcher( matchers ) {
  	return matchers.length > 1 ?
  		function( elem, context, xml ) {
  			var i = matchers.length;
  			while ( i-- ) {
  				if ( !matchers[i]( elem, context, xml ) ) {
  					return false;
  				}
  			}
  			return true;
  		} :
  		matchers[0];
  }
  
  function multipleContexts( selector, contexts, results ) {
  	var i = 0,
  		len = contexts.length;
  	for ( ; i < len; i++ ) {
  		Sizzle( selector, contexts[i], results );
  	}
  	return results;
  }
  
  function condense( unmatched, map, filter, context, xml ) {
  	var elem,
  		newUnmatched = [],
  		i = 0,
  		len = unmatched.length,
  		mapped = map != null;
  
  	for ( ; i < len; i++ ) {
  		if ( (elem = unmatched[i]) ) {
  			if ( !filter || filter( elem, context, xml ) ) {
  				newUnmatched.push( elem );
  				if ( mapped ) {
  					map.push( i );
  				}
  			}
  		}
  	}
  
  	return newUnmatched;
  }
  
  function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
  	if ( postFilter && !postFilter[ expando ] ) {
  		postFilter = setMatcher( postFilter );
  	}
  	if ( postFinder && !postFinder[ expando ] ) {
  		postFinder = setMatcher( postFinder, postSelector );
  	}
  	return markFunction(function( seed, results, context, xml ) {
  		var temp, i, elem,
  			preMap = [],
  			postMap = [],
  			preexisting = results.length,
  
  			// Get initial elements from seed or context
  			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
  
  			// Prefilter to get matcher input, preserving a map for seed-results synchronization
  			matcherIn = preFilter && ( seed || !selector ) ?
  				condense( elems, preMap, preFilter, context, xml ) :
  				elems,
  
  			matcherOut = matcher ?
  				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
  				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
  
  					// ...intermediate processing is necessary
  					[] :
  
  					// ...otherwise use results directly
  					results :
  				matcherIn;
  
  		// Find primary matches
  		if ( matcher ) {
  			matcher( matcherIn, matcherOut, context, xml );
  		}
  
  		// Apply postFilter
  		if ( postFilter ) {
  			temp = condense( matcherOut, postMap );
  			postFilter( temp, [], context, xml );
  
  			// Un-match failing elements by moving them back to matcherIn
  			i = temp.length;
  			while ( i-- ) {
  				if ( (elem = temp[i]) ) {
  					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
  				}
  			}
  		}
  
  		if ( seed ) {
  			if ( postFinder || preFilter ) {
  				if ( postFinder ) {
  					// Get the final matcherOut by condensing this intermediate into postFinder contexts
  					temp = [];
  					i = matcherOut.length;
  					while ( i-- ) {
  						if ( (elem = matcherOut[i]) ) {
  							// Restore matcherIn since elem is not yet a final match
  							temp.push( (matcherIn[i] = elem) );
  						}
  					}
  					postFinder( null, (matcherOut = []), temp, xml );
  				}
  
  				// Move matched elements from seed to results to keep them synchronized
  				i = matcherOut.length;
  				while ( i-- ) {
  					if ( (elem = matcherOut[i]) &&
  						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
  
  						seed[temp] = !(results[temp] = elem);
  					}
  				}
  			}
  
  		// Add elements to results, through postFinder if defined
  		} else {
  			matcherOut = condense(
  				matcherOut === results ?
  					matcherOut.splice( preexisting, matcherOut.length ) :
  					matcherOut
  			);
  			if ( postFinder ) {
  				postFinder( null, results, matcherOut, xml );
  			} else {
  				push.apply( results, matcherOut );
  			}
  		}
  	});
  }
  
  function matcherFromTokens( tokens ) {
  	var checkContext, matcher, j,
  		len = tokens.length,
  		leadingRelative = Expr.relative[ tokens[0].type ],
  		implicitRelative = leadingRelative || Expr.relative[" "],
  		i = leadingRelative ? 1 : 0,
  
  		// The foundational matcher ensures that elements are reachable from top-level context(s)
  		matchContext = addCombinator( function( elem ) {
  			return elem === checkContext;
  		}, implicitRelative, true ),
  		matchAnyContext = addCombinator( function( elem ) {
  			return indexOf( checkContext, elem ) > -1;
  		}, implicitRelative, true ),
  		matchers = [ function( elem, context, xml ) {
  			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
  				(checkContext = context).nodeType ?
  					matchContext( elem, context, xml ) :
  					matchAnyContext( elem, context, xml ) );
  			// Avoid hanging onto element (issue #299)
  			checkContext = null;
  			return ret;
  		} ];
  
  	for ( ; i < len; i++ ) {
  		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
  			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
  		} else {
  			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
  
  			// Return special upon seeing a positional matcher
  			if ( matcher[ expando ] ) {
  				// Find the next relative operator (if any) for proper handling
  				j = ++i;
  				for ( ; j < len; j++ ) {
  					if ( Expr.relative[ tokens[j].type ] ) {
  						break;
  					}
  				}
  				return setMatcher(
  					i > 1 && elementMatcher( matchers ),
  					i > 1 && toSelector(
  						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
  						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
  					).replace( rtrim, "$1" ),
  					matcher,
  					i < j && matcherFromTokens( tokens.slice( i, j ) ),
  					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
  					j < len && toSelector( tokens )
  				);
  			}
  			matchers.push( matcher );
  		}
  	}
  
  	return elementMatcher( matchers );
  }
  
  function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
  	var bySet = setMatchers.length > 0,
  		byElement = elementMatchers.length > 0,
  		superMatcher = function( seed, context, xml, results, outermost ) {
  			var elem, j, matcher,
  				matchedCount = 0,
  				i = "0",
  				unmatched = seed && [],
  				setMatched = [],
  				contextBackup = outermostContext,
  				// We must always have either seed elements or outermost context
  				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
  				// Use integer dirruns iff this is the outermost matcher
  				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
  				len = elems.length;
  
  			if ( outermost ) {
  				outermostContext = context !== document && context;
  			}
  
  			// Add elements passing elementMatchers directly to results
  			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
  			// Support: IE<9, Safari
  			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
  			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
  				if ( byElement && elem ) {
  					j = 0;
  					while ( (matcher = elementMatchers[j++]) ) {
  						if ( matcher( elem, context, xml ) ) {
  							results.push( elem );
  							break;
  						}
  					}
  					if ( outermost ) {
  						dirruns = dirrunsUnique;
  					}
  				}
  
  				// Track unmatched elements for set filters
  				if ( bySet ) {
  					// They will have gone through all possible matchers
  					if ( (elem = !matcher && elem) ) {
  						matchedCount--;
  					}
  
  					// Lengthen the array for every element, matched or not
  					if ( seed ) {
  						unmatched.push( elem );
  					}
  				}
  			}
  
  			// Apply set filters to unmatched elements
  			matchedCount += i;
  			if ( bySet && i !== matchedCount ) {
  				j = 0;
  				while ( (matcher = setMatchers[j++]) ) {
  					matcher( unmatched, setMatched, context, xml );
  				}
  
  				if ( seed ) {
  					// Reintegrate element matches to eliminate the need for sorting
  					if ( matchedCount > 0 ) {
  						while ( i-- ) {
  							if ( !(unmatched[i] || setMatched[i]) ) {
  								setMatched[i] = pop.call( results );
  							}
  						}
  					}
  
  					// Discard index placeholder values to get only actual matches
  					setMatched = condense( setMatched );
  				}
  
  				// Add matches to results
  				push.apply( results, setMatched );
  
  				// Seedless set matches succeeding multiple successful matchers stipulate sorting
  				if ( outermost && !seed && setMatched.length > 0 &&
  					( matchedCount + setMatchers.length ) > 1 ) {
  
  					Sizzle.uniqueSort( results );
  				}
  			}
  
  			// Override manipulation of globals by nested matchers
  			if ( outermost ) {
  				dirruns = dirrunsUnique;
  				outermostContext = contextBackup;
  			}
  
  			return unmatched;
  		};
  
  	return bySet ?
  		markFunction( superMatcher ) :
  		superMatcher;
  }
  
  compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
  	var i,
  		setMatchers = [],
  		elementMatchers = [],
  		cached = compilerCache[ selector + " " ];
  
  	if ( !cached ) {
  		// Generate a function of recursive functions that can be used to check each element
  		if ( !match ) {
  			match = tokenize( selector );
  		}
  		i = match.length;
  		while ( i-- ) {
  			cached = matcherFromTokens( match[i] );
  			if ( cached[ expando ] ) {
  				setMatchers.push( cached );
  			} else {
  				elementMatchers.push( cached );
  			}
  		}
  
  		// Cache the compiled function
  		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
  
  		// Save selector and tokenization
  		cached.selector = selector;
  	}
  	return cached;
  };
  
  /**
   * A low-level selection function that works with Sizzle's compiled
   *  selector functions
   * @param {String|Function} selector A selector or a pre-compiled
   *  selector function built with Sizzle.compile
   * @param {Element} context
   * @param {Array} [results]
   * @param {Array} [seed] A set of elements to match against
   */
  select = Sizzle.select = function( selector, context, results, seed ) {
  	var i, tokens, token, type, find,
  		compiled = typeof selector === "function" && selector,
  		match = !seed && tokenize( (selector = compiled.selector || selector) );
  
  	results = results || [];
  
  	// Try to minimize operations if there is no seed and only one group
  	if ( match.length === 1 ) {
  
  		// Take a shortcut and set the context if the root selector is an ID
  		tokens = match[0] = match[0].slice( 0 );
  		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
  				support.getById && context.nodeType === 9 && documentIsHTML &&
  				Expr.relative[ tokens[1].type ] ) {
  
  			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
  			if ( !context ) {
  				return results;
  
  			// Precompiled matchers will still verify ancestry, so step up a level
  			} else if ( compiled ) {
  				context = context.parentNode;
  			}
  
  			selector = selector.slice( tokens.shift().value.length );
  		}
  
  		// Fetch a seed set for right-to-left matching
  		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
  		while ( i-- ) {
  			token = tokens[i];
  
  			// Abort if we hit a combinator
  			if ( Expr.relative[ (type = token.type) ] ) {
  				break;
  			}
  			if ( (find = Expr.find[ type ]) ) {
  				// Search, expanding context for leading sibling combinators
  				if ( (seed = find(
  					token.matches[0].replace( runescape, funescape ),
  					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
  				)) ) {
  
  					// If seed is empty or no tokens remain, we can return early
  					tokens.splice( i, 1 );
  					selector = seed.length && toSelector( tokens );
  					if ( !selector ) {
  						push.apply( results, seed );
  						return results;
  					}
  
  					break;
  				}
  			}
  		}
  	}
  
  	// Compile and execute a filtering function if one is not provided
  	// Provide `match` to avoid retokenization if we modified the selector above
  	( compiled || compile( selector, match ) )(
  		seed,
  		context,
  		!documentIsHTML,
  		results,
  		rsibling.test( selector ) && testContext( context.parentNode ) || context
  	);
  	return results;
  };
  
  // One-time assignments
  
  // Sort stability
  support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
  
  // Support: Chrome 14-35+
  // Always assume duplicates if they aren't passed to the comparison function
  support.detectDuplicates = !!hasDuplicate;
  
  // Initialize against the default document
  setDocument();
  
  // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
  // Detached nodes confoundingly follow *each other*
  support.sortDetached = assert(function( div1 ) {
  	// Should return 1, but returns 4 (following)
  	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
  });
  
  // Support: IE<8
  // Prevent attribute/property "interpolation"
  // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
  if ( !assert(function( div ) {
  	div.innerHTML = "<a href='#'></a>";
  	return div.firstChild.getAttribute("href") === "#" ;
  }) ) {
  	addHandle( "type|href|height|width", function( elem, name, isXML ) {
  		if ( !isXML ) {
  			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
  		}
  	});
  }
  
  // Support: IE<9
  // Use defaultValue in place of getAttribute("value")
  if ( !support.attributes || !assert(function( div ) {
  	div.innerHTML = "<input/>";
  	div.firstChild.setAttribute( "value", "" );
  	return div.firstChild.getAttribute( "value" ) === "";
  }) ) {
  	addHandle( "value", function( elem, name, isXML ) {
  		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
  			return elem.defaultValue;
  		}
  	});
  }
  
  // Support: IE<9
  // Use getAttributeNode to fetch booleans when getAttribute lies
  if ( !assert(function( div ) {
  	return div.getAttribute("disabled") == null;
  }) ) {
  	addHandle( booleans, function( elem, name, isXML ) {
  		var val;
  		if ( !isXML ) {
  			return elem[ name ] === true ? name.toLowerCase() :
  					(val = elem.getAttributeNode( name )) && val.specified ?
  					val.value :
  				null;
  		}
  	});
  }
  
  return Sizzle;
  
  })( window );
  
  
  
  jQuery.find = Sizzle;
  jQuery.expr = Sizzle.selectors;
  jQuery.expr[":"] = jQuery.expr.pseudos;
  jQuery.unique = Sizzle.uniqueSort;
  jQuery.text = Sizzle.getText;
  jQuery.isXMLDoc = Sizzle.isXML;
  jQuery.contains = Sizzle.contains;
  
  
  
  var rneedsContext = jQuery.expr.match.needsContext;
  
  var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
  
  
  
  var risSimple = /^.[^:#\[\.,]*$/;
  
  // Implement the identical functionality for filter and not
  function winnow( elements, qualifier, not ) {
  	if ( jQuery.isFunction( qualifier ) ) {
  		return jQuery.grep( elements, function( elem, i ) {
  			/* jshint -W018 */
  			return !!qualifier.call( elem, i, elem ) !== not;
  		});
  
  	}
  
  	if ( qualifier.nodeType ) {
  		return jQuery.grep( elements, function( elem ) {
  			return ( elem === qualifier ) !== not;
  		});
  
  	}
  
  	if ( typeof qualifier === "string" ) {
  		if ( risSimple.test( qualifier ) ) {
  			return jQuery.filter( qualifier, elements, not );
  		}
  
  		qualifier = jQuery.filter( qualifier, elements );
  	}
  
  	return jQuery.grep( elements, function( elem ) {
  		return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
  	});
  }
  
  jQuery.filter = function( expr, elems, not ) {
  	var elem = elems[ 0 ];
  
  	if ( not ) {
  		expr = ":not(" + expr + ")";
  	}
  
  	return elems.length === 1 && elem.nodeType === 1 ?
  		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
  		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
  			return elem.nodeType === 1;
  		}));
  };
  
  jQuery.fn.extend({
  	find: function( selector ) {
  		var i,
  			len = this.length,
  			ret = [],
  			self = this;
  
  		if ( typeof selector !== "string" ) {
  			return this.pushStack( jQuery( selector ).filter(function() {
  				for ( i = 0; i < len; i++ ) {
  					if ( jQuery.contains( self[ i ], this ) ) {
  						return true;
  					}
  				}
  			}) );
  		}
  
  		for ( i = 0; i < len; i++ ) {
  			jQuery.find( selector, self[ i ], ret );
  		}
  
  		// Needed because $( selector, context ) becomes $( context ).find( selector )
  		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
  		ret.selector = this.selector ? this.selector + " " + selector : selector;
  		return ret;
  	},
  	filter: function( selector ) {
  		return this.pushStack( winnow(this, selector || [], false) );
  	},
  	not: function( selector ) {
  		return this.pushStack( winnow(this, selector || [], true) );
  	},
  	is: function( selector ) {
  		return !!winnow(
  			this,
  
  			// If this is a positional/relative selector, check membership in the returned set
  			// so $("p:first").is("p:last") won't return true for a doc with two "p".
  			typeof selector === "string" && rneedsContext.test( selector ) ?
  				jQuery( selector ) :
  				selector || [],
  			false
  		).length;
  	}
  });
  
  
  // Initialize a jQuery object
  
  
  // A central reference to the root jQuery(document)
  var rootjQuery,
  
  	// A simple way to check for HTML strings
  	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
  	// Strict HTML recognition (#11290: must start with <)
  	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
  
  	init = jQuery.fn.init = function( selector, context ) {
  		var match, elem;
  
  		// HANDLE: $(""), $(null), $(undefined), $(false)
  		if ( !selector ) {
  			return this;
  		}
  
  		// Handle HTML strings
  		if ( typeof selector === "string" ) {
  			if ( selector[0] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) {
  				// Assume that strings that start and end with <> are HTML and skip the regex check
  				match = [ null, selector, null ];
  
  			} else {
  				match = rquickExpr.exec( selector );
  			}
  
  			// Match html or make sure no context is specified for #id
  			if ( match && (match[1] || !context) ) {
  
  				// HANDLE: $(html) -> $(array)
  				if ( match[1] ) {
  					context = context instanceof jQuery ? context[0] : context;
  
  					// Option to run scripts is true for back-compat
  					// Intentionally let the error be thrown if parseHTML is not present
  					jQuery.merge( this, jQuery.parseHTML(
  						match[1],
  						context && context.nodeType ? context.ownerDocument || context : document,
  						true
  					) );
  
  					// HANDLE: $(html, props)
  					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
  						for ( match in context ) {
  							// Properties of context are called as methods if possible
  							if ( jQuery.isFunction( this[ match ] ) ) {
  								this[ match ]( context[ match ] );
  
  							// ...and otherwise set as attributes
  							} else {
  								this.attr( match, context[ match ] );
  							}
  						}
  					}
  
  					return this;
  
  				// HANDLE: $(#id)
  				} else {
  					elem = document.getElementById( match[2] );
  
  					// Support: Blackberry 4.6
  					// gEBID returns nodes no longer in the document (#6963)
  					if ( elem && elem.parentNode ) {
  						// Inject the element directly into the jQuery object
  						this.length = 1;
  						this[0] = elem;
  					}
  
  					this.context = document;
  					this.selector = selector;
  					return this;
  				}
  
  			// HANDLE: $(expr, $(...))
  			} else if ( !context || context.jquery ) {
  				return ( context || rootjQuery ).find( selector );
  
  			// HANDLE: $(expr, context)
  			// (which is just equivalent to: $(context).find(expr)
  			} else {
  				return this.constructor( context ).find( selector );
  			}
  
  		// HANDLE: $(DOMElement)
  		} else if ( selector.nodeType ) {
  			this.context = this[0] = selector;
  			this.length = 1;
  			return this;
  
  		// HANDLE: $(function)
  		// Shortcut for document ready
  		} else if ( jQuery.isFunction( selector ) ) {
  			return typeof rootjQuery.ready !== "undefined" ?
  				rootjQuery.ready( selector ) :
  				// Execute immediately if ready is not present
  				selector( jQuery );
  		}
  
  		if ( selector.selector !== undefined ) {
  			this.selector = selector.selector;
  			this.context = selector.context;
  		}
  
  		return jQuery.makeArray( selector, this );
  	};
  
  // Give the init function the jQuery prototype for later instantiation
  init.prototype = jQuery.fn;
  
  // Initialize central reference
  rootjQuery = jQuery( document );
  
  
  var rparentsprev = /^(?:parents|prev(?:Until|All))/,
  	// Methods guaranteed to produce a unique set when starting from a unique set
  	guaranteedUnique = {
  		children: true,
  		contents: true,
  		next: true,
  		prev: true
  	};
  
  jQuery.extend({
  	dir: function( elem, dir, until ) {
  		var matched = [],
  			truncate = until !== undefined;
  
  		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
  			if ( elem.nodeType === 1 ) {
  				if ( truncate && jQuery( elem ).is( until ) ) {
  					break;
  				}
  				matched.push( elem );
  			}
  		}
  		return matched;
  	},
  
  	sibling: function( n, elem ) {
  		var matched = [];
  
  		for ( ; n; n = n.nextSibling ) {
  			if ( n.nodeType === 1 && n !== elem ) {
  				matched.push( n );
  			}
  		}
  
  		return matched;
  	}
  });
  
  jQuery.fn.extend({
  	has: function( target ) {
  		var targets = jQuery( target, this ),
  			l = targets.length;
  
  		return this.filter(function() {
  			var i = 0;
  			for ( ; i < l; i++ ) {
  				if ( jQuery.contains( this, targets[i] ) ) {
  					return true;
  				}
  			}
  		});
  	},
  
  	closest: function( selectors, context ) {
  		var cur,
  			i = 0,
  			l = this.length,
  			matched = [],
  			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
  				jQuery( selectors, context || this.context ) :
  				0;
  
  		for ( ; i < l; i++ ) {
  			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
  				// Always skip document fragments
  				if ( cur.nodeType < 11 && (pos ?
  					pos.index(cur) > -1 :
  
  					// Don't pass non-elements to Sizzle
  					cur.nodeType === 1 &&
  						jQuery.find.matchesSelector(cur, selectors)) ) {
  
  					matched.push( cur );
  					break;
  				}
  			}
  		}
  
  		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
  	},
  
  	// Determine the position of an element within the set
  	index: function( elem ) {
  
  		// No argument, return index in parent
  		if ( !elem ) {
  			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
  		}
  
  		// Index in selector
  		if ( typeof elem === "string" ) {
  			return indexOf.call( jQuery( elem ), this[ 0 ] );
  		}
  
  		// Locate the position of the desired element
  		return indexOf.call( this,
  
  			// If it receives a jQuery object, the first element is used
  			elem.jquery ? elem[ 0 ] : elem
  		);
  	},
  
  	add: function( selector, context ) {
  		return this.pushStack(
  			jQuery.unique(
  				jQuery.merge( this.get(), jQuery( selector, context ) )
  			)
  		);
  	},
  
  	addBack: function( selector ) {
  		return this.add( selector == null ?
  			this.prevObject : this.prevObject.filter(selector)
  		);
  	}
  });
  
  function sibling( cur, dir ) {
  	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
  	return cur;
  }
  
  jQuery.each({
  	parent: function( elem ) {
  		var parent = elem.parentNode;
  		return parent && parent.nodeType !== 11 ? parent : null;
  	},
  	parents: function( elem ) {
  		return jQuery.dir( elem, "parentNode" );
  	},
  	parentsUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "parentNode", until );
  	},
  	next: function( elem ) {
  		return sibling( elem, "nextSibling" );
  	},
  	prev: function( elem ) {
  		return sibling( elem, "previousSibling" );
  	},
  	nextAll: function( elem ) {
  		return jQuery.dir( elem, "nextSibling" );
  	},
  	prevAll: function( elem ) {
  		return jQuery.dir( elem, "previousSibling" );
  	},
  	nextUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "nextSibling", until );
  	},
  	prevUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "previousSibling", until );
  	},
  	siblings: function( elem ) {
  		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
  	},
  	children: function( elem ) {
  		return jQuery.sibling( elem.firstChild );
  	},
  	contents: function( elem ) {
  		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
  	}
  }, function( name, fn ) {
  	jQuery.fn[ name ] = function( until, selector ) {
  		var matched = jQuery.map( this, fn, until );
  
  		if ( name.slice( -5 ) !== "Until" ) {
  			selector = until;
  		}
  
  		if ( selector && typeof selector === "string" ) {
  			matched = jQuery.filter( selector, matched );
  		}
  
  		if ( this.length > 1 ) {
  			// Remove duplicates
  			if ( !guaranteedUnique[ name ] ) {
  				jQuery.unique( matched );
  			}
  
  			// Reverse order for parents* and prev-derivatives
  			if ( rparentsprev.test( name ) ) {
  				matched.reverse();
  			}
  		}
  
  		return this.pushStack( matched );
  	};
  });
  var rnotwhite = (/\S+/g);
  
  
  
  // String to Object options format cache
  var optionsCache = {};
  
  // Convert String-formatted options into Object-formatted ones and store in cache
  function createOptions( options ) {
  	var object = optionsCache[ options ] = {};
  	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
  		object[ flag ] = true;
  	});
  	return object;
  }
  
  /*
   * Create a callback list using the following parameters:
   *
   *	options: an optional list of space-separated options that will change how
   *			the callback list behaves or a more traditional option object
   *
   * By default a callback list will act like an event callback list and can be
   * "fired" multiple times.
   *
   * Possible options:
   *
   *	once:			will ensure the callback list can only be fired once (like a Deferred)
   *
   *	memory:			will keep track of previous values and will call any callback added
   *					after the list has been fired right away with the latest "memorized"
   *					values (like a Deferred)
   *
   *	unique:			will ensure a callback can only be added once (no duplicate in the list)
   *
   *	stopOnFalse:	interrupt callings when a callback returns false
   *
   */
  jQuery.Callbacks = function( options ) {
  
  	// Convert options from String-formatted to Object-formatted if needed
  	// (we check in cache first)
  	options = typeof options === "string" ?
  		( optionsCache[ options ] || createOptions( options ) ) :
  		jQuery.extend( {}, options );
  
  	var // Last fire value (for non-forgettable lists)
  		memory,
  		// Flag to know if list was already fired
  		fired,
  		// Flag to know if list is currently firing
  		firing,
  		// First callback to fire (used internally by add and fireWith)
  		firingStart,
  		// End of the loop when firing
  		firingLength,
  		// Index of currently firing callback (modified by remove if needed)
  		firingIndex,
  		// Actual callback list
  		list = [],
  		// Stack of fire calls for repeatable lists
  		stack = !options.once && [],
  		// Fire callbacks
  		fire = function( data ) {
  			memory = options.memory && data;
  			fired = true;
  			firingIndex = firingStart || 0;
  			firingStart = 0;
  			firingLength = list.length;
  			firing = true;
  			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
  				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
  					memory = false; // To prevent further calls using add
  					break;
  				}
  			}
  			firing = false;
  			if ( list ) {
  				if ( stack ) {
  					if ( stack.length ) {
  						fire( stack.shift() );
  					}
  				} else if ( memory ) {
  					list = [];
  				} else {
  					self.disable();
  				}
  			}
  		},
  		// Actual Callbacks object
  		self = {
  			// Add a callback or a collection of callbacks to the list
  			add: function() {
  				if ( list ) {
  					// First, we save the current length
  					var start = list.length;
  					(function add( args ) {
  						jQuery.each( args, function( _, arg ) {
  							var type = jQuery.type( arg );
  							if ( type === "function" ) {
  								if ( !options.unique || !self.has( arg ) ) {
  									list.push( arg );
  								}
  							} else if ( arg && arg.length && type !== "string" ) {
  								// Inspect recursively
  								add( arg );
  							}
  						});
  					})( arguments );
  					// Do we need to add the callbacks to the
  					// current firing batch?
  					if ( firing ) {
  						firingLength = list.length;
  					// With memory, if we're not firing then
  					// we should call right away
  					} else if ( memory ) {
  						firingStart = start;
  						fire( memory );
  					}
  				}
  				return this;
  			},
  			// Remove a callback from the list
  			remove: function() {
  				if ( list ) {
  					jQuery.each( arguments, function( _, arg ) {
  						var index;
  						while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
  							list.splice( index, 1 );
  							// Handle firing indexes
  							if ( firing ) {
  								if ( index <= firingLength ) {
  									firingLength--;
  								}
  								if ( index <= firingIndex ) {
  									firingIndex--;
  								}
  							}
  						}
  					});
  				}
  				return this;
  			},
  			// Check if a given callback is in the list.
  			// If no argument is given, return whether or not list has callbacks attached.
  			has: function( fn ) {
  				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
  			},
  			// Remove all callbacks from the list
  			empty: function() {
  				list = [];
  				firingLength = 0;
  				return this;
  			},
  			// Have the list do nothing anymore
  			disable: function() {
  				list = stack = memory = undefined;
  				return this;
  			},
  			// Is it disabled?
  			disabled: function() {
  				return !list;
  			},
  			// Lock the list in its current state
  			lock: function() {
  				stack = undefined;
  				if ( !memory ) {
  					self.disable();
  				}
  				return this;
  			},
  			// Is it locked?
  			locked: function() {
  				return !stack;
  			},
  			// Call all callbacks with the given context and arguments
  			fireWith: function( context, args ) {
  				if ( list && ( !fired || stack ) ) {
  					args = args || [];
  					args = [ context, args.slice ? args.slice() : args ];
  					if ( firing ) {
  						stack.push( args );
  					} else {
  						fire( args );
  					}
  				}
  				return this;
  			},
  			// Call all the callbacks with the given arguments
  			fire: function() {
  				self.fireWith( this, arguments );
  				return this;
  			},
  			// To know if the callbacks have already been called at least once
  			fired: function() {
  				return !!fired;
  			}
  		};
  
  	return self;
  };
  
  
  jQuery.extend({
  
  	Deferred: function( func ) {
  		var tuples = [
  				// action, add listener, listener list, final state
  				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
  				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
  				[ "notify", "progress", jQuery.Callbacks("memory") ]
  			],
  			state = "pending",
  			promise = {
  				state: function() {
  					return state;
  				},
  				always: function() {
  					deferred.done( arguments ).fail( arguments );
  					return this;
  				},
  				then: function( /* fnDone, fnFail, fnProgress */ ) {
  					var fns = arguments;
  					return jQuery.Deferred(function( newDefer ) {
  						jQuery.each( tuples, function( i, tuple ) {
  							var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
  							// deferred[ done | fail | progress ] for forwarding actions to newDefer
  							deferred[ tuple[1] ](function() {
  								var returned = fn && fn.apply( this, arguments );
  								if ( returned && jQuery.isFunction( returned.promise ) ) {
  									returned.promise()
  										.done( newDefer.resolve )
  										.fail( newDefer.reject )
  										.progress( newDefer.notify );
  								} else {
  									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
  								}
  							});
  						});
  						fns = null;
  					}).promise();
  				},
  				// Get a promise for this deferred
  				// If obj is provided, the promise aspect is added to the object
  				promise: function( obj ) {
  					return obj != null ? jQuery.extend( obj, promise ) : promise;
  				}
  			},
  			deferred = {};
  
  		// Keep pipe for back-compat
  		promise.pipe = promise.then;
  
  		// Add list-specific methods
  		jQuery.each( tuples, function( i, tuple ) {
  			var list = tuple[ 2 ],
  				stateString = tuple[ 3 ];
  
  			// promise[ done | fail | progress ] = list.add
  			promise[ tuple[1] ] = list.add;
  
  			// Handle state
  			if ( stateString ) {
  				list.add(function() {
  					// state = [ resolved | rejected ]
  					state = stateString;
  
  				// [ reject_list | resolve_list ].disable; progress_list.lock
  				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
  			}
  
  			// deferred[ resolve | reject | notify ]
  			deferred[ tuple[0] ] = function() {
  				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
  				return this;
  			};
  			deferred[ tuple[0] + "With" ] = list.fireWith;
  		});
  
  		// Make the deferred a promise
  		promise.promise( deferred );
  
  		// Call given func if any
  		if ( func ) {
  			func.call( deferred, deferred );
  		}
  
  		// All done!
  		return deferred;
  	},
  
  	// Deferred helper
  	when: function( subordinate /* , ..., subordinateN */ ) {
  		var i = 0,
  			resolveValues = slice.call( arguments ),
  			length = resolveValues.length,
  
  			// the count of uncompleted subordinates
  			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
  
  			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
  			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
  
  			// Update function for both resolve and progress values
  			updateFunc = function( i, contexts, values ) {
  				return function( value ) {
  					contexts[ i ] = this;
  					values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
  					if ( values === progressValues ) {
  						deferred.notifyWith( contexts, values );
  					} else if ( !( --remaining ) ) {
  						deferred.resolveWith( contexts, values );
  					}
  				};
  			},
  
  			progressValues, progressContexts, resolveContexts;
  
  		// Add listeners to Deferred subordinates; treat others as resolved
  		if ( length > 1 ) {
  			progressValues = new Array( length );
  			progressContexts = new Array( length );
  			resolveContexts = new Array( length );
  			for ( ; i < length; i++ ) {
  				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
  					resolveValues[ i ].promise()
  						.done( updateFunc( i, resolveContexts, resolveValues ) )
  						.fail( deferred.reject )
  						.progress( updateFunc( i, progressContexts, progressValues ) );
  				} else {
  					--remaining;
  				}
  			}
  		}
  
  		// If we're not waiting on anything, resolve the master
  		if ( !remaining ) {
  			deferred.resolveWith( resolveContexts, resolveValues );
  		}
  
  		return deferred.promise();
  	}
  });
  
  
  // The deferred used on DOM ready
  var readyList;
  
  jQuery.fn.ready = function( fn ) {
  	// Add the callback
  	jQuery.ready.promise().done( fn );
  
  	return this;
  };
  
  jQuery.extend({
  	// Is the DOM ready to be used? Set to true once it occurs.
  	isReady: false,
  
  	// A counter to track how many items to wait for before
  	// the ready event fires. See #6781
  	readyWait: 1,
  
  	// Hold (or release) the ready event
  	holdReady: function( hold ) {
  		if ( hold ) {
  			jQuery.readyWait++;
  		} else {
  			jQuery.ready( true );
  		}
  	},
  
  	// Handle when the DOM is ready
  	ready: function( wait ) {
  
  		// Abort if there are pending holds or we're already ready
  		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
  			return;
  		}
  
  		// Remember that the DOM is ready
  		jQuery.isReady = true;
  
  		// If a normal DOM Ready event fired, decrement, and wait if need be
  		if ( wait !== true && --jQuery.readyWait > 0 ) {
  			return;
  		}
  
  		// If there are functions bound, to execute
  		readyList.resolveWith( document, [ jQuery ] );
  
  		// Trigger any bound ready events
  		if ( jQuery.fn.triggerHandler ) {
  			jQuery( document ).triggerHandler( "ready" );
  			jQuery( document ).off( "ready" );
  		}
  	}
  });
  
  /**
   * The ready event handler and self cleanup method
   */
  function completed() {
  	document.removeEventListener( "DOMContentLoaded", completed, false );
  	window.removeEventListener( "load", completed, false );
  	jQuery.ready();
  }
  
  jQuery.ready.promise = function( obj ) {
  	if ( !readyList ) {
  
  		readyList = jQuery.Deferred();
  
  		// Catch cases where $(document).ready() is called after the browser event has already occurred.
  		// We once tried to use readyState "interactive" here, but it caused issues like the one
  		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
  		if ( document.readyState === "complete" ) {
  			// Handle it asynchronously to allow scripts the opportunity to delay ready
  			setTimeout( jQuery.ready );
  
  		} else {
  
  			// Use the handy event callback
  			document.addEventListener( "DOMContentLoaded", completed, false );
  
  			// A fallback to window.onload, that will always work
  			window.addEventListener( "load", completed, false );
  		}
  	}
  	return readyList.promise( obj );
  };
  
  // Kick off the DOM ready check even if the user does not
  jQuery.ready.promise();
  
  
  
  
  // Multifunctional method to get and set values of a collection
  // The value/s can optionally be executed if it's a function
  var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
  	var i = 0,
  		len = elems.length,
  		bulk = key == null;
  
  	// Sets many values
  	if ( jQuery.type( key ) === "object" ) {
  		chainable = true;
  		for ( i in key ) {
  			jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
  		}
  
  	// Sets one value
  	} else if ( value !== undefined ) {
  		chainable = true;
  
  		if ( !jQuery.isFunction( value ) ) {
  			raw = true;
  		}
  
  		if ( bulk ) {
  			// Bulk operations run against the entire set
  			if ( raw ) {
  				fn.call( elems, value );
  				fn = null;
  
  			// ...except when executing function values
  			} else {
  				bulk = fn;
  				fn = function( elem, key, value ) {
  					return bulk.call( jQuery( elem ), value );
  				};
  			}
  		}
  
  		if ( fn ) {
  			for ( ; i < len; i++ ) {
  				fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
  			}
  		}
  	}
  
  	return chainable ?
  		elems :
  
  		// Gets
  		bulk ?
  			fn.call( elems ) :
  			len ? fn( elems[0], key ) : emptyGet;
  };
  
  
  /**
   * Determines whether an object can have data
   */
  jQuery.acceptData = function( owner ) {
  	// Accepts only:
  	//  - Node
  	//    - Node.ELEMENT_NODE
  	//    - Node.DOCUMENT_NODE
  	//  - Object
  	//    - Any
  	/* jshint -W018 */
  	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
  };
  
  
  function Data() {
  	// Support: Android<4,
  	// Old WebKit does not have Object.preventExtensions/freeze method,
  	// return new empty object instead with no [[set]] accessor
  	Object.defineProperty( this.cache = {}, 0, {
  		get: function() {
  			return {};
  		}
  	});
  
  	this.expando = jQuery.expando + Data.uid++;
  }
  
  Data.uid = 1;
  Data.accepts = jQuery.acceptData;
  
  Data.prototype = {
  	key: function( owner ) {
  		// We can accept data for non-element nodes in modern browsers,
  		// but we should not, see #8335.
  		// Always return the key for a frozen object.
  		if ( !Data.accepts( owner ) ) {
  			return 0;
  		}
  
  		var descriptor = {},
  			// Check if the owner object already has a cache key
  			unlock = owner[ this.expando ];
  
  		// If not, create one
  		if ( !unlock ) {
  			unlock = Data.uid++;
  
  			// Secure it in a non-enumerable, non-writable property
  			try {
  				descriptor[ this.expando ] = { value: unlock };
  				Object.defineProperties( owner, descriptor );
  
  			// Support: Android<4
  			// Fallback to a less secure definition
  			} catch ( e ) {
  				descriptor[ this.expando ] = unlock;
  				jQuery.extend( owner, descriptor );
  			}
  		}
  
  		// Ensure the cache object
  		if ( !this.cache[ unlock ] ) {
  			this.cache[ unlock ] = {};
  		}
  
  		return unlock;
  	},
  	set: function( owner, data, value ) {
  		var prop,
  			// There may be an unlock assigned to this node,
  			// if there is no entry for this "owner", create one inline
  			// and set the unlock as though an owner entry had always existed
  			unlock = this.key( owner ),
  			cache = this.cache[ unlock ];
  
  		// Handle: [ owner, key, value ] args
  		if ( typeof data === "string" ) {
  			cache[ data ] = value;
  
  		// Handle: [ owner, { properties } ] args
  		} else {
  			// Fresh assignments by object are shallow copied
  			if ( jQuery.isEmptyObject( cache ) ) {
  				jQuery.extend( this.cache[ unlock ], data );
  			// Otherwise, copy the properties one-by-one to the cache object
  			} else {
  				for ( prop in data ) {
  					cache[ prop ] = data[ prop ];
  				}
  			}
  		}
  		return cache;
  	},
  	get: function( owner, key ) {
  		// Either a valid cache is found, or will be created.
  		// New caches will be created and the unlock returned,
  		// allowing direct access to the newly created
  		// empty data object. A valid owner object must be provided.
  		var cache = this.cache[ this.key( owner ) ];
  
  		return key === undefined ?
  			cache : cache[ key ];
  	},
  	access: function( owner, key, value ) {
  		var stored;
  		// In cases where either:
  		//
  		//   1. No key was specified
  		//   2. A string key was specified, but no value provided
  		//
  		// Take the "read" path and allow the get method to determine
  		// which value to return, respectively either:
  		//
  		//   1. The entire cache object
  		//   2. The data stored at the key
  		//
  		if ( key === undefined ||
  				((key && typeof key === "string") && value === undefined) ) {
  
  			stored = this.get( owner, key );
  
  			return stored !== undefined ?
  				stored : this.get( owner, jQuery.camelCase(key) );
  		}
  
  		// [*]When the key is not a string, or both a key and value
  		// are specified, set or extend (existing objects) with either:
  		//
  		//   1. An object of properties
  		//   2. A key and value
  		//
  		this.set( owner, key, value );
  
  		// Since the "set" path can have two possible entry points
  		// return the expected data based on which path was taken[*]
  		return value !== undefined ? value : key;
  	},
  	remove: function( owner, key ) {
  		var i, name, camel,
  			unlock = this.key( owner ),
  			cache = this.cache[ unlock ];
  
  		if ( key === undefined ) {
  			this.cache[ unlock ] = {};
  
  		} else {
  			// Support array or space separated string of keys
  			if ( jQuery.isArray( key ) ) {
  				// If "name" is an array of keys...
  				// When data is initially created, via ("key", "val") signature,
  				// keys will be converted to camelCase.
  				// Since there is no way to tell _how_ a key was added, remove
  				// both plain key and camelCase key. #12786
  				// This will only penalize the array argument path.
  				name = key.concat( key.map( jQuery.camelCase ) );
  			} else {
  				camel = jQuery.camelCase( key );
  				// Try the string as a key before any manipulation
  				if ( key in cache ) {
  					name = [ key, camel ];
  				} else {
  					// If a key with the spaces exists, use it.
  					// Otherwise, create an array by matching non-whitespace
  					name = camel;
  					name = name in cache ?
  						[ name ] : ( name.match( rnotwhite ) || [] );
  				}
  			}
  
  			i = name.length;
  			while ( i-- ) {
  				delete cache[ name[ i ] ];
  			}
  		}
  	},
  	hasData: function( owner ) {
  		return !jQuery.isEmptyObject(
  			this.cache[ owner[ this.expando ] ] || {}
  		);
  	},
  	discard: function( owner ) {
  		if ( owner[ this.expando ] ) {
  			delete this.cache[ owner[ this.expando ] ];
  		}
  	}
  };
  var data_priv = new Data();
  
  var data_user = new Data();
  
  
  
  //	Implementation Summary
  //
  //	1. Enforce API surface and semantic compatibility with 1.9.x branch
  //	2. Improve the module's maintainability by reducing the storage
  //		paths to a single mechanism.
  //	3. Use the same single mechanism to support "private" and "user" data.
  //	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
  //	5. Avoid exposing implementation details on user objects (eg. expando properties)
  //	6. Provide a clear path for implementation upgrade to WeakMap in 2014
  
  var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
  	rmultiDash = /([A-Z])/g;
  
  function dataAttr( elem, key, data ) {
  	var name;
  
  	// If nothing was found internally, try to fetch any
  	// data from the HTML5 data-* attribute
  	if ( data === undefined && elem.nodeType === 1 ) {
  		name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
  		data = elem.getAttribute( name );
  
  		if ( typeof data === "string" ) {
  			try {
  				data = data === "true" ? true :
  					data === "false" ? false :
  					data === "null" ? null :
  					// Only convert to a number if it doesn't change the string
  					+data + "" === data ? +data :
  					rbrace.test( data ) ? jQuery.parseJSON( data ) :
  					data;
  			} catch( e ) {}
  
  			// Make sure we set the data so it isn't changed later
  			data_user.set( elem, key, data );
  		} else {
  			data = undefined;
  		}
  	}
  	return data;
  }
  
  jQuery.extend({
  	hasData: function( elem ) {
  		return data_user.hasData( elem ) || data_priv.hasData( elem );
  	},
  
  	data: function( elem, name, data ) {
  		return data_user.access( elem, name, data );
  	},
  
  	removeData: function( elem, name ) {
  		data_user.remove( elem, name );
  	},
  
  	// TODO: Now that all calls to _data and _removeData have been replaced
  	// with direct calls to data_priv methods, these can be deprecated.
  	_data: function( elem, name, data ) {
  		return data_priv.access( elem, name, data );
  	},
  
  	_removeData: function( elem, name ) {
  		data_priv.remove( elem, name );
  	}
  });
  
  jQuery.fn.extend({
  	data: function( key, value ) {
  		var i, name, data,
  			elem = this[ 0 ],
  			attrs = elem && elem.attributes;
  
  		// Gets all values
  		if ( key === undefined ) {
  			if ( this.length ) {
  				data = data_user.get( elem );
  
  				if ( elem.nodeType === 1 && !data_priv.get( elem, "hasDataAttrs" ) ) {
  					i = attrs.length;
  					while ( i-- ) {
  
  						// Support: IE11+
  						// The attrs elements can be null (#14894)
  						if ( attrs[ i ] ) {
  							name = attrs[ i ].name;
  							if ( name.indexOf( "data-" ) === 0 ) {
  								name = jQuery.camelCase( name.slice(5) );
  								dataAttr( elem, name, data[ name ] );
  							}
  						}
  					}
  					data_priv.set( elem, "hasDataAttrs", true );
  				}
  			}
  
  			return data;
  		}
  
  		// Sets multiple values
  		if ( typeof key === "object" ) {
  			return this.each(function() {
  				data_user.set( this, key );
  			});
  		}
  
  		return access( this, function( value ) {
  			var data,
  				camelKey = jQuery.camelCase( key );
  
  			// The calling jQuery object (element matches) is not empty
  			// (and therefore has an element appears at this[ 0 ]) and the
  			// `value` parameter was not undefined. An empty jQuery object
  			// will result in `undefined` for elem = this[ 0 ] which will
  			// throw an exception if an attempt to read a data cache is made.
  			if ( elem && value === undefined ) {
  				// Attempt to get data from the cache
  				// with the key as-is
  				data = data_user.get( elem, key );
  				if ( data !== undefined ) {
  					return data;
  				}
  
  				// Attempt to get data from the cache
  				// with the key camelized
  				data = data_user.get( elem, camelKey );
  				if ( data !== undefined ) {
  					return data;
  				}
  
  				// Attempt to "discover" the data in
  				// HTML5 custom data-* attrs
  				data = dataAttr( elem, camelKey, undefined );
  				if ( data !== undefined ) {
  					return data;
  				}
  
  				// We tried really hard, but the data doesn't exist.
  				return;
  			}
  
  			// Set the data...
  			this.each(function() {
  				// First, attempt to store a copy or reference of any
  				// data that might've been store with a camelCased key.
  				var data = data_user.get( this, camelKey );
  
  				// For HTML5 data-* attribute interop, we have to
  				// store property names with dashes in a camelCase form.
  				// This might not apply to all properties...*
  				data_user.set( this, camelKey, value );
  
  				// *... In the case of properties that might _actually_
  				// have dashes, we need to also store a copy of that
  				// unchanged property.
  				if ( key.indexOf("-") !== -1 && data !== undefined ) {
  					data_user.set( this, key, value );
  				}
  			});
  		}, null, value, arguments.length > 1, null, true );
  	},
  
  	removeData: function( key ) {
  		return this.each(function() {
  			data_user.remove( this, key );
  		});
  	}
  });
  
  
  jQuery.extend({
  	queue: function( elem, type, data ) {
  		var queue;
  
  		if ( elem ) {
  			type = ( type || "fx" ) + "queue";
  			queue = data_priv.get( elem, type );
  
  			// Speed up dequeue by getting out quickly if this is just a lookup
  			if ( data ) {
  				if ( !queue || jQuery.isArray( data ) ) {
  					queue = data_priv.access( elem, type, jQuery.makeArray(data) );
  				} else {
  					queue.push( data );
  				}
  			}
  			return queue || [];
  		}
  	},
  
  	dequeue: function( elem, type ) {
  		type = type || "fx";
  
  		var queue = jQuery.queue( elem, type ),
  			startLength = queue.length,
  			fn = queue.shift(),
  			hooks = jQuery._queueHooks( elem, type ),
  			next = function() {
  				jQuery.dequeue( elem, type );
  			};
  
  		// If the fx queue is dequeued, always remove the progress sentinel
  		if ( fn === "inprogress" ) {
  			fn = queue.shift();
  			startLength--;
  		}
  
  		if ( fn ) {
  
  			// Add a progress sentinel to prevent the fx queue from being
  			// automatically dequeued
  			if ( type === "fx" ) {
  				queue.unshift( "inprogress" );
  			}
  
  			// Clear up the last queue stop function
  			delete hooks.stop;
  			fn.call( elem, next, hooks );
  		}
  
  		if ( !startLength && hooks ) {
  			hooks.empty.fire();
  		}
  	},
  
  	// Not public - generate a queueHooks object, or return the current one
  	_queueHooks: function( elem, type ) {
  		var key = type + "queueHooks";
  		return data_priv.get( elem, key ) || data_priv.access( elem, key, {
  			empty: jQuery.Callbacks("once memory").add(function() {
  				data_priv.remove( elem, [ type + "queue", key ] );
  			})
  		});
  	}
  });
  
  jQuery.fn.extend({
  	queue: function( type, data ) {
  		var setter = 2;
  
  		if ( typeof type !== "string" ) {
  			data = type;
  			type = "fx";
  			setter--;
  		}
  
  		if ( arguments.length < setter ) {
  			return jQuery.queue( this[0], type );
  		}
  
  		return data === undefined ?
  			this :
  			this.each(function() {
  				var queue = jQuery.queue( this, type, data );
  
  				// Ensure a hooks for this queue
  				jQuery._queueHooks( this, type );
  
  				if ( type === "fx" && queue[0] !== "inprogress" ) {
  					jQuery.dequeue( this, type );
  				}
  			});
  	},
  	dequeue: function( type ) {
  		return this.each(function() {
  			jQuery.dequeue( this, type );
  		});
  	},
  	clearQueue: function( type ) {
  		return this.queue( type || "fx", [] );
  	},
  	// Get a promise resolved when queues of a certain type
  	// are emptied (fx is the type by default)
  	promise: function( type, obj ) {
  		var tmp,
  			count = 1,
  			defer = jQuery.Deferred(),
  			elements = this,
  			i = this.length,
  			resolve = function() {
  				if ( !( --count ) ) {
  					defer.resolveWith( elements, [ elements ] );
  				}
  			};
  
  		if ( typeof type !== "string" ) {
  			obj = type;
  			type = undefined;
  		}
  		type = type || "fx";
  
  		while ( i-- ) {
  			tmp = data_priv.get( elements[ i ], type + "queueHooks" );
  			if ( tmp && tmp.empty ) {
  				count++;
  				tmp.empty.add( resolve );
  			}
  		}
  		resolve();
  		return defer.promise( obj );
  	}
  });
  var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
  
  var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
  
  var isHidden = function( elem, el ) {
  		// isHidden might be called from jQuery#filter function;
  		// in that case, element will be second argument
  		elem = el || elem;
  		return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
  	};
  
  var rcheckableType = (/^(?:checkbox|radio)$/i);
  
  
  
  (function() {
  	var fragment = document.createDocumentFragment(),
  		div = fragment.appendChild( document.createElement( "div" ) ),
  		input = document.createElement( "input" );
  
  	// Support: Safari<=5.1
  	// Check state lost if the name is set (#11217)
  	// Support: Windows Web Apps (WWA)
  	// `name` and `type` must use .setAttribute for WWA (#14901)
  	input.setAttribute( "type", "radio" );
  	input.setAttribute( "checked", "checked" );
  	input.setAttribute( "name", "t" );
  
  	div.appendChild( input );
  
  	// Support: Safari<=5.1, Android<4.2
  	// Older WebKit doesn't clone checked state correctly in fragments
  	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
  
  	// Support: IE<=11+
  	// Make sure textarea (and checkbox) defaultValue is properly cloned
  	div.innerHTML = "<textarea>x</textarea>";
  	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
  })();
  var strundefined = typeof undefined;
  
  
  
  support.focusinBubbles = "onfocusin" in window;
  
  
  var
  	rkeyEvent = /^key/,
  	rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,
  	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
  	rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
  
  function returnTrue() {
  	return true;
  }
  
  function returnFalse() {
  	return false;
  }
  
  function safeActiveElement() {
  	try {
  		return document.activeElement;
  	} catch ( err ) { }
  }
  
  /*
   * Helper functions for managing events -- not part of the public interface.
   * Props to Dean Edwards' addEvent library for many of the ideas.
   */
  jQuery.event = {
  
  	global: {},
  
  	add: function( elem, types, handler, data, selector ) {
  
  		var handleObjIn, eventHandle, tmp,
  			events, t, handleObj,
  			special, handlers, type, namespaces, origType,
  			elemData = data_priv.get( elem );
  
  		// Don't attach events to noData or text/comment nodes (but allow plain objects)
  		if ( !elemData ) {
  			return;
  		}
  
  		// Caller can pass in an object of custom data in lieu of the handler
  		if ( handler.handler ) {
  			handleObjIn = handler;
  			handler = handleObjIn.handler;
  			selector = handleObjIn.selector;
  		}
  
  		// Make sure that the handler has a unique ID, used to find/remove it later
  		if ( !handler.guid ) {
  			handler.guid = jQuery.guid++;
  		}
  
  		// Init the element's event structure and main handler, if this is the first
  		if ( !(events = elemData.events) ) {
  			events = elemData.events = {};
  		}
  		if ( !(eventHandle = elemData.handle) ) {
  			eventHandle = elemData.handle = function( e ) {
  				// Discard the second event of a jQuery.event.trigger() and
  				// when an event is called after a page has unloaded
  				return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ?
  					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
  			};
  		}
  
  		// Handle multiple events separated by a space
  		types = ( types || "" ).match( rnotwhite ) || [ "" ];
  		t = types.length;
  		while ( t-- ) {
  			tmp = rtypenamespace.exec( types[t] ) || [];
  			type = origType = tmp[1];
  			namespaces = ( tmp[2] || "" ).split( "." ).sort();
  
  			// There *must* be a type, no attaching namespace-only handlers
  			if ( !type ) {
  				continue;
  			}
  
  			// If event changes its type, use the special event handlers for the changed type
  			special = jQuery.event.special[ type ] || {};
  
  			// If selector defined, determine special event api type, otherwise given type
  			type = ( selector ? special.delegateType : special.bindType ) || type;
  
  			// Update special based on newly reset type
  			special = jQuery.event.special[ type ] || {};
  
  			// handleObj is passed to all event handlers
  			handleObj = jQuery.extend({
  				type: type,
  				origType: origType,
  				data: data,
  				handler: handler,
  				guid: handler.guid,
  				selector: selector,
  				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
  				namespace: namespaces.join(".")
  			}, handleObjIn );
  
  			// Init the event handler queue if we're the first
  			if ( !(handlers = events[ type ]) ) {
  				handlers = events[ type ] = [];
  				handlers.delegateCount = 0;
  
  				// Only use addEventListener if the special events handler returns false
  				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  					if ( elem.addEventListener ) {
  						elem.addEventListener( type, eventHandle, false );
  					}
  				}
  			}
  
  			if ( special.add ) {
  				special.add.call( elem, handleObj );
  
  				if ( !handleObj.handler.guid ) {
  					handleObj.handler.guid = handler.guid;
  				}
  			}
  
  			// Add to the element's handler list, delegates in front
  			if ( selector ) {
  				handlers.splice( handlers.delegateCount++, 0, handleObj );
  			} else {
  				handlers.push( handleObj );
  			}
  
  			// Keep track of which events have ever been used, for event optimization
  			jQuery.event.global[ type ] = true;
  		}
  
  	},
  
  	// Detach an event or set of events from an element
  	remove: function( elem, types, handler, selector, mappedTypes ) {
  
  		var j, origCount, tmp,
  			events, t, handleObj,
  			special, handlers, type, namespaces, origType,
  			elemData = data_priv.hasData( elem ) && data_priv.get( elem );
  
  		if ( !elemData || !(events = elemData.events) ) {
  			return;
  		}
  
  		// Once for each type.namespace in types; type may be omitted
  		types = ( types || "" ).match( rnotwhite ) || [ "" ];
  		t = types.length;
  		while ( t-- ) {
  			tmp = rtypenamespace.exec( types[t] ) || [];
  			type = origType = tmp[1];
  			namespaces = ( tmp[2] || "" ).split( "." ).sort();
  
  			// Unbind all events (on this namespace, if provided) for the element
  			if ( !type ) {
  				for ( type in events ) {
  					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
  				}
  				continue;
  			}
  
  			special = jQuery.event.special[ type ] || {};
  			type = ( selector ? special.delegateType : special.bindType ) || type;
  			handlers = events[ type ] || [];
  			tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
  
  			// Remove matching events
  			origCount = j = handlers.length;
  			while ( j-- ) {
  				handleObj = handlers[ j ];
  
  				if ( ( mappedTypes || origType === handleObj.origType ) &&
  					( !handler || handler.guid === handleObj.guid ) &&
  					( !tmp || tmp.test( handleObj.namespace ) ) &&
  					( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
  					handlers.splice( j, 1 );
  
  					if ( handleObj.selector ) {
  						handlers.delegateCount--;
  					}
  					if ( special.remove ) {
  						special.remove.call( elem, handleObj );
  					}
  				}
  			}
  
  			// Remove generic event handler if we removed something and no more handlers exist
  			// (avoids potential for endless recursion during removal of special event handlers)
  			if ( origCount && !handlers.length ) {
  				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
  					jQuery.removeEvent( elem, type, elemData.handle );
  				}
  
  				delete events[ type ];
  			}
  		}
  
  		// Remove the expando if it's no longer used
  		if ( jQuery.isEmptyObject( events ) ) {
  			delete elemData.handle;
  			data_priv.remove( elem, "events" );
  		}
  	},
  
  	trigger: function( event, data, elem, onlyHandlers ) {
  
  		var i, cur, tmp, bubbleType, ontype, handle, special,
  			eventPath = [ elem || document ],
  			type = hasOwn.call( event, "type" ) ? event.type : event,
  			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
  
  		cur = tmp = elem = elem || document;
  
  		// Don't do events on text and comment nodes
  		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  			return;
  		}
  
  		// focus/blur morphs to focusin/out; ensure we're not firing them right now
  		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
  			return;
  		}
  
  		if ( type.indexOf(".") >= 0 ) {
  			// Namespaced trigger; create a regexp to match event type in handle()
  			namespaces = type.split(".");
  			type = namespaces.shift();
  			namespaces.sort();
  		}
  		ontype = type.indexOf(":") < 0 && "on" + type;
  
  		// Caller can pass in a jQuery.Event object, Object, or just an event type string
  		event = event[ jQuery.expando ] ?
  			event :
  			new jQuery.Event( type, typeof event === "object" && event );
  
  		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
  		event.isTrigger = onlyHandlers ? 2 : 3;
  		event.namespace = namespaces.join(".");
  		event.namespace_re = event.namespace ?
  			new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
  			null;
  
  		// Clean up the event in case it is being reused
  		event.result = undefined;
  		if ( !event.target ) {
  			event.target = elem;
  		}
  
  		// Clone any incoming data and prepend the event, creating the handler arg list
  		data = data == null ?
  			[ event ] :
  			jQuery.makeArray( data, [ event ] );
  
  		// Allow special events to draw outside the lines
  		special = jQuery.event.special[ type ] || {};
  		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
  			return;
  		}
  
  		// Determine event propagation path in advance, per W3C events spec (#9951)
  		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
  		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
  
  			bubbleType = special.delegateType || type;
  			if ( !rfocusMorph.test( bubbleType + type ) ) {
  				cur = cur.parentNode;
  			}
  			for ( ; cur; cur = cur.parentNode ) {
  				eventPath.push( cur );
  				tmp = cur;
  			}
  
  			// Only add window if we got to document (e.g., not plain obj or detached DOM)
  			if ( tmp === (elem.ownerDocument || document) ) {
  				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
  			}
  		}
  
  		// Fire handlers on the event path
  		i = 0;
  		while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
  
  			event.type = i > 1 ?
  				bubbleType :
  				special.bindType || type;
  
  			// jQuery handler
  			handle = ( data_priv.get( cur, "events" ) || {} )[ event.type ] && data_priv.get( cur, "handle" );
  			if ( handle ) {
  				handle.apply( cur, data );
  			}
  
  			// Native handler
  			handle = ontype && cur[ ontype ];
  			if ( handle && handle.apply && jQuery.acceptData( cur ) ) {
  				event.result = handle.apply( cur, data );
  				if ( event.result === false ) {
  					event.preventDefault();
  				}
  			}
  		}
  		event.type = type;
  
  		// If nobody prevented the default action, do it now
  		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
  
  			if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) &&
  				jQuery.acceptData( elem ) ) {
  
  				// Call a native DOM method on the target with the same name name as the event.
  				// Don't do default actions on window, that's where global variables be (#6170)
  				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
  
  					// Don't re-trigger an onFOO event when we call its FOO() method
  					tmp = elem[ ontype ];
  
  					if ( tmp ) {
  						elem[ ontype ] = null;
  					}
  
  					// Prevent re-triggering of the same event, since we already bubbled it above
  					jQuery.event.triggered = type;
  					elem[ type ]();
  					jQuery.event.triggered = undefined;
  
  					if ( tmp ) {
  						elem[ ontype ] = tmp;
  					}
  				}
  			}
  		}
  
  		return event.result;
  	},
  
  	dispatch: function( event ) {
  
  		// Make a writable jQuery.Event from the native event object
  		event = jQuery.event.fix( event );
  
  		var i, j, ret, matched, handleObj,
  			handlerQueue = [],
  			args = slice.call( arguments ),
  			handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [],
  			special = jQuery.event.special[ event.type ] || {};
  
  		// Use the fix-ed jQuery.Event rather than the (read-only) native event
  		args[0] = event;
  		event.delegateTarget = this;
  
  		// Call the preDispatch hook for the mapped type, and let it bail if desired
  		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
  			return;
  		}
  
  		// Determine handlers
  		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
  
  		// Run delegates first; they may want to stop propagation beneath us
  		i = 0;
  		while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
  			event.currentTarget = matched.elem;
  
  			j = 0;
  			while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
  
  				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
  				// a subset or equal to those in the bound event (both can have no namespace).
  				if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
  
  					event.handleObj = handleObj;
  					event.data = handleObj.data;
  
  					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
  							.apply( matched.elem, args );
  
  					if ( ret !== undefined ) {
  						if ( (event.result = ret) === false ) {
  							event.preventDefault();
  							event.stopPropagation();
  						}
  					}
  				}
  			}
  		}
  
  		// Call the postDispatch hook for the mapped type
  		if ( special.postDispatch ) {
  			special.postDispatch.call( this, event );
  		}
  
  		return event.result;
  	},
  
  	handlers: function( event, handlers ) {
  		var i, matches, sel, handleObj,
  			handlerQueue = [],
  			delegateCount = handlers.delegateCount,
  			cur = event.target;
  
  		// Find delegate handlers
  		// Black-hole SVG <use> instance trees (#13180)
  		// Avoid non-left-click bubbling in Firefox (#3861)
  		if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
  
  			for ( ; cur !== this; cur = cur.parentNode || this ) {
  
  				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
  				if ( cur.disabled !== true || event.type !== "click" ) {
  					matches = [];
  					for ( i = 0; i < delegateCount; i++ ) {
  						handleObj = handlers[ i ];
  
  						// Don't conflict with Object.prototype properties (#13203)
  						sel = handleObj.selector + " ";
  
  						if ( matches[ sel ] === undefined ) {
  							matches[ sel ] = handleObj.needsContext ?
  								jQuery( sel, this ).index( cur ) >= 0 :
  								jQuery.find( sel, this, null, [ cur ] ).length;
  						}
  						if ( matches[ sel ] ) {
  							matches.push( handleObj );
  						}
  					}
  					if ( matches.length ) {
  						handlerQueue.push({ elem: cur, handlers: matches });
  					}
  				}
  			}
  		}
  
  		// Add the remaining (directly-bound) handlers
  		if ( delegateCount < handlers.length ) {
  			handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
  		}
  
  		return handlerQueue;
  	},
  
  	// Includes some event props shared by KeyEvent and MouseEvent
  	props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
  
  	fixHooks: {},
  
  	keyHooks: {
  		props: "char charCode key keyCode".split(" "),
  		filter: function( event, original ) {
  
  			// Add which for key events
  			if ( event.which == null ) {
  				event.which = original.charCode != null ? original.charCode : original.keyCode;
  			}
  
  			return event;
  		}
  	},
  
  	mouseHooks: {
  		props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
  		filter: function( event, original ) {
  			var eventDoc, doc, body,
  				button = original.button;
  
  			// Calculate pageX/Y if missing and clientX/Y available
  			if ( event.pageX == null && original.clientX != null ) {
  				eventDoc = event.target.ownerDocument || document;
  				doc = eventDoc.documentElement;
  				body = eventDoc.body;
  
  				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
  				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
  			}
  
  			// Add which for click: 1 === left; 2 === middle; 3 === right
  			// Note: button is not normalized, so don't use it
  			if ( !event.which && button !== undefined ) {
  				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
  			}
  
  			return event;
  		}
  	},
  
  	fix: function( event ) {
  		if ( event[ jQuery.expando ] ) {
  			return event;
  		}
  
  		// Create a writable copy of the event object and normalize some properties
  		var i, prop, copy,
  			type = event.type,
  			originalEvent = event,
  			fixHook = this.fixHooks[ type ];
  
  		if ( !fixHook ) {
  			this.fixHooks[ type ] = fixHook =
  				rmouseEvent.test( type ) ? this.mouseHooks :
  				rkeyEvent.test( type ) ? this.keyHooks :
  				{};
  		}
  		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
  
  		event = new jQuery.Event( originalEvent );
  
  		i = copy.length;
  		while ( i-- ) {
  			prop = copy[ i ];
  			event[ prop ] = originalEvent[ prop ];
  		}
  
  		// Support: Cordova 2.5 (WebKit) (#13255)
  		// All events should have a target; Cordova deviceready doesn't
  		if ( !event.target ) {
  			event.target = document;
  		}
  
  		// Support: Safari 6.0+, Chrome<28
  		// Target should not be a text node (#504, #13143)
  		if ( event.target.nodeType === 3 ) {
  			event.target = event.target.parentNode;
  		}
  
  		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
  	},
  
  	special: {
  		load: {
  			// Prevent triggered image.load events from bubbling to window.load
  			noBubble: true
  		},
  		focus: {
  			// Fire native event if possible so blur/focus sequence is correct
  			trigger: function() {
  				if ( this !== safeActiveElement() && this.focus ) {
  					this.focus();
  					return false;
  				}
  			},
  			delegateType: "focusin"
  		},
  		blur: {
  			trigger: function() {
  				if ( this === safeActiveElement() && this.blur ) {
  					this.blur();
  					return false;
  				}
  			},
  			delegateType: "focusout"
  		},
  		click: {
  			// For checkbox, fire native event so checked state will be right
  			trigger: function() {
  				if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
  					this.click();
  					return false;
  				}
  			},
  
  			// For cross-browser consistency, don't fire native .click() on links
  			_default: function( event ) {
  				return jQuery.nodeName( event.target, "a" );
  			}
  		},
  
  		beforeunload: {
  			postDispatch: function( event ) {
  
  				// Support: Firefox 20+
  				// Firefox doesn't alert if the returnValue field is not set.
  				if ( event.result !== undefined && event.originalEvent ) {
  					event.originalEvent.returnValue = event.result;
  				}
  			}
  		}
  	},
  
  	simulate: function( type, elem, event, bubble ) {
  		// Piggyback on a donor event to simulate a different one.
  		// Fake originalEvent to avoid donor's stopPropagation, but if the
  		// simulated event prevents default then we do the same on the donor.
  		var e = jQuery.extend(
  			new jQuery.Event(),
  			event,
  			{
  				type: type,
  				isSimulated: true,
  				originalEvent: {}
  			}
  		);
  		if ( bubble ) {
  			jQuery.event.trigger( e, null, elem );
  		} else {
  			jQuery.event.dispatch.call( elem, e );
  		}
  		if ( e.isDefaultPrevented() ) {
  			event.preventDefault();
  		}
  	}
  };
  
  jQuery.removeEvent = function( elem, type, handle ) {
  	if ( elem.removeEventListener ) {
  		elem.removeEventListener( type, handle, false );
  	}
  };
  
  jQuery.Event = function( src, props ) {
  	// Allow instantiation without the 'new' keyword
  	if ( !(this instanceof jQuery.Event) ) {
  		return new jQuery.Event( src, props );
  	}
  
  	// Event object
  	if ( src && src.type ) {
  		this.originalEvent = src;
  		this.type = src.type;
  
  		// Events bubbling up the document may have been marked as prevented
  		// by a handler lower down the tree; reflect the correct value.
  		this.isDefaultPrevented = src.defaultPrevented ||
  				src.defaultPrevented === undefined &&
  				// Support: Android<4.0
  				src.returnValue === false ?
  			returnTrue :
  			returnFalse;
  
  	// Event type
  	} else {
  		this.type = src;
  	}
  
  	// Put explicitly provided properties onto the event object
  	if ( props ) {
  		jQuery.extend( this, props );
  	}
  
  	// Create a timestamp if incoming event doesn't have one
  	this.timeStamp = src && src.timeStamp || jQuery.now();
  
  	// Mark it as fixed
  	this[ jQuery.expando ] = true;
  };
  
  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
  jQuery.Event.prototype = {
  	isDefaultPrevented: returnFalse,
  	isPropagationStopped: returnFalse,
  	isImmediatePropagationStopped: returnFalse,
  
  	preventDefault: function() {
  		var e = this.originalEvent;
  
  		this.isDefaultPrevented = returnTrue;
  
  		if ( e && e.preventDefault ) {
  			e.preventDefault();
  		}
  	},
  	stopPropagation: function() {
  		var e = this.originalEvent;
  
  		this.isPropagationStopped = returnTrue;
  
  		if ( e && e.stopPropagation ) {
  			e.stopPropagation();
  		}
  	},
  	stopImmediatePropagation: function() {
  		var e = this.originalEvent;
  
  		this.isImmediatePropagationStopped = returnTrue;
  
  		if ( e && e.stopImmediatePropagation ) {
  			e.stopImmediatePropagation();
  		}
  
  		this.stopPropagation();
  	}
  };
  
  // Create mouseenter/leave events using mouseover/out and event-time checks
  // Support: Chrome 15+
  jQuery.each({
  	mouseenter: "mouseover",
  	mouseleave: "mouseout",
  	pointerenter: "pointerover",
  	pointerleave: "pointerout"
  }, function( orig, fix ) {
  	jQuery.event.special[ orig ] = {
  		delegateType: fix,
  		bindType: fix,
  
  		handle: function( event ) {
  			var ret,
  				target = this,
  				related = event.relatedTarget,
  				handleObj = event.handleObj;
  
  			// For mousenter/leave call the handler if related is outside the target.
  			// NB: No relatedTarget if the mouse left/entered the browser window
  			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
  				event.type = handleObj.origType;
  				ret = handleObj.handler.apply( this, arguments );
  				event.type = fix;
  			}
  			return ret;
  		}
  	};
  });
  
  // Support: Firefox, Chrome, Safari
  // Create "bubbling" focus and blur events
  if ( !support.focusinBubbles ) {
  	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
  
  		// Attach a single capturing handler on the document while someone wants focusin/focusout
  		var handler = function( event ) {
  				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
  			};
  
  		jQuery.event.special[ fix ] = {
  			setup: function() {
  				var doc = this.ownerDocument || this,
  					attaches = data_priv.access( doc, fix );
  
  				if ( !attaches ) {
  					doc.addEventListener( orig, handler, true );
  				}
  				data_priv.access( doc, fix, ( attaches || 0 ) + 1 );
  			},
  			teardown: function() {
  				var doc = this.ownerDocument || this,
  					attaches = data_priv.access( doc, fix ) - 1;
  
  				if ( !attaches ) {
  					doc.removeEventListener( orig, handler, true );
  					data_priv.remove( doc, fix );
  
  				} else {
  					data_priv.access( doc, fix, attaches );
  				}
  			}
  		};
  	});
  }
  
  jQuery.fn.extend({
  
  	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
  		var origFn, type;
  
  		// Types can be a map of types/handlers
  		if ( typeof types === "object" ) {
  			// ( types-Object, selector, data )
  			if ( typeof selector !== "string" ) {
  				// ( types-Object, data )
  				data = data || selector;
  				selector = undefined;
  			}
  			for ( type in types ) {
  				this.on( type, selector, data, types[ type ], one );
  			}
  			return this;
  		}
  
  		if ( data == null && fn == null ) {
  			// ( types, fn )
  			fn = selector;
  			data = selector = undefined;
  		} else if ( fn == null ) {
  			if ( typeof selector === "string" ) {
  				// ( types, selector, fn )
  				fn = data;
  				data = undefined;
  			} else {
  				// ( types, data, fn )
  				fn = data;
  				data = selector;
  				selector = undefined;
  			}
  		}
  		if ( fn === false ) {
  			fn = returnFalse;
  		} else if ( !fn ) {
  			return this;
  		}
  
  		if ( one === 1 ) {
  			origFn = fn;
  			fn = function( event ) {
  				// Can use an empty set, since event contains the info
  				jQuery().off( event );
  				return origFn.apply( this, arguments );
  			};
  			// Use same guid so caller can remove using origFn
  			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  		}
  		return this.each( function() {
  			jQuery.event.add( this, types, fn, data, selector );
  		});
  	},
  	one: function( types, selector, data, fn ) {
  		return this.on( types, selector, data, fn, 1 );
  	},
  	off: function( types, selector, fn ) {
  		var handleObj, type;
  		if ( types && types.preventDefault && types.handleObj ) {
  			// ( event )  dispatched jQuery.Event
  			handleObj = types.handleObj;
  			jQuery( types.delegateTarget ).off(
  				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
  				handleObj.selector,
  				handleObj.handler
  			);
  			return this;
  		}
  		if ( typeof types === "object" ) {
  			// ( types-object [, selector] )
  			for ( type in types ) {
  				this.off( type, selector, types[ type ] );
  			}
  			return this;
  		}
  		if ( selector === false || typeof selector === "function" ) {
  			// ( types [, fn] )
  			fn = selector;
  			selector = undefined;
  		}
  		if ( fn === false ) {
  			fn = returnFalse;
  		}
  		return this.each(function() {
  			jQuery.event.remove( this, types, fn, selector );
  		});
  	},
  
  	trigger: function( type, data ) {
  		return this.each(function() {
  			jQuery.event.trigger( type, data, this );
  		});
  	},
  	triggerHandler: function( type, data ) {
  		var elem = this[0];
  		if ( elem ) {
  			return jQuery.event.trigger( type, data, elem, true );
  		}
  	}
  });
  
  
  var
  	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
  	rtagName = /<([\w:]+)/,
  	rhtml = /<|&#?\w+;/,
  	rnoInnerhtml = /<(?:script|style|link)/i,
  	// checked="checked" or checked
  	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  	rscriptType = /^$|\/(?:java|ecma)script/i,
  	rscriptTypeMasked = /^true\/(.*)/,
  	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
  
  	// We have to close these tags to support XHTML (#13200)
  	wrapMap = {
  
  		// Support: IE9
  		option: [ 1, "<select multiple='multiple'>", "</select>" ],
  
  		thead: [ 1, "<table>", "</table>" ],
  		col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
  		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  
  		_default: [ 0, "", "" ]
  	};
  
  // Support: IE9
  wrapMap.optgroup = wrapMap.option;
  
  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  wrapMap.th = wrapMap.td;
  
  // Support: 1.x compatibility
  // Manipulating tables requires a tbody
  function manipulationTarget( elem, content ) {
  	return jQuery.nodeName( elem, "table" ) &&
  		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
  
  		elem.getElementsByTagName("tbody")[0] ||
  			elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
  		elem;
  }
  
  // Replace/restore the type attribute of script elements for safe DOM manipulation
  function disableScript( elem ) {
  	elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
  	return elem;
  }
  function restoreScript( elem ) {
  	var match = rscriptTypeMasked.exec( elem.type );
  
  	if ( match ) {
  		elem.type = match[ 1 ];
  	} else {
  		elem.removeAttribute("type");
  	}
  
  	return elem;
  }
  
  // Mark scripts as having already been evaluated
  function setGlobalEval( elems, refElements ) {
  	var i = 0,
  		l = elems.length;
  
  	for ( ; i < l; i++ ) {
  		data_priv.set(
  			elems[ i ], "globalEval", !refElements || data_priv.get( refElements[ i ], "globalEval" )
  		);
  	}
  }
  
  function cloneCopyEvent( src, dest ) {
  	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
  
  	if ( dest.nodeType !== 1 ) {
  		return;
  	}
  
  	// 1. Copy private data: events, handlers, etc.
  	if ( data_priv.hasData( src ) ) {
  		pdataOld = data_priv.access( src );
  		pdataCur = data_priv.set( dest, pdataOld );
  		events = pdataOld.events;
  
  		if ( events ) {
  			delete pdataCur.handle;
  			pdataCur.events = {};
  
  			for ( type in events ) {
  				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
  					jQuery.event.add( dest, type, events[ type ][ i ] );
  				}
  			}
  		}
  	}
  
  	// 2. Copy user data
  	if ( data_user.hasData( src ) ) {
  		udataOld = data_user.access( src );
  		udataCur = jQuery.extend( {}, udataOld );
  
  		data_user.set( dest, udataCur );
  	}
  }
  
  function getAll( context, tag ) {
  	var ret = context.getElementsByTagName ? context.getElementsByTagName( tag || "*" ) :
  			context.querySelectorAll ? context.querySelectorAll( tag || "*" ) :
  			[];
  
  	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
  		jQuery.merge( [ context ], ret ) :
  		ret;
  }
  
  // Fix IE bugs, see support tests
  function fixInput( src, dest ) {
  	var nodeName = dest.nodeName.toLowerCase();
  
  	// Fails to persist the checked state of a cloned checkbox or radio button.
  	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
  		dest.checked = src.checked;
  
  	// Fails to return the selected option to the default selected state when cloning options
  	} else if ( nodeName === "input" || nodeName === "textarea" ) {
  		dest.defaultValue = src.defaultValue;
  	}
  }
  
  jQuery.extend({
  	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
  		var i, l, srcElements, destElements,
  			clone = elem.cloneNode( true ),
  			inPage = jQuery.contains( elem.ownerDocument, elem );
  
  		// Fix IE cloning issues
  		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
  				!jQuery.isXMLDoc( elem ) ) {
  
  			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
  			destElements = getAll( clone );
  			srcElements = getAll( elem );
  
  			for ( i = 0, l = srcElements.length; i < l; i++ ) {
  				fixInput( srcElements[ i ], destElements[ i ] );
  			}
  		}
  
  		// Copy the events from the original to the clone
  		if ( dataAndEvents ) {
  			if ( deepDataAndEvents ) {
  				srcElements = srcElements || getAll( elem );
  				destElements = destElements || getAll( clone );
  
  				for ( i = 0, l = srcElements.length; i < l; i++ ) {
  					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
  				}
  			} else {
  				cloneCopyEvent( elem, clone );
  			}
  		}
  
  		// Preserve script evaluation history
  		destElements = getAll( clone, "script" );
  		if ( destElements.length > 0 ) {
  			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
  		}
  
  		// Return the cloned set
  		return clone;
  	},
  
  	buildFragment: function( elems, context, scripts, selection ) {
  		var elem, tmp, tag, wrap, contains, j,
  			fragment = context.createDocumentFragment(),
  			nodes = [],
  			i = 0,
  			l = elems.length;
  
  		for ( ; i < l; i++ ) {
  			elem = elems[ i ];
  
  			if ( elem || elem === 0 ) {
  
  				// Add nodes directly
  				if ( jQuery.type( elem ) === "object" ) {
  					// Support: QtWebKit, PhantomJS
  					// push.apply(_, arraylike) throws on ancient WebKit
  					jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
  
  				// Convert non-html into a text node
  				} else if ( !rhtml.test( elem ) ) {
  					nodes.push( context.createTextNode( elem ) );
  
  				// Convert html into DOM nodes
  				} else {
  					tmp = tmp || fragment.appendChild( context.createElement("div") );
  
  					// Deserialize a standard representation
  					tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
  					wrap = wrapMap[ tag ] || wrapMap._default;
  					tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[ 2 ];
  
  					// Descend through wrappers to the right content
  					j = wrap[ 0 ];
  					while ( j-- ) {
  						tmp = tmp.lastChild;
  					}
  
  					// Support: QtWebKit, PhantomJS
  					// push.apply(_, arraylike) throws on ancient WebKit
  					jQuery.merge( nodes, tmp.childNodes );
  
  					// Remember the top-level container
  					tmp = fragment.firstChild;
  
  					// Ensure the created nodes are orphaned (#12392)
  					tmp.textContent = "";
  				}
  			}
  		}
  
  		// Remove wrapper from fragment
  		fragment.textContent = "";
  
  		i = 0;
  		while ( (elem = nodes[ i++ ]) ) {
  
  			// #4087 - If origin and destination elements are the same, and this is
  			// that element, do not do anything
  			if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
  				continue;
  			}
  
  			contains = jQuery.contains( elem.ownerDocument, elem );
  
  			// Append to fragment
  			tmp = getAll( fragment.appendChild( elem ), "script" );
  
  			// Preserve script evaluation history
  			if ( contains ) {
  				setGlobalEval( tmp );
  			}
  
  			// Capture executables
  			if ( scripts ) {
  				j = 0;
  				while ( (elem = tmp[ j++ ]) ) {
  					if ( rscriptType.test( elem.type || "" ) ) {
  						scripts.push( elem );
  					}
  				}
  			}
  		}
  
  		return fragment;
  	},
  
  	cleanData: function( elems ) {
  		var data, elem, type, key,
  			special = jQuery.event.special,
  			i = 0;
  
  		for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
  			if ( jQuery.acceptData( elem ) ) {
  				key = elem[ data_priv.expando ];
  
  				if ( key && (data = data_priv.cache[ key ]) ) {
  					if ( data.events ) {
  						for ( type in data.events ) {
  							if ( special[ type ] ) {
  								jQuery.event.remove( elem, type );
  
  							// This is a shortcut to avoid jQuery.event.remove's overhead
  							} else {
  								jQuery.removeEvent( elem, type, data.handle );
  							}
  						}
  					}
  					if ( data_priv.cache[ key ] ) {
  						// Discard any remaining `private` data
  						delete data_priv.cache[ key ];
  					}
  				}
  			}
  			// Discard any remaining `user` data
  			delete data_user.cache[ elem[ data_user.expando ] ];
  		}
  	}
  });
  
  jQuery.fn.extend({
  	text: function( value ) {
  		return access( this, function( value ) {
  			return value === undefined ?
  				jQuery.text( this ) :
  				this.empty().each(function() {
  					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  						this.textContent = value;
  					}
  				});
  		}, null, value, arguments.length );
  	},
  
  	append: function() {
  		return this.domManip( arguments, function( elem ) {
  			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  				var target = manipulationTarget( this, elem );
  				target.appendChild( elem );
  			}
  		});
  	},
  
  	prepend: function() {
  		return this.domManip( arguments, function( elem ) {
  			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  				var target = manipulationTarget( this, elem );
  				target.insertBefore( elem, target.firstChild );
  			}
  		});
  	},
  
  	before: function() {
  		return this.domManip( arguments, function( elem ) {
  			if ( this.parentNode ) {
  				this.parentNode.insertBefore( elem, this );
  			}
  		});
  	},
  
  	after: function() {
  		return this.domManip( arguments, function( elem ) {
  			if ( this.parentNode ) {
  				this.parentNode.insertBefore( elem, this.nextSibling );
  			}
  		});
  	},
  
  	remove: function( selector, keepData /* Internal Use Only */ ) {
  		var elem,
  			elems = selector ? jQuery.filter( selector, this ) : this,
  			i = 0;
  
  		for ( ; (elem = elems[i]) != null; i++ ) {
  			if ( !keepData && elem.nodeType === 1 ) {
  				jQuery.cleanData( getAll( elem ) );
  			}
  
  			if ( elem.parentNode ) {
  				if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
  					setGlobalEval( getAll( elem, "script" ) );
  				}
  				elem.parentNode.removeChild( elem );
  			}
  		}
  
  		return this;
  	},
  
  	empty: function() {
  		var elem,
  			i = 0;
  
  		for ( ; (elem = this[i]) != null; i++ ) {
  			if ( elem.nodeType === 1 ) {
  
  				// Prevent memory leaks
  				jQuery.cleanData( getAll( elem, false ) );
  
  				// Remove any remaining nodes
  				elem.textContent = "";
  			}
  		}
  
  		return this;
  	},
  
  	clone: function( dataAndEvents, deepDataAndEvents ) {
  		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  
  		return this.map(function() {
  			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
  		});
  	},
  
  	html: function( value ) {
  		return access( this, function( value ) {
  			var elem = this[ 0 ] || {},
  				i = 0,
  				l = this.length;
  
  			if ( value === undefined && elem.nodeType === 1 ) {
  				return elem.innerHTML;
  			}
  
  			// See if we can take a shortcut and just use innerHTML
  			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
  				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
  
  				value = value.replace( rxhtmlTag, "<$1></$2>" );
  
  				try {
  					for ( ; i < l; i++ ) {
  						elem = this[ i ] || {};
  
  						// Remove element nodes and prevent memory leaks
  						if ( elem.nodeType === 1 ) {
  							jQuery.cleanData( getAll( elem, false ) );
  							elem.innerHTML = value;
  						}
  					}
  
  					elem = 0;
  
  				// If using innerHTML throws an exception, use the fallback method
  				} catch( e ) {}
  			}
  
  			if ( elem ) {
  				this.empty().append( value );
  			}
  		}, null, value, arguments.length );
  	},
  
  	replaceWith: function() {
  		var arg = arguments[ 0 ];
  
  		// Make the changes, replacing each context element with the new content
  		this.domManip( arguments, function( elem ) {
  			arg = this.parentNode;
  
  			jQuery.cleanData( getAll( this ) );
  
  			if ( arg ) {
  				arg.replaceChild( elem, this );
  			}
  		});
  
  		// Force removal if there was no new content (e.g., from empty arguments)
  		return arg && (arg.length || arg.nodeType) ? this : this.remove();
  	},
  
  	detach: function( selector ) {
  		return this.remove( selector, true );
  	},
  
  	domManip: function( args, callback ) {
  
  		// Flatten any nested arrays
  		args = concat.apply( [], args );
  
  		var fragment, first, scripts, hasScripts, node, doc,
  			i = 0,
  			l = this.length,
  			set = this,
  			iNoClone = l - 1,
  			value = args[ 0 ],
  			isFunction = jQuery.isFunction( value );
  
  		// We can't cloneNode fragments that contain checked, in WebKit
  		if ( isFunction ||
  				( l > 1 && typeof value === "string" &&
  					!support.checkClone && rchecked.test( value ) ) ) {
  			return this.each(function( index ) {
  				var self = set.eq( index );
  				if ( isFunction ) {
  					args[ 0 ] = value.call( this, index, self.html() );
  				}
  				self.domManip( args, callback );
  			});
  		}
  
  		if ( l ) {
  			fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
  			first = fragment.firstChild;
  
  			if ( fragment.childNodes.length === 1 ) {
  				fragment = first;
  			}
  
  			if ( first ) {
  				scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
  				hasScripts = scripts.length;
  
  				// Use the original fragment for the last item instead of the first because it can end up
  				// being emptied incorrectly in certain situations (#8070).
  				for ( ; i < l; i++ ) {
  					node = fragment;
  
  					if ( i !== iNoClone ) {
  						node = jQuery.clone( node, true, true );
  
  						// Keep references to cloned scripts for later restoration
  						if ( hasScripts ) {
  							// Support: QtWebKit
  							// jQuery.merge because push.apply(_, arraylike) throws
  							jQuery.merge( scripts, getAll( node, "script" ) );
  						}
  					}
  
  					callback.call( this[ i ], node, i );
  				}
  
  				if ( hasScripts ) {
  					doc = scripts[ scripts.length - 1 ].ownerDocument;
  
  					// Reenable scripts
  					jQuery.map( scripts, restoreScript );
  
  					// Evaluate executable scripts on first document insertion
  					for ( i = 0; i < hasScripts; i++ ) {
  						node = scripts[ i ];
  						if ( rscriptType.test( node.type || "" ) &&
  							!data_priv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
  
  							if ( node.src ) {
  								// Optional AJAX dependency, but won't run scripts if not present
  								if ( jQuery._evalUrl ) {
  									jQuery._evalUrl( node.src );
  								}
  							} else {
  								jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
  							}
  						}
  					}
  				}
  			}
  		}
  
  		return this;
  	}
  });
  
  jQuery.each({
  	appendTo: "append",
  	prependTo: "prepend",
  	insertBefore: "before",
  	insertAfter: "after",
  	replaceAll: "replaceWith"
  }, function( name, original ) {
  	jQuery.fn[ name ] = function( selector ) {
  		var elems,
  			ret = [],
  			insert = jQuery( selector ),
  			last = insert.length - 1,
  			i = 0;
  
  		for ( ; i <= last; i++ ) {
  			elems = i === last ? this : this.clone( true );
  			jQuery( insert[ i ] )[ original ]( elems );
  
  			// Support: QtWebKit
  			// .get() because push.apply(_, arraylike) throws
  			push.apply( ret, elems.get() );
  		}
  
  		return this.pushStack( ret );
  	};
  });
  
  
  var iframe,
  	elemdisplay = {};
  
  /**
   * Retrieve the actual display of a element
   * @param {String} name nodeName of the element
   * @param {Object} doc Document object
   */
  // Called only from within defaultDisplay
  function actualDisplay( name, doc ) {
  	var style,
  		elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
  
  		// getDefaultComputedStyle might be reliably used only on attached element
  		display = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ?
  
  			// Use of this method is a temporary fix (more like optimization) until something better comes along,
  			// since it was removed from specification and supported only in FF
  			style.display : jQuery.css( elem[ 0 ], "display" );
  
  	// We don't have any data stored on the element,
  	// so use "detach" method as fast way to get rid of the element
  	elem.detach();
  
  	return display;
  }
  
  /**
   * Try to determine the default display value of an element
   * @param {String} nodeName
   */
  function defaultDisplay( nodeName ) {
  	var doc = document,
  		display = elemdisplay[ nodeName ];
  
  	if ( !display ) {
  		display = actualDisplay( nodeName, doc );
  
  		// If the simple way fails, read from inside an iframe
  		if ( display === "none" || !display ) {
  
  			// Use the already-created iframe if possible
  			iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" )).appendTo( doc.documentElement );
  
  			// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
  			doc = iframe[ 0 ].contentDocument;
  
  			// Support: IE
  			doc.write();
  			doc.close();
  
  			display = actualDisplay( nodeName, doc );
  			iframe.detach();
  		}
  
  		// Store the correct default display
  		elemdisplay[ nodeName ] = display;
  	}
  
  	return display;
  }
  var rmargin = (/^margin/);
  
  var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
  
  var getStyles = function( elem ) {
  		// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
  		// IE throws on elements created in popups
  		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
  		if ( elem.ownerDocument.defaultView.opener ) {
  			return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
  		}
  
  		return window.getComputedStyle( elem, null );
  	};
  
  
  
  function curCSS( elem, name, computed ) {
  	var width, minWidth, maxWidth, ret,
  		style = elem.style;
  
  	computed = computed || getStyles( elem );
  
  	// Support: IE9
  	// getPropertyValue is only needed for .css('filter') (#12537)
  	if ( computed ) {
  		ret = computed.getPropertyValue( name ) || computed[ name ];
  	}
  
  	if ( computed ) {
  
  		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
  			ret = jQuery.style( elem, name );
  		}
  
  		// Support: iOS < 6
  		// A tribute to the "awesome hack by Dean Edwards"
  		// iOS < 6 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
  		// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
  		if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
  
  			// Remember the original values
  			width = style.width;
  			minWidth = style.minWidth;
  			maxWidth = style.maxWidth;
  
  			// Put in the new values to get a computed value out
  			style.minWidth = style.maxWidth = style.width = ret;
  			ret = computed.width;
  
  			// Revert the changed values
  			style.width = width;
  			style.minWidth = minWidth;
  			style.maxWidth = maxWidth;
  		}
  	}
  
  	return ret !== undefined ?
  		// Support: IE
  		// IE returns zIndex value as an integer.
  		ret + "" :
  		ret;
  }
  
  
  function addGetHookIf( conditionFn, hookFn ) {
  	// Define the hook, we'll check on the first run if it's really needed.
  	return {
  		get: function() {
  			if ( conditionFn() ) {
  				// Hook not needed (or it's not possible to use it due
  				// to missing dependency), remove it.
  				delete this.get;
  				return;
  			}
  
  			// Hook needed; redefine it so that the support test is not executed again.
  			return (this.get = hookFn).apply( this, arguments );
  		}
  	};
  }
  
  
  (function() {
  	var pixelPositionVal, boxSizingReliableVal,
  		docElem = document.documentElement,
  		container = document.createElement( "div" ),
  		div = document.createElement( "div" );
  
  	if ( !div.style ) {
  		return;
  	}
  
  	// Support: IE9-11+
  	// Style of cloned element affects source element cloned (#8908)
  	div.style.backgroundClip = "content-box";
  	div.cloneNode( true ).style.backgroundClip = "";
  	support.clearCloneStyle = div.style.backgroundClip === "content-box";
  
  	container.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;" +
  		"position:absolute";
  	container.appendChild( div );
  
  	// Executing both pixelPosition & boxSizingReliable tests require only one layout
  	// so they're executed at the same time to save the second computation.
  	function computePixelPositionAndBoxSizingReliable() {
  		div.style.cssText =
  			// Support: Firefox<29, Android 2.3
  			// Vendor-prefix box-sizing
  			"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" +
  			"box-sizing:border-box;display:block;margin-top:1%;top:1%;" +
  			"border:1px;padding:1px;width:4px;position:absolute";
  		div.innerHTML = "";
  		docElem.appendChild( container );
  
  		var divStyle = window.getComputedStyle( div, null );
  		pixelPositionVal = divStyle.top !== "1%";
  		boxSizingReliableVal = divStyle.width === "4px";
  
  		docElem.removeChild( container );
  	}
  
  	// Support: node.js jsdom
  	// Don't assume that getComputedStyle is a property of the global object
  	if ( window.getComputedStyle ) {
  		jQuery.extend( support, {
  			pixelPosition: function() {
  
  				// This test is executed only once but we still do memoizing
  				// since we can use the boxSizingReliable pre-computing.
  				// No need to check if the test was already performed, though.
  				computePixelPositionAndBoxSizingReliable();
  				return pixelPositionVal;
  			},
  			boxSizingReliable: function() {
  				if ( boxSizingReliableVal == null ) {
  					computePixelPositionAndBoxSizingReliable();
  				}
  				return boxSizingReliableVal;
  			},
  			reliableMarginRight: function() {
  
  				// Support: Android 2.3
  				// Check if div with explicit width and no margin-right incorrectly
  				// gets computed margin-right based on width of container. (#3333)
  				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  				// This support function is only executed once so no memoizing is needed.
  				var ret,
  					marginDiv = div.appendChild( document.createElement( "div" ) );
  
  				// Reset CSS: box-sizing; display; margin; border; padding
  				marginDiv.style.cssText = div.style.cssText =
  					// Support: Firefox<29, Android 2.3
  					// Vendor-prefix box-sizing
  					"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
  					"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
  				marginDiv.style.marginRight = marginDiv.style.width = "0";
  				div.style.width = "1px";
  				docElem.appendChild( container );
  
  				ret = !parseFloat( window.getComputedStyle( marginDiv, null ).marginRight );
  
  				docElem.removeChild( container );
  				div.removeChild( marginDiv );
  
  				return ret;
  			}
  		});
  	}
  })();
  
  
  // A method for quickly swapping in/out CSS properties to get correct calculations.
  jQuery.swap = function( elem, options, callback, args ) {
  	var ret, name,
  		old = {};
  
  	// Remember the old values, and insert the new ones
  	for ( name in options ) {
  		old[ name ] = elem.style[ name ];
  		elem.style[ name ] = options[ name ];
  	}
  
  	ret = callback.apply( elem, args || [] );
  
  	// Revert the old values
  	for ( name in options ) {
  		elem.style[ name ] = old[ name ];
  	}
  
  	return ret;
  };
  
  
  var
  	// Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
  	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  	rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
  	rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
  
  	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  	cssNormalTransform = {
  		letterSpacing: "0",
  		fontWeight: "400"
  	},
  
  	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
  
  // Return a css property mapped to a potentially vendor prefixed property
  function vendorPropName( style, name ) {
  
  	// Shortcut for names that are not vendor prefixed
  	if ( name in style ) {
  		return name;
  	}
  
  	// Check for vendor prefixed names
  	var capName = name[0].toUpperCase() + name.slice(1),
  		origName = name,
  		i = cssPrefixes.length;
  
  	while ( i-- ) {
  		name = cssPrefixes[ i ] + capName;
  		if ( name in style ) {
  			return name;
  		}
  	}
  
  	return origName;
  }
  
  function setPositiveNumber( elem, value, subtract ) {
  	var matches = rnumsplit.exec( value );
  	return matches ?
  		// Guard against undefined "subtract", e.g., when used as in cssHooks
  		Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
  		value;
  }
  
  function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
  	var i = extra === ( isBorderBox ? "border" : "content" ) ?
  		// If we already have the right measurement, avoid augmentation
  		4 :
  		// Otherwise initialize for horizontal or vertical properties
  		name === "width" ? 1 : 0,
  
  		val = 0;
  
  	for ( ; i < 4; i += 2 ) {
  		// Both box models exclude margin, so add it if we want it
  		if ( extra === "margin" ) {
  			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
  		}
  
  		if ( isBorderBox ) {
  			// border-box includes padding, so remove it if we want content
  			if ( extra === "content" ) {
  				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  			}
  
  			// At this point, extra isn't border nor margin, so remove border
  			if ( extra !== "margin" ) {
  				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  			}
  		} else {
  			// At this point, extra isn't content, so add padding
  			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  
  			// At this point, extra isn't content nor padding, so add border
  			if ( extra !== "padding" ) {
  				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  			}
  		}
  	}
  
  	return val;
  }
  
  function getWidthOrHeight( elem, name, extra ) {
  
  	// Start with offset property, which is equivalent to the border-box value
  	var valueIsBorderBox = true,
  		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
  		styles = getStyles( elem ),
  		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
  
  	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
  	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
  	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
  	if ( val <= 0 || val == null ) {
  		// Fall back to computed then uncomputed css if necessary
  		val = curCSS( elem, name, styles );
  		if ( val < 0 || val == null ) {
  			val = elem.style[ name ];
  		}
  
  		// Computed unit is not pixels. Stop here and return.
  		if ( rnumnonpx.test(val) ) {
  			return val;
  		}
  
  		// Check for style in case a browser which returns unreliable values
  		// for getComputedStyle silently falls back to the reliable elem.style
  		valueIsBorderBox = isBorderBox &&
  			( support.boxSizingReliable() || val === elem.style[ name ] );
  
  		// Normalize "", auto, and prepare for extra
  		val = parseFloat( val ) || 0;
  	}
  
  	// Use the active box-sizing model to add/subtract irrelevant styles
  	return ( val +
  		augmentWidthOrHeight(
  			elem,
  			name,
  			extra || ( isBorderBox ? "border" : "content" ),
  			valueIsBorderBox,
  			styles
  		)
  	) + "px";
  }
  
  function showHide( elements, show ) {
  	var display, elem, hidden,
  		values = [],
  		index = 0,
  		length = elements.length;
  
  	for ( ; index < length; index++ ) {
  		elem = elements[ index ];
  		if ( !elem.style ) {
  			continue;
  		}
  
  		values[ index ] = data_priv.get( elem, "olddisplay" );
  		display = elem.style.display;
  		if ( show ) {
  			// Reset the inline display of this element to learn if it is
  			// being hidden by cascaded rules or not
  			if ( !values[ index ] && display === "none" ) {
  				elem.style.display = "";
  			}
  
  			// Set elements which have been overridden with display: none
  			// in a stylesheet to whatever the default browser style is
  			// for such an element
  			if ( elem.style.display === "" && isHidden( elem ) ) {
  				values[ index ] = data_priv.access( elem, "olddisplay", defaultDisplay(elem.nodeName) );
  			}
  		} else {
  			hidden = isHidden( elem );
  
  			if ( display !== "none" || !hidden ) {
  				data_priv.set( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
  			}
  		}
  	}
  
  	// Set the display of most of the elements in a second loop
  	// to avoid the constant reflow
  	for ( index = 0; index < length; index++ ) {
  		elem = elements[ index ];
  		if ( !elem.style ) {
  			continue;
  		}
  		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
  			elem.style.display = show ? values[ index ] || "" : "none";
  		}
  	}
  
  	return elements;
  }
  
  jQuery.extend({
  
  	// Add in style property hooks for overriding the default
  	// behavior of getting and setting a style property
  	cssHooks: {
  		opacity: {
  			get: function( elem, computed ) {
  				if ( computed ) {
  
  					// We should always get a number back from opacity
  					var ret = curCSS( elem, "opacity" );
  					return ret === "" ? "1" : ret;
  				}
  			}
  		}
  	},
  
  	// Don't automatically add "px" to these possibly-unitless properties
  	cssNumber: {
  		"columnCount": true,
  		"fillOpacity": true,
  		"flexGrow": true,
  		"flexShrink": true,
  		"fontWeight": true,
  		"lineHeight": true,
  		"opacity": true,
  		"order": true,
  		"orphans": true,
  		"widows": true,
  		"zIndex": true,
  		"zoom": true
  	},
  
  	// Add in properties whose names you wish to fix before
  	// setting or getting the value
  	cssProps: {
  		"float": "cssFloat"
  	},
  
  	// Get and set the style property on a DOM Node
  	style: function( elem, name, value, extra ) {
  
  		// Don't set styles on text and comment nodes
  		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
  			return;
  		}
  
  		// Make sure that we're working with the right name
  		var ret, type, hooks,
  			origName = jQuery.camelCase( name ),
  			style = elem.style;
  
  		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
  
  		// Gets hook for the prefixed version, then unprefixed version
  		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  
  		// Check if we're setting a value
  		if ( value !== undefined ) {
  			type = typeof value;
  
  			// Convert "+=" or "-=" to relative numbers (#7345)
  			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
  				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
  				// Fixes bug #9237
  				type = "number";
  			}
  
  			// Make sure that null and NaN values aren't set (#7116)
  			if ( value == null || value !== value ) {
  				return;
  			}
  
  			// If a number, add 'px' to the (except for certain CSS properties)
  			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
  				value += "px";
  			}
  
  			// Support: IE9-11+
  			// background-* props affect original clone's values
  			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
  				style[ name ] = "inherit";
  			}
  
  			// If a hook was provided, use that value, otherwise just set the specified value
  			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
  				style[ name ] = value;
  			}
  
  		} else {
  			// If a hook was provided get the non-computed value from there
  			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
  				return ret;
  			}
  
  			// Otherwise just get the value from the style object
  			return style[ name ];
  		}
  	},
  
  	css: function( elem, name, extra, styles ) {
  		var val, num, hooks,
  			origName = jQuery.camelCase( name );
  
  		// Make sure that we're working with the right name
  		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
  
  		// Try prefixed name followed by the unprefixed name
  		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  
  		// If a hook was provided get the computed value from there
  		if ( hooks && "get" in hooks ) {
  			val = hooks.get( elem, true, extra );
  		}
  
  		// Otherwise, if a way to get the computed value exists, use that
  		if ( val === undefined ) {
  			val = curCSS( elem, name, styles );
  		}
  
  		// Convert "normal" to computed value
  		if ( val === "normal" && name in cssNormalTransform ) {
  			val = cssNormalTransform[ name ];
  		}
  
  		// Make numeric if forced or a qualifier was provided and val looks numeric
  		if ( extra === "" || extra ) {
  			num = parseFloat( val );
  			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
  		}
  		return val;
  	}
  });
  
  jQuery.each([ "height", "width" ], function( i, name ) {
  	jQuery.cssHooks[ name ] = {
  		get: function( elem, computed, extra ) {
  			if ( computed ) {
  
  				// Certain elements can have dimension info if we invisibly show them
  				// but it must have a current display style that would benefit
  				return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
  					jQuery.swap( elem, cssShow, function() {
  						return getWidthOrHeight( elem, name, extra );
  					}) :
  					getWidthOrHeight( elem, name, extra );
  			}
  		},
  
  		set: function( elem, value, extra ) {
  			var styles = extra && getStyles( elem );
  			return setPositiveNumber( elem, value, extra ?
  				augmentWidthOrHeight(
  					elem,
  					name,
  					extra,
  					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
  					styles
  				) : 0
  			);
  		}
  	};
  });
  
  // Support: Android 2.3
  jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
  	function( elem, computed ) {
  		if ( computed ) {
  			return jQuery.swap( elem, { "display": "inline-block" },
  				curCSS, [ elem, "marginRight" ] );
  		}
  	}
  );
  
  // These hooks are used by animate to expand properties
  jQuery.each({
  	margin: "",
  	padding: "",
  	border: "Width"
  }, function( prefix, suffix ) {
  	jQuery.cssHooks[ prefix + suffix ] = {
  		expand: function( value ) {
  			var i = 0,
  				expanded = {},
  
  				// Assumes a single number if not a string
  				parts = typeof value === "string" ? value.split(" ") : [ value ];
  
  			for ( ; i < 4; i++ ) {
  				expanded[ prefix + cssExpand[ i ] + suffix ] =
  					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
  			}
  
  			return expanded;
  		}
  	};
  
  	if ( !rmargin.test( prefix ) ) {
  		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
  	}
  });
  
  jQuery.fn.extend({
  	css: function( name, value ) {
  		return access( this, function( elem, name, value ) {
  			var styles, len,
  				map = {},
  				i = 0;
  
  			if ( jQuery.isArray( name ) ) {
  				styles = getStyles( elem );
  				len = name.length;
  
  				for ( ; i < len; i++ ) {
  					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
  				}
  
  				return map;
  			}
  
  			return value !== undefined ?
  				jQuery.style( elem, name, value ) :
  				jQuery.css( elem, name );
  		}, name, value, arguments.length > 1 );
  	},
  	show: function() {
  		return showHide( this, true );
  	},
  	hide: function() {
  		return showHide( this );
  	},
  	toggle: function( state ) {
  		if ( typeof state === "boolean" ) {
  			return state ? this.show() : this.hide();
  		}
  
  		return this.each(function() {
  			if ( isHidden( this ) ) {
  				jQuery( this ).show();
  			} else {
  				jQuery( this ).hide();
  			}
  		});
  	}
  });
  
  
  function Tween( elem, options, prop, end, easing ) {
  	return new Tween.prototype.init( elem, options, prop, end, easing );
  }
  jQuery.Tween = Tween;
  
  Tween.prototype = {
  	constructor: Tween,
  	init: function( elem, options, prop, end, easing, unit ) {
  		this.elem = elem;
  		this.prop = prop;
  		this.easing = easing || "swing";
  		this.options = options;
  		this.start = this.now = this.cur();
  		this.end = end;
  		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
  	},
  	cur: function() {
  		var hooks = Tween.propHooks[ this.prop ];
  
  		return hooks && hooks.get ?
  			hooks.get( this ) :
  			Tween.propHooks._default.get( this );
  	},
  	run: function( percent ) {
  		var eased,
  			hooks = Tween.propHooks[ this.prop ];
  
  		if ( this.options.duration ) {
  			this.pos = eased = jQuery.easing[ this.easing ](
  				percent, this.options.duration * percent, 0, 1, this.options.duration
  			);
  		} else {
  			this.pos = eased = percent;
  		}
  		this.now = ( this.end - this.start ) * eased + this.start;
  
  		if ( this.options.step ) {
  			this.options.step.call( this.elem, this.now, this );
  		}
  
  		if ( hooks && hooks.set ) {
  			hooks.set( this );
  		} else {
  			Tween.propHooks._default.set( this );
  		}
  		return this;
  	}
  };
  
  Tween.prototype.init.prototype = Tween.prototype;
  
  Tween.propHooks = {
  	_default: {
  		get: function( tween ) {
  			var result;
  
  			if ( tween.elem[ tween.prop ] != null &&
  				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
  				return tween.elem[ tween.prop ];
  			}
  
  			// Passing an empty string as a 3rd parameter to .css will automatically
  			// attempt a parseFloat and fallback to a string if the parse fails.
  			// Simple values such as "10px" are parsed to Float;
  			// complex values such as "rotate(1rad)" are returned as-is.
  			result = jQuery.css( tween.elem, tween.prop, "" );
  			// Empty strings, null, undefined and "auto" are converted to 0.
  			return !result || result === "auto" ? 0 : result;
  		},
  		set: function( tween ) {
  			// Use step hook for back compat.
  			// Use cssHook if its there.
  			// Use .style if available and use plain properties where available.
  			if ( jQuery.fx.step[ tween.prop ] ) {
  				jQuery.fx.step[ tween.prop ]( tween );
  			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
  				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
  			} else {
  				tween.elem[ tween.prop ] = tween.now;
  			}
  		}
  	}
  };
  
  // Support: IE9
  // Panic based approach to setting things on disconnected nodes
  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  	set: function( tween ) {
  		if ( tween.elem.nodeType && tween.elem.parentNode ) {
  			tween.elem[ tween.prop ] = tween.now;
  		}
  	}
  };
  
  jQuery.easing = {
  	linear: function( p ) {
  		return p;
  	},
  	swing: function( p ) {
  		return 0.5 - Math.cos( p * Math.PI ) / 2;
  	}
  };
  
  jQuery.fx = Tween.prototype.init;
  
  // Back Compat <1.8 extension point
  jQuery.fx.step = {};
  
  
  
  
  var
  	fxNow, timerId,
  	rfxtypes = /^(?:toggle|show|hide)$/,
  	rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
  	rrun = /queueHooks$/,
  	animationPrefilters = [ defaultPrefilter ],
  	tweeners = {
  		"*": [ function( prop, value ) {
  			var tween = this.createTween( prop, value ),
  				target = tween.cur(),
  				parts = rfxnum.exec( value ),
  				unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
  
  				// Starting value computation is required for potential unit mismatches
  				start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
  					rfxnum.exec( jQuery.css( tween.elem, prop ) ),
  				scale = 1,
  				maxIterations = 20;
  
  			if ( start && start[ 3 ] !== unit ) {
  				// Trust units reported by jQuery.css
  				unit = unit || start[ 3 ];
  
  				// Make sure we update the tween properties later on
  				parts = parts || [];
  
  				// Iteratively approximate from a nonzero starting point
  				start = +target || 1;
  
  				do {
  					// If previous iteration zeroed out, double until we get *something*.
  					// Use string for doubling so we don't accidentally see scale as unchanged below
  					scale = scale || ".5";
  
  					// Adjust and apply
  					start = start / scale;
  					jQuery.style( tween.elem, prop, start + unit );
  
  				// Update scale, tolerating zero or NaN from tween.cur(),
  				// break the loop if scale is unchanged or perfect, or if we've just had enough
  				} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
  			}
  
  			// Update tween properties
  			if ( parts ) {
  				start = tween.start = +start || +target || 0;
  				tween.unit = unit;
  				// If a +=/-= token was provided, we're doing a relative animation
  				tween.end = parts[ 1 ] ?
  					start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
  					+parts[ 2 ];
  			}
  
  			return tween;
  		} ]
  	};
  
  // Animations created synchronously will run synchronously
  function createFxNow() {
  	setTimeout(function() {
  		fxNow = undefined;
  	});
  	return ( fxNow = jQuery.now() );
  }
  
  // Generate parameters to create a standard animation
  function genFx( type, includeWidth ) {
  	var which,
  		i = 0,
  		attrs = { height: type };
  
  	// If we include width, step value is 1 to do all cssExpand values,
  	// otherwise step value is 2 to skip over Left and Right
  	includeWidth = includeWidth ? 1 : 0;
  	for ( ; i < 4 ; i += 2 - includeWidth ) {
  		which = cssExpand[ i ];
  		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
  	}
  
  	if ( includeWidth ) {
  		attrs.opacity = attrs.width = type;
  	}
  
  	return attrs;
  }
  
  function createTween( value, prop, animation ) {
  	var tween,
  		collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
  		index = 0,
  		length = collection.length;
  	for ( ; index < length; index++ ) {
  		if ( (tween = collection[ index ].call( animation, prop, value )) ) {
  
  			// We're done with this property
  			return tween;
  		}
  	}
  }
  
  function defaultPrefilter( elem, props, opts ) {
  	/* jshint validthis: true */
  	var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
  		anim = this,
  		orig = {},
  		style = elem.style,
  		hidden = elem.nodeType && isHidden( elem ),
  		dataShow = data_priv.get( elem, "fxshow" );
  
  	// Handle queue: false promises
  	if ( !opts.queue ) {
  		hooks = jQuery._queueHooks( elem, "fx" );
  		if ( hooks.unqueued == null ) {
  			hooks.unqueued = 0;
  			oldfire = hooks.empty.fire;
  			hooks.empty.fire = function() {
  				if ( !hooks.unqueued ) {
  					oldfire();
  				}
  			};
  		}
  		hooks.unqueued++;
  
  		anim.always(function() {
  			// Ensure the complete handler is called before this completes
  			anim.always(function() {
  				hooks.unqueued--;
  				if ( !jQuery.queue( elem, "fx" ).length ) {
  					hooks.empty.fire();
  				}
  			});
  		});
  	}
  
  	// Height/width overflow pass
  	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
  		// Make sure that nothing sneaks out
  		// Record all 3 overflow attributes because IE9-10 do not
  		// change the overflow attribute when overflowX and
  		// overflowY are set to the same value
  		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
  
  		// Set display property to inline-block for height/width
  		// animations on inline elements that are having width/height animated
  		display = jQuery.css( elem, "display" );
  
  		// Test default display if display is currently "none"
  		checkDisplay = display === "none" ?
  			data_priv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
  
  		if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
  			style.display = "inline-block";
  		}
  	}
  
  	if ( opts.overflow ) {
  		style.overflow = "hidden";
  		anim.always(function() {
  			style.overflow = opts.overflow[ 0 ];
  			style.overflowX = opts.overflow[ 1 ];
  			style.overflowY = opts.overflow[ 2 ];
  		});
  	}
  
  	// show/hide pass
  	for ( prop in props ) {
  		value = props[ prop ];
  		if ( rfxtypes.exec( value ) ) {
  			delete props[ prop ];
  			toggle = toggle || value === "toggle";
  			if ( value === ( hidden ? "hide" : "show" ) ) {
  
  				// If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
  				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
  					hidden = true;
  				} else {
  					continue;
  				}
  			}
  			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
  
  		// Any non-fx value stops us from restoring the original display value
  		} else {
  			display = undefined;
  		}
  	}
  
  	if ( !jQuery.isEmptyObject( orig ) ) {
  		if ( dataShow ) {
  			if ( "hidden" in dataShow ) {
  				hidden = dataShow.hidden;
  			}
  		} else {
  			dataShow = data_priv.access( elem, "fxshow", {} );
  		}
  
  		// Store state if its toggle - enables .stop().toggle() to "reverse"
  		if ( toggle ) {
  			dataShow.hidden = !hidden;
  		}
  		if ( hidden ) {
  			jQuery( elem ).show();
  		} else {
  			anim.done(function() {
  				jQuery( elem ).hide();
  			});
  		}
  		anim.done(function() {
  			var prop;
  
  			data_priv.remove( elem, "fxshow" );
  			for ( prop in orig ) {
  				jQuery.style( elem, prop, orig[ prop ] );
  			}
  		});
  		for ( prop in orig ) {
  			tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
  
  			if ( !( prop in dataShow ) ) {
  				dataShow[ prop ] = tween.start;
  				if ( hidden ) {
  					tween.end = tween.start;
  					tween.start = prop === "width" || prop === "height" ? 1 : 0;
  				}
  			}
  		}
  
  	// If this is a noop like .hide().hide(), restore an overwritten display value
  	} else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
  		style.display = display;
  	}
  }
  
  function propFilter( props, specialEasing ) {
  	var index, name, easing, value, hooks;
  
  	// camelCase, specialEasing and expand cssHook pass
  	for ( index in props ) {
  		name = jQuery.camelCase( index );
  		easing = specialEasing[ name ];
  		value = props[ index ];
  		if ( jQuery.isArray( value ) ) {
  			easing = value[ 1 ];
  			value = props[ index ] = value[ 0 ];
  		}
  
  		if ( index !== name ) {
  			props[ name ] = value;
  			delete props[ index ];
  		}
  
  		hooks = jQuery.cssHooks[ name ];
  		if ( hooks && "expand" in hooks ) {
  			value = hooks.expand( value );
  			delete props[ name ];
  
  			// Not quite $.extend, this won't overwrite existing keys.
  			// Reusing 'index' because we have the correct "name"
  			for ( index in value ) {
  				if ( !( index in props ) ) {
  					props[ index ] = value[ index ];
  					specialEasing[ index ] = easing;
  				}
  			}
  		} else {
  			specialEasing[ name ] = easing;
  		}
  	}
  }
  
  function Animation( elem, properties, options ) {
  	var result,
  		stopped,
  		index = 0,
  		length = animationPrefilters.length,
  		deferred = jQuery.Deferred().always( function() {
  			// Don't match elem in the :animated selector
  			delete tick.elem;
  		}),
  		tick = function() {
  			if ( stopped ) {
  				return false;
  			}
  			var currentTime = fxNow || createFxNow(),
  				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
  				// Support: Android 2.3
  				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
  				temp = remaining / animation.duration || 0,
  				percent = 1 - temp,
  				index = 0,
  				length = animation.tweens.length;
  
  			for ( ; index < length ; index++ ) {
  				animation.tweens[ index ].run( percent );
  			}
  
  			deferred.notifyWith( elem, [ animation, percent, remaining ]);
  
  			if ( percent < 1 && length ) {
  				return remaining;
  			} else {
  				deferred.resolveWith( elem, [ animation ] );
  				return false;
  			}
  		},
  		animation = deferred.promise({
  			elem: elem,
  			props: jQuery.extend( {}, properties ),
  			opts: jQuery.extend( true, { specialEasing: {} }, options ),
  			originalProperties: properties,
  			originalOptions: options,
  			startTime: fxNow || createFxNow(),
  			duration: options.duration,
  			tweens: [],
  			createTween: function( prop, end ) {
  				var tween = jQuery.Tween( elem, animation.opts, prop, end,
  						animation.opts.specialEasing[ prop ] || animation.opts.easing );
  				animation.tweens.push( tween );
  				return tween;
  			},
  			stop: function( gotoEnd ) {
  				var index = 0,
  					// If we are going to the end, we want to run all the tweens
  					// otherwise we skip this part
  					length = gotoEnd ? animation.tweens.length : 0;
  				if ( stopped ) {
  					return this;
  				}
  				stopped = true;
  				for ( ; index < length ; index++ ) {
  					animation.tweens[ index ].run( 1 );
  				}
  
  				// Resolve when we played the last frame; otherwise, reject
  				if ( gotoEnd ) {
  					deferred.resolveWith( elem, [ animation, gotoEnd ] );
  				} else {
  					deferred.rejectWith( elem, [ animation, gotoEnd ] );
  				}
  				return this;
  			}
  		}),
  		props = animation.props;
  
  	propFilter( props, animation.opts.specialEasing );
  
  	for ( ; index < length ; index++ ) {
  		result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
  		if ( result ) {
  			return result;
  		}
  	}
  
  	jQuery.map( props, createTween, animation );
  
  	if ( jQuery.isFunction( animation.opts.start ) ) {
  		animation.opts.start.call( elem, animation );
  	}
  
  	jQuery.fx.timer(
  		jQuery.extend( tick, {
  			elem: elem,
  			anim: animation,
  			queue: animation.opts.queue
  		})
  	);
  
  	// attach callbacks from options
  	return animation.progress( animation.opts.progress )
  		.done( animation.opts.done, animation.opts.complete )
  		.fail( animation.opts.fail )
  		.always( animation.opts.always );
  }
  
  jQuery.Animation = jQuery.extend( Animation, {
  
  	tweener: function( props, callback ) {
  		if ( jQuery.isFunction( props ) ) {
  			callback = props;
  			props = [ "*" ];
  		} else {
  			props = props.split(" ");
  		}
  
  		var prop,
  			index = 0,
  			length = props.length;
  
  		for ( ; index < length ; index++ ) {
  			prop = props[ index ];
  			tweeners[ prop ] = tweeners[ prop ] || [];
  			tweeners[ prop ].unshift( callback );
  		}
  	},
  
  	prefilter: function( callback, prepend ) {
  		if ( prepend ) {
  			animationPrefilters.unshift( callback );
  		} else {
  			animationPrefilters.push( callback );
  		}
  	}
  });
  
  jQuery.speed = function( speed, easing, fn ) {
  	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
  		complete: fn || !fn && easing ||
  			jQuery.isFunction( speed ) && speed,
  		duration: speed,
  		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
  	};
  
  	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
  		opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
  
  	// Normalize opt.queue - true/undefined/null -> "fx"
  	if ( opt.queue == null || opt.queue === true ) {
  		opt.queue = "fx";
  	}
  
  	// Queueing
  	opt.old = opt.complete;
  
  	opt.complete = function() {
  		if ( jQuery.isFunction( opt.old ) ) {
  			opt.old.call( this );
  		}
  
  		if ( opt.queue ) {
  			jQuery.dequeue( this, opt.queue );
  		}
  	};
  
  	return opt;
  };
  
  jQuery.fn.extend({
  	fadeTo: function( speed, to, easing, callback ) {
  
  		// Show any hidden elements after setting opacity to 0
  		return this.filter( isHidden ).css( "opacity", 0 ).show()
  
  			// Animate to the value specified
  			.end().animate({ opacity: to }, speed, easing, callback );
  	},
  	animate: function( prop, speed, easing, callback ) {
  		var empty = jQuery.isEmptyObject( prop ),
  			optall = jQuery.speed( speed, easing, callback ),
  			doAnimation = function() {
  				// Operate on a copy of prop so per-property easing won't be lost
  				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
  
  				// Empty animations, or finishing resolves immediately
  				if ( empty || data_priv.get( this, "finish" ) ) {
  					anim.stop( true );
  				}
  			};
  			doAnimation.finish = doAnimation;
  
  		return empty || optall.queue === false ?
  			this.each( doAnimation ) :
  			this.queue( optall.queue, doAnimation );
  	},
  	stop: function( type, clearQueue, gotoEnd ) {
  		var stopQueue = function( hooks ) {
  			var stop = hooks.stop;
  			delete hooks.stop;
  			stop( gotoEnd );
  		};
  
  		if ( typeof type !== "string" ) {
  			gotoEnd = clearQueue;
  			clearQueue = type;
  			type = undefined;
  		}
  		if ( clearQueue && type !== false ) {
  			this.queue( type || "fx", [] );
  		}
  
  		return this.each(function() {
  			var dequeue = true,
  				index = type != null && type + "queueHooks",
  				timers = jQuery.timers,
  				data = data_priv.get( this );
  
  			if ( index ) {
  				if ( data[ index ] && data[ index ].stop ) {
  					stopQueue( data[ index ] );
  				}
  			} else {
  				for ( index in data ) {
  					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
  						stopQueue( data[ index ] );
  					}
  				}
  			}
  
  			for ( index = timers.length; index--; ) {
  				if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
  					timers[ index ].anim.stop( gotoEnd );
  					dequeue = false;
  					timers.splice( index, 1 );
  				}
  			}
  
  			// Start the next in the queue if the last step wasn't forced.
  			// Timers currently will call their complete callbacks, which
  			// will dequeue but only if they were gotoEnd.
  			if ( dequeue || !gotoEnd ) {
  				jQuery.dequeue( this, type );
  			}
  		});
  	},
  	finish: function( type ) {
  		if ( type !== false ) {
  			type = type || "fx";
  		}
  		return this.each(function() {
  			var index,
  				data = data_priv.get( this ),
  				queue = data[ type + "queue" ],
  				hooks = data[ type + "queueHooks" ],
  				timers = jQuery.timers,
  				length = queue ? queue.length : 0;
  
  			// Enable finishing flag on private data
  			data.finish = true;
  
  			// Empty the queue first
  			jQuery.queue( this, type, [] );
  
  			if ( hooks && hooks.stop ) {
  				hooks.stop.call( this, true );
  			}
  
  			// Look for any active animations, and finish them
  			for ( index = timers.length; index--; ) {
  				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
  					timers[ index ].anim.stop( true );
  					timers.splice( index, 1 );
  				}
  			}
  
  			// Look for any animations in the old queue and finish them
  			for ( index = 0; index < length; index++ ) {
  				if ( queue[ index ] && queue[ index ].finish ) {
  					queue[ index ].finish.call( this );
  				}
  			}
  
  			// Turn off finishing flag
  			delete data.finish;
  		});
  	}
  });
  
  jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
  	var cssFn = jQuery.fn[ name ];
  	jQuery.fn[ name ] = function( speed, easing, callback ) {
  		return speed == null || typeof speed === "boolean" ?
  			cssFn.apply( this, arguments ) :
  			this.animate( genFx( name, true ), speed, easing, callback );
  	};
  });
  
  // Generate shortcuts for custom animations
  jQuery.each({
  	slideDown: genFx("show"),
  	slideUp: genFx("hide"),
  	slideToggle: genFx("toggle"),
  	fadeIn: { opacity: "show" },
  	fadeOut: { opacity: "hide" },
  	fadeToggle: { opacity: "toggle" }
  }, function( name, props ) {
  	jQuery.fn[ name ] = function( speed, easing, callback ) {
  		return this.animate( props, speed, easing, callback );
  	};
  });
  
  jQuery.timers = [];
  jQuery.fx.tick = function() {
  	var timer,
  		i = 0,
  		timers = jQuery.timers;
  
  	fxNow = jQuery.now();
  
  	for ( ; i < timers.length; i++ ) {
  		timer = timers[ i ];
  		// Checks the timer has not already been removed
  		if ( !timer() && timers[ i ] === timer ) {
  			timers.splice( i--, 1 );
  		}
  	}
  
  	if ( !timers.length ) {
  		jQuery.fx.stop();
  	}
  	fxNow = undefined;
  };
  
  jQuery.fx.timer = function( timer ) {
  	jQuery.timers.push( timer );
  	if ( timer() ) {
  		jQuery.fx.start();
  	} else {
  		jQuery.timers.pop();
  	}
  };
  
  jQuery.fx.interval = 13;
  
  jQuery.fx.start = function() {
  	if ( !timerId ) {
  		timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
  	}
  };
  
  jQuery.fx.stop = function() {
  	clearInterval( timerId );
  	timerId = null;
  };
  
  jQuery.fx.speeds = {
  	slow: 600,
  	fast: 200,
  	// Default speed
  	_default: 400
  };
  
  
  // Based off of the plugin by Clint Helfers, with permission.
  // http://blindsignals.com/index.php/2009/07/jquery-delay/
  jQuery.fn.delay = function( time, type ) {
  	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
  	type = type || "fx";
  
  	return this.queue( type, function( next, hooks ) {
  		var timeout = setTimeout( next, time );
  		hooks.stop = function() {
  			clearTimeout( timeout );
  		};
  	});
  };
  
  
  (function() {
  	var input = document.createElement( "input" ),
  		select = document.createElement( "select" ),
  		opt = select.appendChild( document.createElement( "option" ) );
  
  	input.type = "checkbox";
  
  	// Support: iOS<=5.1, Android<=4.2+
  	// Default value for a checkbox should be "on"
  	support.checkOn = input.value !== "";
  
  	// Support: IE<=11+
  	// Must access selectedIndex to make default options select
  	support.optSelected = opt.selected;
  
  	// Support: Android<=2.3
  	// Options inside disabled selects are incorrectly marked as disabled
  	select.disabled = true;
  	support.optDisabled = !opt.disabled;
  
  	// Support: IE<=11+
  	// An input loses its value after becoming a radio
  	input = document.createElement( "input" );
  	input.value = "t";
  	input.type = "radio";
  	support.radioValue = input.value === "t";
  })();
  
  
  var nodeHook, boolHook,
  	attrHandle = jQuery.expr.attrHandle;
  
  jQuery.fn.extend({
  	attr: function( name, value ) {
  		return access( this, jQuery.attr, name, value, arguments.length > 1 );
  	},
  
  	removeAttr: function( name ) {
  		return this.each(function() {
  			jQuery.removeAttr( this, name );
  		});
  	}
  });
  
  jQuery.extend({
  	attr: function( elem, name, value ) {
  		var hooks, ret,
  			nType = elem.nodeType;
  
  		// don't get/set attributes on text, comment and attribute nodes
  		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  			return;
  		}
  
  		// Fallback to prop when attributes are not supported
  		if ( typeof elem.getAttribute === strundefined ) {
  			return jQuery.prop( elem, name, value );
  		}
  
  		// All attributes are lowercase
  		// Grab necessary hook if one is defined
  		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
  			name = name.toLowerCase();
  			hooks = jQuery.attrHooks[ name ] ||
  				( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
  		}
  
  		if ( value !== undefined ) {
  
  			if ( value === null ) {
  				jQuery.removeAttr( elem, name );
  
  			} else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
  				return ret;
  
  			} else {
  				elem.setAttribute( name, value + "" );
  				return value;
  			}
  
  		} else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
  			return ret;
  
  		} else {
  			ret = jQuery.find.attr( elem, name );
  
  			// Non-existent attributes return null, we normalize to undefined
  			return ret == null ?
  				undefined :
  				ret;
  		}
  	},
  
  	removeAttr: function( elem, value ) {
  		var name, propName,
  			i = 0,
  			attrNames = value && value.match( rnotwhite );
  
  		if ( attrNames && elem.nodeType === 1 ) {
  			while ( (name = attrNames[i++]) ) {
  				propName = jQuery.propFix[ name ] || name;
  
  				// Boolean attributes get special treatment (#10870)
  				if ( jQuery.expr.match.bool.test( name ) ) {
  					// Set corresponding property to false
  					elem[ propName ] = false;
  				}
  
  				elem.removeAttribute( name );
  			}
  		}
  	},
  
  	attrHooks: {
  		type: {
  			set: function( elem, value ) {
  				if ( !support.radioValue && value === "radio" &&
  					jQuery.nodeName( elem, "input" ) ) {
  					var val = elem.value;
  					elem.setAttribute( "type", value );
  					if ( val ) {
  						elem.value = val;
  					}
  					return value;
  				}
  			}
  		}
  	}
  });
  
  // Hooks for boolean attributes
  boolHook = {
  	set: function( elem, value, name ) {
  		if ( value === false ) {
  			// Remove boolean attributes when set to false
  			jQuery.removeAttr( elem, name );
  		} else {
  			elem.setAttribute( name, name );
  		}
  		return name;
  	}
  };
  jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
  	var getter = attrHandle[ name ] || jQuery.find.attr;
  
  	attrHandle[ name ] = function( elem, name, isXML ) {
  		var ret, handle;
  		if ( !isXML ) {
  			// Avoid an infinite loop by temporarily removing this function from the getter
  			handle = attrHandle[ name ];
  			attrHandle[ name ] = ret;
  			ret = getter( elem, name, isXML ) != null ?
  				name.toLowerCase() :
  				null;
  			attrHandle[ name ] = handle;
  		}
  		return ret;
  	};
  });
  
  
  
  
  var rfocusable = /^(?:input|select|textarea|button)$/i;
  
  jQuery.fn.extend({
  	prop: function( name, value ) {
  		return access( this, jQuery.prop, name, value, arguments.length > 1 );
  	},
  
  	removeProp: function( name ) {
  		return this.each(function() {
  			delete this[ jQuery.propFix[ name ] || name ];
  		});
  	}
  });
  
  jQuery.extend({
  	propFix: {
  		"for": "htmlFor",
  		"class": "className"
  	},
  
  	prop: function( elem, name, value ) {
  		var ret, hooks, notxml,
  			nType = elem.nodeType;
  
  		// Don't get/set properties on text, comment and attribute nodes
  		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  			return;
  		}
  
  		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  
  		if ( notxml ) {
  			// Fix name and attach hooks
  			name = jQuery.propFix[ name ] || name;
  			hooks = jQuery.propHooks[ name ];
  		}
  
  		if ( value !== undefined ) {
  			return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?
  				ret :
  				( elem[ name ] = value );
  
  		} else {
  			return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?
  				ret :
  				elem[ name ];
  		}
  	},
  
  	propHooks: {
  		tabIndex: {
  			get: function( elem ) {
  				return elem.hasAttribute( "tabindex" ) || rfocusable.test( elem.nodeName ) || elem.href ?
  					elem.tabIndex :
  					-1;
  			}
  		}
  	}
  });
  
  if ( !support.optSelected ) {
  	jQuery.propHooks.selected = {
  		get: function( elem ) {
  			var parent = elem.parentNode;
  			if ( parent && parent.parentNode ) {
  				parent.parentNode.selectedIndex;
  			}
  			return null;
  		}
  	};
  }
  
  jQuery.each([
  	"tabIndex",
  	"readOnly",
  	"maxLength",
  	"cellSpacing",
  	"cellPadding",
  	"rowSpan",
  	"colSpan",
  	"useMap",
  	"frameBorder",
  	"contentEditable"
  ], function() {
  	jQuery.propFix[ this.toLowerCase() ] = this;
  });
  
  
  
  
  var rclass = /[\t\r\n\f]/g;
  
  jQuery.fn.extend({
  	addClass: function( value ) {
  		var classes, elem, cur, clazz, j, finalValue,
  			proceed = typeof value === "string" && value,
  			i = 0,
  			len = this.length;
  
  		if ( jQuery.isFunction( value ) ) {
  			return this.each(function( j ) {
  				jQuery( this ).addClass( value.call( this, j, this.className ) );
  			});
  		}
  
  		if ( proceed ) {
  			// The disjunction here is for better compressibility (see removeClass)
  			classes = ( value || "" ).match( rnotwhite ) || [];
  
  			for ( ; i < len; i++ ) {
  				elem = this[ i ];
  				cur = elem.nodeType === 1 && ( elem.className ?
  					( " " + elem.className + " " ).replace( rclass, " " ) :
  					" "
  				);
  
  				if ( cur ) {
  					j = 0;
  					while ( (clazz = classes[j++]) ) {
  						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
  							cur += clazz + " ";
  						}
  					}
  
  					// only assign if different to avoid unneeded rendering.
  					finalValue = jQuery.trim( cur );
  					if ( elem.className !== finalValue ) {
  						elem.className = finalValue;
  					}
  				}
  			}
  		}
  
  		return this;
  	},
  
  	removeClass: function( value ) {
  		var classes, elem, cur, clazz, j, finalValue,
  			proceed = arguments.length === 0 || typeof value === "string" && value,
  			i = 0,
  			len = this.length;
  
  		if ( jQuery.isFunction( value ) ) {
  			return this.each(function( j ) {
  				jQuery( this ).removeClass( value.call( this, j, this.className ) );
  			});
  		}
  		if ( proceed ) {
  			classes = ( value || "" ).match( rnotwhite ) || [];
  
  			for ( ; i < len; i++ ) {
  				elem = this[ i ];
  				// This expression is here for better compressibility (see addClass)
  				cur = elem.nodeType === 1 && ( elem.className ?
  					( " " + elem.className + " " ).replace( rclass, " " ) :
  					""
  				);
  
  				if ( cur ) {
  					j = 0;
  					while ( (clazz = classes[j++]) ) {
  						// Remove *all* instances
  						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
  							cur = cur.replace( " " + clazz + " ", " " );
  						}
  					}
  
  					// Only assign if different to avoid unneeded rendering.
  					finalValue = value ? jQuery.trim( cur ) : "";
  					if ( elem.className !== finalValue ) {
  						elem.className = finalValue;
  					}
  				}
  			}
  		}
  
  		return this;
  	},
  
  	toggleClass: function( value, stateVal ) {
  		var type = typeof value;
  
  		if ( typeof stateVal === "boolean" && type === "string" ) {
  			return stateVal ? this.addClass( value ) : this.removeClass( value );
  		}
  
  		if ( jQuery.isFunction( value ) ) {
  			return this.each(function( i ) {
  				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
  			});
  		}
  
  		return this.each(function() {
  			if ( type === "string" ) {
  				// Toggle individual class names
  				var className,
  					i = 0,
  					self = jQuery( this ),
  					classNames = value.match( rnotwhite ) || [];
  
  				while ( (className = classNames[ i++ ]) ) {
  					// Check each className given, space separated list
  					if ( self.hasClass( className ) ) {
  						self.removeClass( className );
  					} else {
  						self.addClass( className );
  					}
  				}
  
  			// Toggle whole class name
  			} else if ( type === strundefined || type === "boolean" ) {
  				if ( this.className ) {
  					// store className if set
  					data_priv.set( this, "__className__", this.className );
  				}
  
  				// If the element has a class name or if we're passed `false`,
  				// then remove the whole classname (if there was one, the above saved it).
  				// Otherwise bring back whatever was previously saved (if anything),
  				// falling back to the empty string if nothing was stored.
  				this.className = this.className || value === false ? "" : data_priv.get( this, "__className__" ) || "";
  			}
  		});
  	},
  
  	hasClass: function( selector ) {
  		var className = " " + selector + " ",
  			i = 0,
  			l = this.length;
  		for ( ; i < l; i++ ) {
  			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
  				return true;
  			}
  		}
  
  		return false;
  	}
  });
  
  
  
  
  var rreturn = /\r/g;
  
  jQuery.fn.extend({
  	val: function( value ) {
  		var hooks, ret, isFunction,
  			elem = this[0];
  
  		if ( !arguments.length ) {
  			if ( elem ) {
  				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
  
  				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
  					return ret;
  				}
  
  				ret = elem.value;
  
  				return typeof ret === "string" ?
  					// Handle most common string cases
  					ret.replace(rreturn, "") :
  					// Handle cases where value is null/undef or number
  					ret == null ? "" : ret;
  			}
  
  			return;
  		}
  
  		isFunction = jQuery.isFunction( value );
  
  		return this.each(function( i ) {
  			var val;
  
  			if ( this.nodeType !== 1 ) {
  				return;
  			}
  
  			if ( isFunction ) {
  				val = value.call( this, i, jQuery( this ).val() );
  			} else {
  				val = value;
  			}
  
  			// Treat null/undefined as ""; convert numbers to string
  			if ( val == null ) {
  				val = "";
  
  			} else if ( typeof val === "number" ) {
  				val += "";
  
  			} else if ( jQuery.isArray( val ) ) {
  				val = jQuery.map( val, function( value ) {
  					return value == null ? "" : value + "";
  				});
  			}
  
  			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
  
  			// If set returns undefined, fall back to normal setting
  			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
  				this.value = val;
  			}
  		});
  	}
  });
  
  jQuery.extend({
  	valHooks: {
  		option: {
  			get: function( elem ) {
  				var val = jQuery.find.attr( elem, "value" );
  				return val != null ?
  					val :
  					// Support: IE10-11+
  					// option.text throws exceptions (#14686, #14858)
  					jQuery.trim( jQuery.text( elem ) );
  			}
  		},
  		select: {
  			get: function( elem ) {
  				var value, option,
  					options = elem.options,
  					index = elem.selectedIndex,
  					one = elem.type === "select-one" || index < 0,
  					values = one ? null : [],
  					max = one ? index + 1 : options.length,
  					i = index < 0 ?
  						max :
  						one ? index : 0;
  
  				// Loop through all the selected options
  				for ( ; i < max; i++ ) {
  					option = options[ i ];
  
  					// IE6-9 doesn't update selected after form reset (#2551)
  					if ( ( option.selected || i === index ) &&
  							// Don't return options that are disabled or in a disabled optgroup
  							( support.optDisabled ? !option.disabled : option.getAttribute( "disabled" ) === null ) &&
  							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
  
  						// Get the specific value for the option
  						value = jQuery( option ).val();
  
  						// We don't need an array for one selects
  						if ( one ) {
  							return value;
  						}
  
  						// Multi-Selects return an array
  						values.push( value );
  					}
  				}
  
  				return values;
  			},
  
  			set: function( elem, value ) {
  				var optionSet, option,
  					options = elem.options,
  					values = jQuery.makeArray( value ),
  					i = options.length;
  
  				while ( i-- ) {
  					option = options[ i ];
  					if ( (option.selected = jQuery.inArray( option.value, values ) >= 0) ) {
  						optionSet = true;
  					}
  				}
  
  				// Force browsers to behave consistently when non-matching value is set
  				if ( !optionSet ) {
  					elem.selectedIndex = -1;
  				}
  				return values;
  			}
  		}
  	}
  });
  
  // Radios and checkboxes getter/setter
  jQuery.each([ "radio", "checkbox" ], function() {
  	jQuery.valHooks[ this ] = {
  		set: function( elem, value ) {
  			if ( jQuery.isArray( value ) ) {
  				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
  			}
  		}
  	};
  	if ( !support.checkOn ) {
  		jQuery.valHooks[ this ].get = function( elem ) {
  			return elem.getAttribute("value") === null ? "on" : elem.value;
  		};
  	}
  });
  
  
  
  
  // Return jQuery for attributes-only inclusion
  
  
  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
  
  	// Handle event binding
  	jQuery.fn[ name ] = function( data, fn ) {
  		return arguments.length > 0 ?
  			this.on( name, null, data, fn ) :
  			this.trigger( name );
  	};
  });
  
  jQuery.fn.extend({
  	hover: function( fnOver, fnOut ) {
  		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  	},
  
  	bind: function( types, data, fn ) {
  		return this.on( types, null, data, fn );
  	},
  	unbind: function( types, fn ) {
  		return this.off( types, null, fn );
  	},
  
  	delegate: function( selector, types, data, fn ) {
  		return this.on( types, selector, data, fn );
  	},
  	undelegate: function( selector, types, fn ) {
  		// ( namespace ) or ( selector, types [, fn] )
  		return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
  	}
  });
  
  
  var nonce = jQuery.now();
  
  var rquery = (/\?/);
  
  
  
  // Support: Android 2.3
  // Workaround failure to string-cast null input
  jQuery.parseJSON = function( data ) {
  	return JSON.parse( data + "" );
  };
  
  
  // Cross-browser xml parsing
  jQuery.parseXML = function( data ) {
  	var xml, tmp;
  	if ( !data || typeof data !== "string" ) {
  		return null;
  	}
  
  	// Support: IE9
  	try {
  		tmp = new DOMParser();
  		xml = tmp.parseFromString( data, "text/xml" );
  	} catch ( e ) {
  		xml = undefined;
  	}
  
  	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
  		jQuery.error( "Invalid XML: " + data );
  	}
  	return xml;
  };
  
  
  var
  	rhash = /#.*$/,
  	rts = /([?&])_=[^&]*/,
  	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
  	// #7653, #8125, #8152: local protocol detection
  	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
  	rnoContent = /^(?:GET|HEAD)$/,
  	rprotocol = /^\/\//,
  	rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
  
  	/* Prefilters
  	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  	 * 2) These are called:
  	 *    - BEFORE asking for a transport
  	 *    - AFTER param serialization (s.data is a string if s.processData is true)
  	 * 3) key is the dataType
  	 * 4) the catchall symbol "*" can be used
  	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  	 */
  	prefilters = {},
  
  	/* Transports bindings
  	 * 1) key is the dataType
  	 * 2) the catchall symbol "*" can be used
  	 * 3) selection will start with transport dataType and THEN go to "*" if needed
  	 */
  	transports = {},
  
  	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
  	allTypes = "*/".concat( "*" ),
  
  	// Document location
  	ajaxLocation = window.location.href,
  
  	// Segment location into parts
  	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
  
  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  function addToPrefiltersOrTransports( structure ) {
  
  	// dataTypeExpression is optional and defaults to "*"
  	return function( dataTypeExpression, func ) {
  
  		if ( typeof dataTypeExpression !== "string" ) {
  			func = dataTypeExpression;
  			dataTypeExpression = "*";
  		}
  
  		var dataType,
  			i = 0,
  			dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
  
  		if ( jQuery.isFunction( func ) ) {
  			// For each dataType in the dataTypeExpression
  			while ( (dataType = dataTypes[i++]) ) {
  				// Prepend if requested
  				if ( dataType[0] === "+" ) {
  					dataType = dataType.slice( 1 ) || "*";
  					(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
  
  				// Otherwise append
  				} else {
  					(structure[ dataType ] = structure[ dataType ] || []).push( func );
  				}
  			}
  		}
  	};
  }
  
  // Base inspection function for prefilters and transports
  function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
  
  	var inspected = {},
  		seekingTransport = ( structure === transports );
  
  	function inspect( dataType ) {
  		var selected;
  		inspected[ dataType ] = true;
  		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
  			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
  			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
  				options.dataTypes.unshift( dataTypeOrTransport );
  				inspect( dataTypeOrTransport );
  				return false;
  			} else if ( seekingTransport ) {
  				return !( selected = dataTypeOrTransport );
  			}
  		});
  		return selected;
  	}
  
  	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
  }
  
  // A special extend for ajax options
  // that takes "flat" options (not to be deep extended)
  // Fixes #9887
  function ajaxExtend( target, src ) {
  	var key, deep,
  		flatOptions = jQuery.ajaxSettings.flatOptions || {};
  
  	for ( key in src ) {
  		if ( src[ key ] !== undefined ) {
  			( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
  		}
  	}
  	if ( deep ) {
  		jQuery.extend( true, target, deep );
  	}
  
  	return target;
  }
  
  /* Handles responses to an ajax request:
   * - finds the right dataType (mediates between content-type and expected dataType)
   * - returns the corresponding response
   */
  function ajaxHandleResponses( s, jqXHR, responses ) {
  
  	var ct, type, finalDataType, firstDataType,
  		contents = s.contents,
  		dataTypes = s.dataTypes;
  
  	// Remove auto dataType and get content-type in the process
  	while ( dataTypes[ 0 ] === "*" ) {
  		dataTypes.shift();
  		if ( ct === undefined ) {
  			ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
  		}
  	}
  
  	// Check if we're dealing with a known content-type
  	if ( ct ) {
  		for ( type in contents ) {
  			if ( contents[ type ] && contents[ type ].test( ct ) ) {
  				dataTypes.unshift( type );
  				break;
  			}
  		}
  	}
  
  	// Check to see if we have a response for the expected dataType
  	if ( dataTypes[ 0 ] in responses ) {
  		finalDataType = dataTypes[ 0 ];
  	} else {
  		// Try convertible dataTypes
  		for ( type in responses ) {
  			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
  				finalDataType = type;
  				break;
  			}
  			if ( !firstDataType ) {
  				firstDataType = type;
  			}
  		}
  		// Or just use first one
  		finalDataType = finalDataType || firstDataType;
  	}
  
  	// If we found a dataType
  	// We add the dataType to the list if needed
  	// and return the corresponding response
  	if ( finalDataType ) {
  		if ( finalDataType !== dataTypes[ 0 ] ) {
  			dataTypes.unshift( finalDataType );
  		}
  		return responses[ finalDataType ];
  	}
  }
  
  /* Chain conversions given the request and the original response
   * Also sets the responseXXX fields on the jqXHR instance
   */
  function ajaxConvert( s, response, jqXHR, isSuccess ) {
  	var conv2, current, conv, tmp, prev,
  		converters = {},
  		// Work with a copy of dataTypes in case we need to modify it for conversion
  		dataTypes = s.dataTypes.slice();
  
  	// Create converters map with lowercased keys
  	if ( dataTypes[ 1 ] ) {
  		for ( conv in s.converters ) {
  			converters[ conv.toLowerCase() ] = s.converters[ conv ];
  		}
  	}
  
  	current = dataTypes.shift();
  
  	// Convert to each sequential dataType
  	while ( current ) {
  
  		if ( s.responseFields[ current ] ) {
  			jqXHR[ s.responseFields[ current ] ] = response;
  		}
  
  		// Apply the dataFilter if provided
  		if ( !prev && isSuccess && s.dataFilter ) {
  			response = s.dataFilter( response, s.dataType );
  		}
  
  		prev = current;
  		current = dataTypes.shift();
  
  		if ( current ) {
  
  		// There's only work to do if current dataType is non-auto
  			if ( current === "*" ) {
  
  				current = prev;
  
  			// Convert response if prev dataType is non-auto and differs from current
  			} else if ( prev !== "*" && prev !== current ) {
  
  				// Seek a direct converter
  				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
  
  				// If none found, seek a pair
  				if ( !conv ) {
  					for ( conv2 in converters ) {
  
  						// If conv2 outputs current
  						tmp = conv2.split( " " );
  						if ( tmp[ 1 ] === current ) {
  
  							// If prev can be converted to accepted input
  							conv = converters[ prev + " " + tmp[ 0 ] ] ||
  								converters[ "* " + tmp[ 0 ] ];
  							if ( conv ) {
  								// Condense equivalence converters
  								if ( conv === true ) {
  									conv = converters[ conv2 ];
  
  								// Otherwise, insert the intermediate dataType
  								} else if ( converters[ conv2 ] !== true ) {
  									current = tmp[ 0 ];
  									dataTypes.unshift( tmp[ 1 ] );
  								}
  								break;
  							}
  						}
  					}
  				}
  
  				// Apply converter (if not an equivalence)
  				if ( conv !== true ) {
  
  					// Unless errors are allowed to bubble, catch and return them
  					if ( conv && s[ "throws" ] ) {
  						response = conv( response );
  					} else {
  						try {
  							response = conv( response );
  						} catch ( e ) {
  							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
  						}
  					}
  				}
  			}
  		}
  	}
  
  	return { state: "success", data: response };
  }
  
  jQuery.extend({
  
  	// Counter for holding the number of active queries
  	active: 0,
  
  	// Last-Modified header cache for next request
  	lastModified: {},
  	etag: {},
  
  	ajaxSettings: {
  		url: ajaxLocation,
  		type: "GET",
  		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
  		global: true,
  		processData: true,
  		async: true,
  		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  		/*
  		timeout: 0,
  		data: null,
  		dataType: null,
  		username: null,
  		password: null,
  		cache: null,
  		throws: false,
  		traditional: false,
  		headers: {},
  		*/
  
  		accepts: {
  			"*": allTypes,
  			text: "text/plain",
  			html: "text/html",
  			xml: "application/xml, text/xml",
  			json: "application/json, text/javascript"
  		},
  
  		contents: {
  			xml: /xml/,
  			html: /html/,
  			json: /json/
  		},
  
  		responseFields: {
  			xml: "responseXML",
  			text: "responseText",
  			json: "responseJSON"
  		},
  
  		// Data converters
  		// Keys separate source (or catchall "*") and destination types with a single space
  		converters: {
  
  			// Convert anything to text
  			"* text": String,
  
  			// Text to html (true = no transformation)
  			"text html": true,
  
  			// Evaluate text as a json expression
  			"text json": jQuery.parseJSON,
  
  			// Parse text as xml
  			"text xml": jQuery.parseXML
  		},
  
  		// For options that shouldn't be deep extended:
  		// you can add your own custom options here if
  		// and when you create one that shouldn't be
  		// deep extended (see ajaxExtend)
  		flatOptions: {
  			url: true,
  			context: true
  		}
  	},
  
  	// Creates a full fledged settings object into target
  	// with both ajaxSettings and settings fields.
  	// If target is omitted, writes into ajaxSettings.
  	ajaxSetup: function( target, settings ) {
  		return settings ?
  
  			// Building a settings object
  			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
  
  			// Extending ajaxSettings
  			ajaxExtend( jQuery.ajaxSettings, target );
  	},
  
  	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
  	ajaxTransport: addToPrefiltersOrTransports( transports ),
  
  	// Main method
  	ajax: function( url, options ) {
  
  		// If url is an object, simulate pre-1.5 signature
  		if ( typeof url === "object" ) {
  			options = url;
  			url = undefined;
  		}
  
  		// Force options to be an object
  		options = options || {};
  
  		var transport,
  			// URL without anti-cache param
  			cacheURL,
  			// Response headers
  			responseHeadersString,
  			responseHeaders,
  			// timeout handle
  			timeoutTimer,
  			// Cross-domain detection vars
  			parts,
  			// To know if global events are to be dispatched
  			fireGlobals,
  			// Loop variable
  			i,
  			// Create the final options object
  			s = jQuery.ajaxSetup( {}, options ),
  			// Callbacks context
  			callbackContext = s.context || s,
  			// Context for global events is callbackContext if it is a DOM node or jQuery collection
  			globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
  				jQuery( callbackContext ) :
  				jQuery.event,
  			// Deferreds
  			deferred = jQuery.Deferred(),
  			completeDeferred = jQuery.Callbacks("once memory"),
  			// Status-dependent callbacks
  			statusCode = s.statusCode || {},
  			// Headers (they are sent all at once)
  			requestHeaders = {},
  			requestHeadersNames = {},
  			// The jqXHR state
  			state = 0,
  			// Default abort message
  			strAbort = "canceled",
  			// Fake xhr
  			jqXHR = {
  				readyState: 0,
  
  				// Builds headers hashtable if needed
  				getResponseHeader: function( key ) {
  					var match;
  					if ( state === 2 ) {
  						if ( !responseHeaders ) {
  							responseHeaders = {};
  							while ( (match = rheaders.exec( responseHeadersString )) ) {
  								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
  							}
  						}
  						match = responseHeaders[ key.toLowerCase() ];
  					}
  					return match == null ? null : match;
  				},
  
  				// Raw string
  				getAllResponseHeaders: function() {
  					return state === 2 ? responseHeadersString : null;
  				},
  
  				// Caches the header
  				setRequestHeader: function( name, value ) {
  					var lname = name.toLowerCase();
  					if ( !state ) {
  						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
  						requestHeaders[ name ] = value;
  					}
  					return this;
  				},
  
  				// Overrides response content-type header
  				overrideMimeType: function( type ) {
  					if ( !state ) {
  						s.mimeType = type;
  					}
  					return this;
  				},
  
  				// Status-dependent callbacks
  				statusCode: function( map ) {
  					var code;
  					if ( map ) {
  						if ( state < 2 ) {
  							for ( code in map ) {
  								// Lazy-add the new callback in a way that preserves old ones
  								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
  							}
  						} else {
  							// Execute the appropriate callbacks
  							jqXHR.always( map[ jqXHR.status ] );
  						}
  					}
  					return this;
  				},
  
  				// Cancel the request
  				abort: function( statusText ) {
  					var finalText = statusText || strAbort;
  					if ( transport ) {
  						transport.abort( finalText );
  					}
  					done( 0, finalText );
  					return this;
  				}
  			};
  
  		// Attach deferreds
  		deferred.promise( jqXHR ).complete = completeDeferred.add;
  		jqXHR.success = jqXHR.done;
  		jqXHR.error = jqXHR.fail;
  
  		// Remove hash character (#7531: and string promotion)
  		// Add protocol if not provided (prefilters might expect it)
  		// Handle falsy url in the settings object (#10093: consistency with old signature)
  		// We also use the url parameter if available
  		s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" )
  			.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
  
  		// Alias method option to type as per ticket #12004
  		s.type = options.method || options.type || s.method || s.type;
  
  		// Extract dataTypes list
  		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
  
  		// A cross-domain request is in order when we have a protocol:host:port mismatch
  		if ( s.crossDomain == null ) {
  			parts = rurl.exec( s.url.toLowerCase() );
  			s.crossDomain = !!( parts &&
  				( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
  					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
  						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
  			);
  		}
  
  		// Convert data if not already a string
  		if ( s.data && s.processData && typeof s.data !== "string" ) {
  			s.data = jQuery.param( s.data, s.traditional );
  		}
  
  		// Apply prefilters
  		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  
  		// If request was aborted inside a prefilter, stop there
  		if ( state === 2 ) {
  			return jqXHR;
  		}
  
  		// We can fire global events as of now if asked to
  		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
  		fireGlobals = jQuery.event && s.global;
  
  		// Watch for a new set of requests
  		if ( fireGlobals && jQuery.active++ === 0 ) {
  			jQuery.event.trigger("ajaxStart");
  		}
  
  		// Uppercase the type
  		s.type = s.type.toUpperCase();
  
  		// Determine if request has content
  		s.hasContent = !rnoContent.test( s.type );
  
  		// Save the URL in case we're toying with the If-Modified-Since
  		// and/or If-None-Match header later on
  		cacheURL = s.url;
  
  		// More options handling for requests with no content
  		if ( !s.hasContent ) {
  
  			// If data is available, append data to url
  			if ( s.data ) {
  				cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
  				// #9682: remove data so that it's not used in an eventual retry
  				delete s.data;
  			}
  
  			// Add anti-cache in url if needed
  			if ( s.cache === false ) {
  				s.url = rts.test( cacheURL ) ?
  
  					// If there is already a '_' parameter, set its value
  					cacheURL.replace( rts, "$1_=" + nonce++ ) :
  
  					// Otherwise add one to the end
  					cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
  			}
  		}
  
  		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  		if ( s.ifModified ) {
  			if ( jQuery.lastModified[ cacheURL ] ) {
  				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
  			}
  			if ( jQuery.etag[ cacheURL ] ) {
  				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
  			}
  		}
  
  		// Set the correct header, if data is being sent
  		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
  			jqXHR.setRequestHeader( "Content-Type", s.contentType );
  		}
  
  		// Set the Accepts header for the server, depending on the dataType
  		jqXHR.setRequestHeader(
  			"Accept",
  			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
  				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
  				s.accepts[ "*" ]
  		);
  
  		// Check for headers option
  		for ( i in s.headers ) {
  			jqXHR.setRequestHeader( i, s.headers[ i ] );
  		}
  
  		// Allow custom headers/mimetypes and early abort
  		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
  			// Abort if not done already and return
  			return jqXHR.abort();
  		}
  
  		// Aborting is no longer a cancellation
  		strAbort = "abort";
  
  		// Install callbacks on deferreds
  		for ( i in { success: 1, error: 1, complete: 1 } ) {
  			jqXHR[ i ]( s[ i ] );
  		}
  
  		// Get transport
  		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  
  		// If no transport, we auto-abort
  		if ( !transport ) {
  			done( -1, "No Transport" );
  		} else {
  			jqXHR.readyState = 1;
  
  			// Send global event
  			if ( fireGlobals ) {
  				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
  			}
  			// Timeout
  			if ( s.async && s.timeout > 0 ) {
  				timeoutTimer = setTimeout(function() {
  					jqXHR.abort("timeout");
  				}, s.timeout );
  			}
  
  			try {
  				state = 1;
  				transport.send( requestHeaders, done );
  			} catch ( e ) {
  				// Propagate exception as error if not done
  				if ( state < 2 ) {
  					done( -1, e );
  				// Simply rethrow otherwise
  				} else {
  					throw e;
  				}
  			}
  		}
  
  		// Callback for when everything is done
  		function done( status, nativeStatusText, responses, headers ) {
  			var isSuccess, success, error, response, modified,
  				statusText = nativeStatusText;
  
  			// Called once
  			if ( state === 2 ) {
  				return;
  			}
  
  			// State is "done" now
  			state = 2;
  
  			// Clear timeout if it exists
  			if ( timeoutTimer ) {
  				clearTimeout( timeoutTimer );
  			}
  
  			// Dereference transport for early garbage collection
  			// (no matter how long the jqXHR object will be used)
  			transport = undefined;
  
  			// Cache response headers
  			responseHeadersString = headers || "";
  
  			// Set readyState
  			jqXHR.readyState = status > 0 ? 4 : 0;
  
  			// Determine if successful
  			isSuccess = status >= 200 && status < 300 || status === 304;
  
  			// Get response data
  			if ( responses ) {
  				response = ajaxHandleResponses( s, jqXHR, responses );
  			}
  
  			// Convert no matter what (that way responseXXX fields are always set)
  			response = ajaxConvert( s, response, jqXHR, isSuccess );
  
  			// If successful, handle type chaining
  			if ( isSuccess ) {
  
  				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  				if ( s.ifModified ) {
  					modified = jqXHR.getResponseHeader("Last-Modified");
  					if ( modified ) {
  						jQuery.lastModified[ cacheURL ] = modified;
  					}
  					modified = jqXHR.getResponseHeader("etag");
  					if ( modified ) {
  						jQuery.etag[ cacheURL ] = modified;
  					}
  				}
  
  				// if no content
  				if ( status === 204 || s.type === "HEAD" ) {
  					statusText = "nocontent";
  
  				// if not modified
  				} else if ( status === 304 ) {
  					statusText = "notmodified";
  
  				// If we have data, let's convert it
  				} else {
  					statusText = response.state;
  					success = response.data;
  					error = response.error;
  					isSuccess = !error;
  				}
  			} else {
  				// Extract error from statusText and normalize for non-aborts
  				error = statusText;
  				if ( status || !statusText ) {
  					statusText = "error";
  					if ( status < 0 ) {
  						status = 0;
  					}
  				}
  			}
  
  			// Set data for the fake xhr object
  			jqXHR.status = status;
  			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
  
  			// Success/Error
  			if ( isSuccess ) {
  				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
  			} else {
  				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
  			}
  
  			// Status-dependent callbacks
  			jqXHR.statusCode( statusCode );
  			statusCode = undefined;
  
  			if ( fireGlobals ) {
  				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
  					[ jqXHR, s, isSuccess ? success : error ] );
  			}
  
  			// Complete
  			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
  
  			if ( fireGlobals ) {
  				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
  				// Handle the global AJAX counter
  				if ( !( --jQuery.active ) ) {
  					jQuery.event.trigger("ajaxStop");
  				}
  			}
  		}
  
  		return jqXHR;
  	},
  
  	getJSON: function( url, data, callback ) {
  		return jQuery.get( url, data, callback, "json" );
  	},
  
  	getScript: function( url, callback ) {
  		return jQuery.get( url, undefined, callback, "script" );
  	}
  });
  
  jQuery.each( [ "get", "post" ], function( i, method ) {
  	jQuery[ method ] = function( url, data, callback, type ) {
  		// Shift arguments if data argument was omitted
  		if ( jQuery.isFunction( data ) ) {
  			type = type || callback;
  			callback = data;
  			data = undefined;
  		}
  
  		return jQuery.ajax({
  			url: url,
  			type: method,
  			dataType: type,
  			data: data,
  			success: callback
  		});
  	};
  });
  
  
  jQuery._evalUrl = function( url ) {
  	return jQuery.ajax({
  		url: url,
  		type: "GET",
  		dataType: "script",
  		async: false,
  		global: false,
  		"throws": true
  	});
  };
  
  
  jQuery.fn.extend({
  	wrapAll: function( html ) {
  		var wrap;
  
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function( i ) {
  				jQuery( this ).wrapAll( html.call(this, i) );
  			});
  		}
  
  		if ( this[ 0 ] ) {
  
  			// The elements to wrap the target around
  			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
  
  			if ( this[ 0 ].parentNode ) {
  				wrap.insertBefore( this[ 0 ] );
  			}
  
  			wrap.map(function() {
  				var elem = this;
  
  				while ( elem.firstElementChild ) {
  					elem = elem.firstElementChild;
  				}
  
  				return elem;
  			}).append( this );
  		}
  
  		return this;
  	},
  
  	wrapInner: function( html ) {
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function( i ) {
  				jQuery( this ).wrapInner( html.call(this, i) );
  			});
  		}
  
  		return this.each(function() {
  			var self = jQuery( this ),
  				contents = self.contents();
  
  			if ( contents.length ) {
  				contents.wrapAll( html );
  
  			} else {
  				self.append( html );
  			}
  		});
  	},
  
  	wrap: function( html ) {
  		var isFunction = jQuery.isFunction( html );
  
  		return this.each(function( i ) {
  			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
  		});
  	},
  
  	unwrap: function() {
  		return this.parent().each(function() {
  			if ( !jQuery.nodeName( this, "body" ) ) {
  				jQuery( this ).replaceWith( this.childNodes );
  			}
  		}).end();
  	}
  });
  
  
  jQuery.expr.filters.hidden = function( elem ) {
  	// Support: Opera <= 12.12
  	// Opera reports offsetWidths and offsetHeights less than zero on some elements
  	return elem.offsetWidth <= 0 && elem.offsetHeight <= 0;
  };
  jQuery.expr.filters.visible = function( elem ) {
  	return !jQuery.expr.filters.hidden( elem );
  };
  
  
  
  
  var r20 = /%20/g,
  	rbracket = /\[\]$/,
  	rCRLF = /\r?\n/g,
  	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
  	rsubmittable = /^(?:input|select|textarea|keygen)/i;
  
  function buildParams( prefix, obj, traditional, add ) {
  	var name;
  
  	if ( jQuery.isArray( obj ) ) {
  		// Serialize array item.
  		jQuery.each( obj, function( i, v ) {
  			if ( traditional || rbracket.test( prefix ) ) {
  				// Treat each array item as a scalar.
  				add( prefix, v );
  
  			} else {
  				// Item is non-scalar (array or object), encode its numeric index.
  				buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
  			}
  		});
  
  	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
  		// Serialize object item.
  		for ( name in obj ) {
  			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
  		}
  
  	} else {
  		// Serialize scalar item.
  		add( prefix, obj );
  	}
  }
  
  // Serialize an array of form elements or a set of
  // key/values into a query string
  jQuery.param = function( a, traditional ) {
  	var prefix,
  		s = [],
  		add = function( key, value ) {
  			// If value is a function, invoke it and return its value
  			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
  			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
  		};
  
  	// Set traditional to true for jQuery <= 1.3.2 behavior.
  	if ( traditional === undefined ) {
  		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
  	}
  
  	// If an array was passed in, assume that it is an array of form elements.
  	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
  		// Serialize the form elements
  		jQuery.each( a, function() {
  			add( this.name, this.value );
  		});
  
  	} else {
  		// If traditional, encode the "old" way (the way 1.3.2 or older
  		// did it), otherwise encode params recursively.
  		for ( prefix in a ) {
  			buildParams( prefix, a[ prefix ], traditional, add );
  		}
  	}
  
  	// Return the resulting serialization
  	return s.join( "&" ).replace( r20, "+" );
  };
  
  jQuery.fn.extend({
  	serialize: function() {
  		return jQuery.param( this.serializeArray() );
  	},
  	serializeArray: function() {
  		return this.map(function() {
  			// Can add propHook for "elements" to filter or add form elements
  			var elements = jQuery.prop( this, "elements" );
  			return elements ? jQuery.makeArray( elements ) : this;
  		})
  		.filter(function() {
  			var type = this.type;
  
  			// Use .is( ":disabled" ) so that fieldset[disabled] works
  			return this.name && !jQuery( this ).is( ":disabled" ) &&
  				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
  				( this.checked || !rcheckableType.test( type ) );
  		})
  		.map(function( i, elem ) {
  			var val = jQuery( this ).val();
  
  			return val == null ?
  				null :
  				jQuery.isArray( val ) ?
  					jQuery.map( val, function( val ) {
  						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  					}) :
  					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  		}).get();
  	}
  });
  
  
  jQuery.ajaxSettings.xhr = function() {
  	try {
  		return new XMLHttpRequest();
  	} catch( e ) {}
  };
  
  var xhrId = 0,
  	xhrCallbacks = {},
  	xhrSuccessStatus = {
  		// file protocol always yields status code 0, assume 200
  		0: 200,
  		// Support: IE9
  		// #1450: sometimes IE returns 1223 when it should be 204
  		1223: 204
  	},
  	xhrSupported = jQuery.ajaxSettings.xhr();
  
  // Support: IE9
  // Open requests must be manually aborted on unload (#5280)
  // See https://support.microsoft.com/kb/2856746 for more info
  if ( window.attachEvent ) {
  	window.attachEvent( "onunload", function() {
  		for ( var key in xhrCallbacks ) {
  			xhrCallbacks[ key ]();
  		}
  	});
  }
  
  support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
  support.ajax = xhrSupported = !!xhrSupported;
  
  jQuery.ajaxTransport(function( options ) {
  	var callback;
  
  	// Cross domain only allowed if supported through XMLHttpRequest
  	if ( support.cors || xhrSupported && !options.crossDomain ) {
  		return {
  			send: function( headers, complete ) {
  				var i,
  					xhr = options.xhr(),
  					id = ++xhrId;
  
  				xhr.open( options.type, options.url, options.async, options.username, options.password );
  
  				// Apply custom fields if provided
  				if ( options.xhrFields ) {
  					for ( i in options.xhrFields ) {
  						xhr[ i ] = options.xhrFields[ i ];
  					}
  				}
  
  				// Override mime type if needed
  				if ( options.mimeType && xhr.overrideMimeType ) {
  					xhr.overrideMimeType( options.mimeType );
  				}
  
  				// X-Requested-With header
  				// For cross-domain requests, seeing as conditions for a preflight are
  				// akin to a jigsaw puzzle, we simply never set it to be sure.
  				// (it can always be set on a per-request basis or even using ajaxSetup)
  				// For same-domain requests, won't change header if already provided.
  				if ( !options.crossDomain && !headers["X-Requested-With"] ) {
  					headers["X-Requested-With"] = "XMLHttpRequest";
  				}
  
  				// Set headers
  				for ( i in headers ) {
  					xhr.setRequestHeader( i, headers[ i ] );
  				}
  
  				// Callback
  				callback = function( type ) {
  					return function() {
  						if ( callback ) {
  							delete xhrCallbacks[ id ];
  							callback = xhr.onload = xhr.onerror = null;
  
  							if ( type === "abort" ) {
  								xhr.abort();
  							} else if ( type === "error" ) {
  								complete(
  									// file: protocol always yields status 0; see #8605, #14207
  									xhr.status,
  									xhr.statusText
  								);
  							} else {
  								complete(
  									xhrSuccessStatus[ xhr.status ] || xhr.status,
  									xhr.statusText,
  									// Support: IE9
  									// Accessing binary-data responseText throws an exception
  									// (#11426)
  									typeof xhr.responseText === "string" ? {
  										text: xhr.responseText
  									} : undefined,
  									xhr.getAllResponseHeaders()
  								);
  							}
  						}
  					};
  				};
  
  				// Listen to events
  				xhr.onload = callback();
  				xhr.onerror = callback("error");
  
  				// Create the abort callback
  				callback = xhrCallbacks[ id ] = callback("abort");
  
  				try {
  					// Do send the request (this may raise an exception)
  					xhr.send( options.hasContent && options.data || null );
  				} catch ( e ) {
  					// #14683: Only rethrow if this hasn't been notified as an error yet
  					if ( callback ) {
  						throw e;
  					}
  				}
  			},
  
  			abort: function() {
  				if ( callback ) {
  					callback();
  				}
  			}
  		};
  	}
  });
  
  
  
  
  // Install script dataType
  jQuery.ajaxSetup({
  	accepts: {
  		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  	},
  	contents: {
  		script: /(?:java|ecma)script/
  	},
  	converters: {
  		"text script": function( text ) {
  			jQuery.globalEval( text );
  			return text;
  		}
  	}
  });
  
  // Handle cache's special case and crossDomain
  jQuery.ajaxPrefilter( "script", function( s ) {
  	if ( s.cache === undefined ) {
  		s.cache = false;
  	}
  	if ( s.crossDomain ) {
  		s.type = "GET";
  	}
  });
  
  // Bind script tag hack transport
  jQuery.ajaxTransport( "script", function( s ) {
  	// This transport only deals with cross domain requests
  	if ( s.crossDomain ) {
  		var script, callback;
  		return {
  			send: function( _, complete ) {
  				script = jQuery("<script>").prop({
  					async: true,
  					charset: s.scriptCharset,
  					src: s.url
  				}).on(
  					"load error",
  					callback = function( evt ) {
  						script.remove();
  						callback = null;
  						if ( evt ) {
  							complete( evt.type === "error" ? 404 : 200, evt.type );
  						}
  					}
  				);
  				document.head.appendChild( script[ 0 ] );
  			},
  			abort: function() {
  				if ( callback ) {
  					callback();
  				}
  			}
  		};
  	}
  });
  
  
  
  
  var oldCallbacks = [],
  	rjsonp = /(=)\?(?=&|$)|\?\?/;
  
  // Default jsonp settings
  jQuery.ajaxSetup({
  	jsonp: "callback",
  	jsonpCallback: function() {
  		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
  		this[ callback ] = true;
  		return callback;
  	}
  });
  
  // Detect, normalize options and install callbacks for jsonp requests
  jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
  
  	var callbackName, overwritten, responseContainer,
  		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
  			"url" :
  			typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
  		);
  
  	// Handle iff the expected data type is "jsonp" or we have a parameter to set
  	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
  
  		// Get callback name, remembering preexisting value associated with it
  		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
  			s.jsonpCallback() :
  			s.jsonpCallback;
  
  		// Insert callback into url or form data
  		if ( jsonProp ) {
  			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
  		} else if ( s.jsonp !== false ) {
  			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
  		}
  
  		// Use data converter to retrieve json after script execution
  		s.converters["script json"] = function() {
  			if ( !responseContainer ) {
  				jQuery.error( callbackName + " was not called" );
  			}
  			return responseContainer[ 0 ];
  		};
  
  		// force json dataType
  		s.dataTypes[ 0 ] = "json";
  
  		// Install callback
  		overwritten = window[ callbackName ];
  		window[ callbackName ] = function() {
  			responseContainer = arguments;
  		};
  
  		// Clean-up function (fires after converters)
  		jqXHR.always(function() {
  			// Restore preexisting value
  			window[ callbackName ] = overwritten;
  
  			// Save back as free
  			if ( s[ callbackName ] ) {
  				// make sure that re-using the options doesn't screw things around
  				s.jsonpCallback = originalSettings.jsonpCallback;
  
  				// save the callback name for future use
  				oldCallbacks.push( callbackName );
  			}
  
  			// Call if it was a function and we have a response
  			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
  				overwritten( responseContainer[ 0 ] );
  			}
  
  			responseContainer = overwritten = undefined;
  		});
  
  		// Delegate to script
  		return "script";
  	}
  });
  
  
  
  
  // data: string of html
  // context (optional): If specified, the fragment will be created in this context, defaults to document
  // keepScripts (optional): If true, will include scripts passed in the html string
  jQuery.parseHTML = function( data, context, keepScripts ) {
  	if ( !data || typeof data !== "string" ) {
  		return null;
  	}
  	if ( typeof context === "boolean" ) {
  		keepScripts = context;
  		context = false;
  	}
  	context = context || document;
  
  	var parsed = rsingleTag.exec( data ),
  		scripts = !keepScripts && [];
  
  	// Single tag
  	if ( parsed ) {
  		return [ context.createElement( parsed[1] ) ];
  	}
  
  	parsed = jQuery.buildFragment( [ data ], context, scripts );
  
  	if ( scripts && scripts.length ) {
  		jQuery( scripts ).remove();
  	}
  
  	return jQuery.merge( [], parsed.childNodes );
  };
  
  
  // Keep a copy of the old load method
  var _load = jQuery.fn.load;
  
  /**
   * Load a url into a page
   */
  jQuery.fn.load = function( url, params, callback ) {
  	if ( typeof url !== "string" && _load ) {
  		return _load.apply( this, arguments );
  	}
  
  	var selector, type, response,
  		self = this,
  		off = url.indexOf(" ");
  
  	if ( off >= 0 ) {
  		selector = jQuery.trim( url.slice( off ) );
  		url = url.slice( 0, off );
  	}
  
  	// If it's a function
  	if ( jQuery.isFunction( params ) ) {
  
  		// We assume that it's the callback
  		callback = params;
  		params = undefined;
  
  	// Otherwise, build a param string
  	} else if ( params && typeof params === "object" ) {
  		type = "POST";
  	}
  
  	// If we have elements to modify, make the request
  	if ( self.length > 0 ) {
  		jQuery.ajax({
  			url: url,
  
  			// if "type" variable is undefined, then "GET" method will be used
  			type: type,
  			dataType: "html",
  			data: params
  		}).done(function( responseText ) {
  
  			// Save response for use in complete callback
  			response = arguments;
  
  			self.html( selector ?
  
  				// If a selector was specified, locate the right elements in a dummy div
  				// Exclude scripts to avoid IE 'Permission Denied' errors
  				jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
  
  				// Otherwise use the full result
  				responseText );
  
  		}).complete( callback && function( jqXHR, status ) {
  			self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
  		});
  	}
  
  	return this;
  };
  
  
  
  
  // Attach a bunch of functions for handling common AJAX events
  jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
  	jQuery.fn[ type ] = function( fn ) {
  		return this.on( type, fn );
  	};
  });
  
  
  
  
  jQuery.expr.filters.animated = function( elem ) {
  	return jQuery.grep(jQuery.timers, function( fn ) {
  		return elem === fn.elem;
  	}).length;
  };
  
  
  
  
  var docElem = window.document.documentElement;
  
  /**
   * Gets a window from an element
   */
  function getWindow( elem ) {
  	return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
  }
  
  jQuery.offset = {
  	setOffset: function( elem, options, i ) {
  		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
  			position = jQuery.css( elem, "position" ),
  			curElem = jQuery( elem ),
  			props = {};
  
  		// Set position first, in-case top/left are set even on static elem
  		if ( position === "static" ) {
  			elem.style.position = "relative";
  		}
  
  		curOffset = curElem.offset();
  		curCSSTop = jQuery.css( elem, "top" );
  		curCSSLeft = jQuery.css( elem, "left" );
  		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
  			( curCSSTop + curCSSLeft ).indexOf("auto") > -1;
  
  		// Need to be able to calculate position if either
  		// top or left is auto and position is either absolute or fixed
  		if ( calculatePosition ) {
  			curPosition = curElem.position();
  			curTop = curPosition.top;
  			curLeft = curPosition.left;
  
  		} else {
  			curTop = parseFloat( curCSSTop ) || 0;
  			curLeft = parseFloat( curCSSLeft ) || 0;
  		}
  
  		if ( jQuery.isFunction( options ) ) {
  			options = options.call( elem, i, curOffset );
  		}
  
  		if ( options.top != null ) {
  			props.top = ( options.top - curOffset.top ) + curTop;
  		}
  		if ( options.left != null ) {
  			props.left = ( options.left - curOffset.left ) + curLeft;
  		}
  
  		if ( "using" in options ) {
  			options.using.call( elem, props );
  
  		} else {
  			curElem.css( props );
  		}
  	}
  };
  
  jQuery.fn.extend({
  	offset: function( options ) {
  		if ( arguments.length ) {
  			return options === undefined ?
  				this :
  				this.each(function( i ) {
  					jQuery.offset.setOffset( this, options, i );
  				});
  		}
  
  		var docElem, win,
  			elem = this[ 0 ],
  			box = { top: 0, left: 0 },
  			doc = elem && elem.ownerDocument;
  
  		if ( !doc ) {
  			return;
  		}
  
  		docElem = doc.documentElement;
  
  		// Make sure it's not a disconnected DOM node
  		if ( !jQuery.contains( docElem, elem ) ) {
  			return box;
  		}
  
  		// Support: BlackBerry 5, iOS 3 (original iPhone)
  		// If we don't have gBCR, just use 0,0 rather than error
  		if ( typeof elem.getBoundingClientRect !== strundefined ) {
  			box = elem.getBoundingClientRect();
  		}
  		win = getWindow( doc );
  		return {
  			top: box.top + win.pageYOffset - docElem.clientTop,
  			left: box.left + win.pageXOffset - docElem.clientLeft
  		};
  	},
  
  	position: function() {
  		if ( !this[ 0 ] ) {
  			return;
  		}
  
  		var offsetParent, offset,
  			elem = this[ 0 ],
  			parentOffset = { top: 0, left: 0 };
  
  		// Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
  		if ( jQuery.css( elem, "position" ) === "fixed" ) {
  			// Assume getBoundingClientRect is there when computed position is fixed
  			offset = elem.getBoundingClientRect();
  
  		} else {
  			// Get *real* offsetParent
  			offsetParent = this.offsetParent();
  
  			// Get correct offsets
  			offset = this.offset();
  			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
  				parentOffset = offsetParent.offset();
  			}
  
  			// Add offsetParent borders
  			parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
  			parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
  		}
  
  		// Subtract parent offsets and element margins
  		return {
  			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
  			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
  		};
  	},
  
  	offsetParent: function() {
  		return this.map(function() {
  			var offsetParent = this.offsetParent || docElem;
  
  			while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position" ) === "static" ) ) {
  				offsetParent = offsetParent.offsetParent;
  			}
  
  			return offsetParent || docElem;
  		});
  	}
  });
  
  // Create scrollLeft and scrollTop methods
  jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
  	var top = "pageYOffset" === prop;
  
  	jQuery.fn[ method ] = function( val ) {
  		return access( this, function( elem, method, val ) {
  			var win = getWindow( elem );
  
  			if ( val === undefined ) {
  				return win ? win[ prop ] : elem[ method ];
  			}
  
  			if ( win ) {
  				win.scrollTo(
  					!top ? val : window.pageXOffset,
  					top ? val : window.pageYOffset
  				);
  
  			} else {
  				elem[ method ] = val;
  			}
  		}, method, val, arguments.length, null );
  	};
  });
  
  // Support: Safari<7+, Chrome<37+
  // Add the top/left cssHooks using jQuery.fn.position
  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
  // Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
  // getComputedStyle returns percent when specified for top/left/bottom/right;
  // rather than make the css module depend on the offset module, just check for it here
  jQuery.each( [ "top", "left" ], function( i, prop ) {
  	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
  		function( elem, computed ) {
  			if ( computed ) {
  				computed = curCSS( elem, prop );
  				// If curCSS returns percentage, fallback to offset
  				return rnumnonpx.test( computed ) ?
  					jQuery( elem ).position()[ prop ] + "px" :
  					computed;
  			}
  		}
  	);
  });
  
  
  // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
  jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
  	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
  		// Margin is only for outerHeight, outerWidth
  		jQuery.fn[ funcName ] = function( margin, value ) {
  			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
  				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
  
  			return access( this, function( elem, type, value ) {
  				var doc;
  
  				if ( jQuery.isWindow( elem ) ) {
  					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
  					// isn't a whole lot we can do. See pull request at this URL for discussion:
  					// https://github.com/jquery/jquery/pull/764
  					return elem.document.documentElement[ "client" + name ];
  				}
  
  				// Get document width or height
  				if ( elem.nodeType === 9 ) {
  					doc = elem.documentElement;
  
  					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
  					// whichever is greatest
  					return Math.max(
  						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
  						elem.body[ "offset" + name ], doc[ "offset" + name ],
  						doc[ "client" + name ]
  					);
  				}
  
  				return value === undefined ?
  					// Get width or height on the element, requesting but not forcing parseFloat
  					jQuery.css( elem, type, extra ) :
  
  					// Set width or height on the element
  					jQuery.style( elem, type, value, extra );
  			}, type, chainable ? margin : undefined, chainable, null );
  		};
  	});
  });
  
  
  // The number of elements contained in the matched element set
  jQuery.fn.size = function() {
  	return this.length;
  };
  
  jQuery.fn.andSelf = jQuery.fn.addBack;
  
  
  
  
  // Register as a named AMD module, since jQuery can be concatenated with other
  // files that may use define, but not via a proper concatenation script that
  // understands anonymous AMD modules. A named AMD is safest and most robust
  // way to register. Lowercase jquery is used because AMD module names are
  // derived from file names, and jQuery is normally delivered in a lowercase
  // file name. Do this after creating the global so that if an AMD module wants
  // to call noConflict to hide this version of jQuery, it will work.
  
  // Note that for maximum portability, libraries that are not jQuery should
  // declare themselves as anonymous modules, and avoid setting a global if an
  // AMD loader is present. jQuery is a special case. For more information, see
  // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
  
  if ( typeof define === "function" && define.amd ) {
  	define( "jquery", [], function() {
  		return jQuery;
  	});
  }
  
  
  
  
  var
  	// Map over jQuery in case of overwrite
  	_jQuery = window.jQuery,
  
  	// Map over the $ in case of overwrite
  	_$ = window.$;
  
  jQuery.noConflict = function( deep ) {
  	if ( window.$ === jQuery ) {
  		window.$ = _$;
  	}
  
  	if ( deep && window.jQuery === jQuery ) {
  		window.jQuery = _jQuery;
  	}
  
  	return jQuery;
  };
  
  // Expose jQuery and $ identifiers, even in AMD
  // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
  // and CommonJS for browser emulators (#13566)
  if ( typeof noGlobal === strundefined ) {
  	window.jQuery = window.$ = jQuery;
  }
  
  
  
  
  return jQuery;
  
  }));
  
  },{}],4:[function(require,module,exports){
  //! moment.js
  //! version : 2.10.6
  //! authors : Tim Wood, Iskren Chernev, Moment.js contributors
  //! license : MIT
  //! momentjs.com
  
  (function (global, factory) {
      typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
      typeof define === 'function' && define.amd ? define(factory) :
      global.moment = factory()
  }(this, function () { 'use strict';
  
      var hookCallback;
  
      function utils_hooks__hooks () {
          return hookCallback.apply(null, arguments);
      }
  
      // This is done to register the method called with moment()
      // without creating circular dependencies.
      function setHookCallback (callback) {
          hookCallback = callback;
      }
  
      function isArray(input) {
          return Object.prototype.toString.call(input) === '[object Array]';
      }
  
      function isDate(input) {
          return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
      }
  
      function map(arr, fn) {
          var res = [], i;
          for (i = 0; i < arr.length; ++i) {
              res.push(fn(arr[i], i));
          }
          return res;
      }
  
      function hasOwnProp(a, b) {
          return Object.prototype.hasOwnProperty.call(a, b);
      }
  
      function extend(a, b) {
          for (var i in b) {
              if (hasOwnProp(b, i)) {
                  a[i] = b[i];
              }
          }
  
          if (hasOwnProp(b, 'toString')) {
              a.toString = b.toString;
          }
  
          if (hasOwnProp(b, 'valueOf')) {
              a.valueOf = b.valueOf;
          }
  
          return a;
      }
  
      function create_utc__createUTC (input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, true).utc();
      }
  
      function defaultParsingFlags() {
          // We need to deep clone this object.
          return {
              empty           : false,
              unusedTokens    : [],
              unusedInput     : [],
              overflow        : -2,
              charsLeftOver   : 0,
              nullInput       : false,
              invalidMonth    : null,
              invalidFormat   : false,
              userInvalidated : false,
              iso             : false
          };
      }
  
      function getParsingFlags(m) {
          if (m._pf == null) {
              m._pf = defaultParsingFlags();
          }
          return m._pf;
      }
  
      function valid__isValid(m) {
          if (m._isValid == null) {
              var flags = getParsingFlags(m);
              m._isValid = !isNaN(m._d.getTime()) &&
                  flags.overflow < 0 &&
                  !flags.empty &&
                  !flags.invalidMonth &&
                  !flags.invalidWeekday &&
                  !flags.nullInput &&
                  !flags.invalidFormat &&
                  !flags.userInvalidated;
  
              if (m._strict) {
                  m._isValid = m._isValid &&
                      flags.charsLeftOver === 0 &&
                      flags.unusedTokens.length === 0 &&
                      flags.bigHour === undefined;
              }
          }
          return m._isValid;
      }
  
      function valid__createInvalid (flags) {
          var m = create_utc__createUTC(NaN);
          if (flags != null) {
              extend(getParsingFlags(m), flags);
          }
          else {
              getParsingFlags(m).userInvalidated = true;
          }
  
          return m;
      }
  
      var momentProperties = utils_hooks__hooks.momentProperties = [];
  
      function copyConfig(to, from) {
          var i, prop, val;
  
          if (typeof from._isAMomentObject !== 'undefined') {
              to._isAMomentObject = from._isAMomentObject;
          }
          if (typeof from._i !== 'undefined') {
              to._i = from._i;
          }
          if (typeof from._f !== 'undefined') {
              to._f = from._f;
          }
          if (typeof from._l !== 'undefined') {
              to._l = from._l;
          }
          if (typeof from._strict !== 'undefined') {
              to._strict = from._strict;
          }
          if (typeof from._tzm !== 'undefined') {
              to._tzm = from._tzm;
          }
          if (typeof from._isUTC !== 'undefined') {
              to._isUTC = from._isUTC;
          }
          if (typeof from._offset !== 'undefined') {
              to._offset = from._offset;
          }
          if (typeof from._pf !== 'undefined') {
              to._pf = getParsingFlags(from);
          }
          if (typeof from._locale !== 'undefined') {
              to._locale = from._locale;
          }
  
          if (momentProperties.length > 0) {
              for (i in momentProperties) {
                  prop = momentProperties[i];
                  val = from[prop];
                  if (typeof val !== 'undefined') {
                      to[prop] = val;
                  }
              }
          }
  
          return to;
      }
  
      var updateInProgress = false;
  
      // Moment prototype object
      function Moment(config) {
          copyConfig(this, config);
          this._d = new Date(config._d != null ? config._d.getTime() : NaN);
          // Prevent infinite loop in case updateOffset creates new moment
          // objects.
          if (updateInProgress === false) {
              updateInProgress = true;
              utils_hooks__hooks.updateOffset(this);
              updateInProgress = false;
          }
      }
  
      function isMoment (obj) {
          return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
      }
  
      function absFloor (number) {
          if (number < 0) {
              return Math.ceil(number);
          } else {
              return Math.floor(number);
          }
      }
  
      function toInt(argumentForCoercion) {
          var coercedNumber = +argumentForCoercion,
              value = 0;
  
          if (coercedNumber !== 0 && isFinite(coercedNumber)) {
              value = absFloor(coercedNumber);
          }
  
          return value;
      }
  
      function compareArrays(array1, array2, dontConvert) {
          var len = Math.min(array1.length, array2.length),
              lengthDiff = Math.abs(array1.length - array2.length),
              diffs = 0,
              i;
          for (i = 0; i < len; i++) {
              if ((dontConvert && array1[i] !== array2[i]) ||
                  (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
                  diffs++;
              }
          }
          return diffs + lengthDiff;
      }
  
      function Locale() {
      }
  
      var locales = {};
      var globalLocale;
  
      function normalizeLocale(key) {
          return key ? key.toLowerCase().replace('_', '-') : key;
      }
  
      // pick the locale from the array
      // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
      // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
      function chooseLocale(names) {
          var i = 0, j, next, locale, split;
  
          while (i < names.length) {
              split = normalizeLocale(names[i]).split('-');
              j = split.length;
              next = normalizeLocale(names[i + 1]);
              next = next ? next.split('-') : null;
              while (j > 0) {
                  locale = loadLocale(split.slice(0, j).join('-'));
                  if (locale) {
                      return locale;
                  }
                  if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
                      //the next array item is better than a shallower substring of this one
                      break;
                  }
                  j--;
              }
              i++;
          }
          return null;
      }
  
      function loadLocale(name) {
          var oldLocale = null;
          // TODO: Find a better way to register and load all the locales in Node
          if (!locales[name] && typeof module !== 'undefined' &&
                  module && module.exports) {
              try {
                  oldLocale = globalLocale._abbr;
                  require('./locale/' + name);
                  // because defineLocale currently also sets the global locale, we
                  // want to undo that for lazy loaded locales
                  locale_locales__getSetGlobalLocale(oldLocale);
              } catch (e) { }
          }
          return locales[name];
      }
  
      // This function will load locale and then set the global locale.  If
      // no arguments are passed in, it will simply return the current global
      // locale key.
      function locale_locales__getSetGlobalLocale (key, values) {
          var data;
          if (key) {
              if (typeof values === 'undefined') {
                  data = locale_locales__getLocale(key);
              }
              else {
                  data = defineLocale(key, values);
              }
  
              if (data) {
                  // moment.duration._locale = moment._locale = data;
                  globalLocale = data;
              }
          }
  
          return globalLocale._abbr;
      }
  
      function defineLocale (name, values) {
          if (values !== null) {
              values.abbr = name;
              locales[name] = locales[name] || new Locale();
              locales[name].set(values);
  
              // backwards compat for now: also set the locale
              locale_locales__getSetGlobalLocale(name);
  
              return locales[name];
          } else {
              // useful for testing
              delete locales[name];
              return null;
          }
      }
  
      // returns locale data
      function locale_locales__getLocale (key) {
          var locale;
  
          if (key && key._locale && key._locale._abbr) {
              key = key._locale._abbr;
          }
  
          if (!key) {
              return globalLocale;
          }
  
          if (!isArray(key)) {
              //short-circuit everything else
              locale = loadLocale(key);
              if (locale) {
                  return locale;
              }
              key = [key];
          }
  
          return chooseLocale(key);
      }
  
      var aliases = {};
  
      function addUnitAlias (unit, shorthand) {
          var lowerCase = unit.toLowerCase();
          aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
      }
  
      function normalizeUnits(units) {
          return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
      }
  
      function normalizeObjectUnits(inputObject) {
          var normalizedInput = {},
              normalizedProp,
              prop;
  
          for (prop in inputObject) {
              if (hasOwnProp(inputObject, prop)) {
                  normalizedProp = normalizeUnits(prop);
                  if (normalizedProp) {
                      normalizedInput[normalizedProp] = inputObject[prop];
                  }
              }
          }
  
          return normalizedInput;
      }
  
      function makeGetSet (unit, keepTime) {
          return function (value) {
              if (value != null) {
                  get_set__set(this, unit, value);
                  utils_hooks__hooks.updateOffset(this, keepTime);
                  return this;
              } else {
                  return get_set__get(this, unit);
              }
          };
      }
  
      function get_set__get (mom, unit) {
          return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
      }
  
      function get_set__set (mom, unit, value) {
          return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
      }
  
      // MOMENTS
  
      function getSet (units, value) {
          var unit;
          if (typeof units === 'object') {
              for (unit in units) {
                  this.set(unit, units[unit]);
              }
          } else {
              units = normalizeUnits(units);
              if (typeof this[units] === 'function') {
                  return this[units](value);
              }
          }
          return this;
      }
  
      function zeroFill(number, targetLength, forceSign) {
          var absNumber = '' + Math.abs(number),
              zerosToFill = targetLength - absNumber.length,
              sign = number >= 0;
          return (sign ? (forceSign ? '+' : '') : '-') +
              Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
      }
  
      var formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
  
      var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
  
      var formatFunctions = {};
  
      var formatTokenFunctions = {};
  
      // token:    'M'
      // padded:   ['MM', 2]
      // ordinal:  'Mo'
      // callback: function () { this.month() + 1 }
      function addFormatToken (token, padded, ordinal, callback) {
          var func = callback;
          if (typeof callback === 'string') {
              func = function () {
                  return this[callback]();
              };
          }
          if (token) {
              formatTokenFunctions[token] = func;
          }
          if (padded) {
              formatTokenFunctions[padded[0]] = function () {
                  return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
              };
          }
          if (ordinal) {
              formatTokenFunctions[ordinal] = function () {
                  return this.localeData().ordinal(func.apply(this, arguments), token);
              };
          }
      }
  
      function removeFormattingTokens(input) {
          if (input.match(/\[[\s\S]/)) {
              return input.replace(/^\[|\]$/g, '');
          }
          return input.replace(/\\/g, '');
      }
  
      function makeFormatFunction(format) {
          var array = format.match(formattingTokens), i, length;
  
          for (i = 0, length = array.length; i < length; i++) {
              if (formatTokenFunctions[array[i]]) {
                  array[i] = formatTokenFunctions[array[i]];
              } else {
                  array[i] = removeFormattingTokens(array[i]);
              }
          }
  
          return function (mom) {
              var output = '';
              for (i = 0; i < length; i++) {
                  output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
              }
              return output;
          };
      }
  
      // format date using native date object
      function formatMoment(m, format) {
          if (!m.isValid()) {
              return m.localeData().invalidDate();
          }
  
          format = expandFormat(format, m.localeData());
          formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
  
          return formatFunctions[format](m);
      }
  
      function expandFormat(format, locale) {
          var i = 5;
  
          function replaceLongDateFormatTokens(input) {
              return locale.longDateFormat(input) || input;
          }
  
          localFormattingTokens.lastIndex = 0;
          while (i >= 0 && localFormattingTokens.test(format)) {
              format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
              localFormattingTokens.lastIndex = 0;
              i -= 1;
          }
  
          return format;
      }
  
      var match1         = /\d/;            //       0 - 9
      var match2         = /\d\d/;          //      00 - 99
      var match3         = /\d{3}/;         //     000 - 999
      var match4         = /\d{4}/;         //    0000 - 9999
      var match6         = /[+-]?\d{6}/;    // -999999 - 999999
      var match1to2      = /\d\d?/;         //       0 - 99
      var match1to3      = /\d{1,3}/;       //       0 - 999
      var match1to4      = /\d{1,4}/;       //       0 - 9999
      var match1to6      = /[+-]?\d{1,6}/;  // -999999 - 999999
  
      var matchUnsigned  = /\d+/;           //       0 - inf
      var matchSigned    = /[+-]?\d+/;      //    -inf - inf
  
      var matchOffset    = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
  
      var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
  
      // any word (or two) characters or numbers including two/three word month in arabic.
      var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
  
      var regexes = {};
  
      function isFunction (sth) {
          // https://github.com/moment/moment/issues/2325
          return typeof sth === 'function' &&
              Object.prototype.toString.call(sth) === '[object Function]';
      }
  
  
      function addRegexToken (token, regex, strictRegex) {
          regexes[token] = isFunction(regex) ? regex : function (isStrict) {
              return (isStrict && strictRegex) ? strictRegex : regex;
          };
      }
  
      function getParseRegexForToken (token, config) {
          if (!hasOwnProp(regexes, token)) {
              return new RegExp(unescapeFormat(token));
          }
  
          return regexes[token](config._strict, config._locale);
      }
  
      // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
      function unescapeFormat(s) {
          return s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
              return p1 || p2 || p3 || p4;
          }).replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
      }
  
      var tokens = {};
  
      function addParseToken (token, callback) {
          var i, func = callback;
          if (typeof token === 'string') {
              token = [token];
          }
          if (typeof callback === 'number') {
              func = function (input, array) {
                  array[callback] = toInt(input);
              };
          }
          for (i = 0; i < token.length; i++) {
              tokens[token[i]] = func;
          }
      }
  
      function addWeekParseToken (token, callback) {
          addParseToken(token, function (input, array, config, token) {
              config._w = config._w || {};
              callback(input, config._w, config, token);
          });
      }
  
      function addTimeToArrayFromToken(token, input, config) {
          if (input != null && hasOwnProp(tokens, token)) {
              tokens[token](input, config._a, config, token);
          }
      }
  
      var YEAR = 0;
      var MONTH = 1;
      var DATE = 2;
      var HOUR = 3;
      var MINUTE = 4;
      var SECOND = 5;
      var MILLISECOND = 6;
  
      function daysInMonth(year, month) {
          return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
      }
  
      // FORMATTING
  
      addFormatToken('M', ['MM', 2], 'Mo', function () {
          return this.month() + 1;
      });
  
      addFormatToken('MMM', 0, 0, function (format) {
          return this.localeData().monthsShort(this, format);
      });
  
      addFormatToken('MMMM', 0, 0, function (format) {
          return this.localeData().months(this, format);
      });
  
      // ALIASES
  
      addUnitAlias('month', 'M');
  
      // PARSING
  
      addRegexToken('M',    match1to2);
      addRegexToken('MM',   match1to2, match2);
      addRegexToken('MMM',  matchWord);
      addRegexToken('MMMM', matchWord);
  
      addParseToken(['M', 'MM'], function (input, array) {
          array[MONTH] = toInt(input) - 1;
      });
  
      addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
          var month = config._locale.monthsParse(input, token, config._strict);
          // if we didn't find a month name, mark the date as invalid.
          if (month != null) {
              array[MONTH] = month;
          } else {
              getParsingFlags(config).invalidMonth = input;
          }
      });
  
      // LOCALES
  
      var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
      function localeMonths (m) {
          return this._months[m.month()];
      }
  
      var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
      function localeMonthsShort (m) {
          return this._monthsShort[m.month()];
      }
  
      function localeMonthsParse (monthName, format, strict) {
          var i, mom, regex;
  
          if (!this._monthsParse) {
              this._monthsParse = [];
              this._longMonthsParse = [];
              this._shortMonthsParse = [];
          }
  
          for (i = 0; i < 12; i++) {
              // make the regex if we don't have it already
              mom = create_utc__createUTC([2000, i]);
              if (strict && !this._longMonthsParse[i]) {
                  this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
                  this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
              }
              if (!strict && !this._monthsParse[i]) {
                  regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
                  this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
              }
              // test the regex
              if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
                  return i;
              } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
                  return i;
              } else if (!strict && this._monthsParse[i].test(monthName)) {
                  return i;
              }
          }
      }
  
      // MOMENTS
  
      function setMonth (mom, value) {
          var dayOfMonth;
  
          // TODO: Move this out of here!
          if (typeof value === 'string') {
              value = mom.localeData().monthsParse(value);
              // TODO: Another silent failure?
              if (typeof value !== 'number') {
                  return mom;
              }
          }
  
          dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
          mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
          return mom;
      }
  
      function getSetMonth (value) {
          if (value != null) {
              setMonth(this, value);
              utils_hooks__hooks.updateOffset(this, true);
              return this;
          } else {
              return get_set__get(this, 'Month');
          }
      }
  
      function getDaysInMonth () {
          return daysInMonth(this.year(), this.month());
      }
  
      function checkOverflow (m) {
          var overflow;
          var a = m._a;
  
          if (a && getParsingFlags(m).overflow === -2) {
              overflow =
                  a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
                  a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
                  a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
                  a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
                  a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
                  a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
                  -1;
  
              if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
                  overflow = DATE;
              }
  
              getParsingFlags(m).overflow = overflow;
          }
  
          return m;
      }
  
      function warn(msg) {
          if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
              console.warn('Deprecation warning: ' + msg);
          }
      }
  
      function deprecate(msg, fn) {
          var firstTime = true;
  
          return extend(function () {
              if (firstTime) {
                  warn(msg + '\n' + (new Error()).stack);
                  firstTime = false;
              }
              return fn.apply(this, arguments);
          }, fn);
      }
  
      var deprecations = {};
  
      function deprecateSimple(name, msg) {
          if (!deprecations[name]) {
              warn(msg);
              deprecations[name] = true;
          }
      }
  
      utils_hooks__hooks.suppressDeprecationWarnings = false;
  
      var from_string__isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
  
      var isoDates = [
          ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
          ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
          ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
          ['GGGG-[W]WW', /\d{4}-W\d{2}/],
          ['YYYY-DDD', /\d{4}-\d{3}/]
      ];
  
      // iso time formats and regexes
      var isoTimes = [
          ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
          ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
          ['HH:mm', /(T| )\d\d:\d\d/],
          ['HH', /(T| )\d\d/]
      ];
  
      var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
  
      // date from iso format
      function configFromISO(config) {
          var i, l,
              string = config._i,
              match = from_string__isoRegex.exec(string);
  
          if (match) {
              getParsingFlags(config).iso = true;
              for (i = 0, l = isoDates.length; i < l; i++) {
                  if (isoDates[i][1].exec(string)) {
                      config._f = isoDates[i][0];
                      break;
                  }
              }
              for (i = 0, l = isoTimes.length; i < l; i++) {
                  if (isoTimes[i][1].exec(string)) {
                      // match[6] should be 'T' or space
                      config._f += (match[6] || ' ') + isoTimes[i][0];
                      break;
                  }
              }
              if (string.match(matchOffset)) {
                  config._f += 'Z';
              }
              configFromStringAndFormat(config);
          } else {
              config._isValid = false;
          }
      }
  
      // date from iso format or fallback
      function configFromString(config) {
          var matched = aspNetJsonRegex.exec(config._i);
  
          if (matched !== null) {
              config._d = new Date(+matched[1]);
              return;
          }
  
          configFromISO(config);
          if (config._isValid === false) {
              delete config._isValid;
              utils_hooks__hooks.createFromInputFallback(config);
          }
      }
  
      utils_hooks__hooks.createFromInputFallback = deprecate(
          'moment construction falls back to js Date. This is ' +
          'discouraged and will be removed in upcoming major ' +
          'release. Please refer to ' +
          'https://github.com/moment/moment/issues/1407 for more info.',
          function (config) {
              config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
          }
      );
  
      function createDate (y, m, d, h, M, s, ms) {
          //can't just apply() to create a date:
          //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
          var date = new Date(y, m, d, h, M, s, ms);
  
          //the date constructor doesn't accept years < 1970
          if (y < 1970) {
              date.setFullYear(y);
          }
          return date;
      }
  
      function createUTCDate (y) {
          var date = new Date(Date.UTC.apply(null, arguments));
          if (y < 1970) {
              date.setUTCFullYear(y);
          }
          return date;
      }
  
      addFormatToken(0, ['YY', 2], 0, function () {
          return this.year() % 100;
      });
  
      addFormatToken(0, ['YYYY',   4],       0, 'year');
      addFormatToken(0, ['YYYYY',  5],       0, 'year');
      addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
  
      // ALIASES
  
      addUnitAlias('year', 'y');
  
      // PARSING
  
      addRegexToken('Y',      matchSigned);
      addRegexToken('YY',     match1to2, match2);
      addRegexToken('YYYY',   match1to4, match4);
      addRegexToken('YYYYY',  match1to6, match6);
      addRegexToken('YYYYYY', match1to6, match6);
  
      addParseToken(['YYYYY', 'YYYYYY'], YEAR);
      addParseToken('YYYY', function (input, array) {
          array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input);
      });
      addParseToken('YY', function (input, array) {
          array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input);
      });
  
      // HELPERS
  
      function daysInYear(year) {
          return isLeapYear(year) ? 366 : 365;
      }
  
      function isLeapYear(year) {
          return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
      }
  
      // HOOKS
  
      utils_hooks__hooks.parseTwoDigitYear = function (input) {
          return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
      };
  
      // MOMENTS
  
      var getSetYear = makeGetSet('FullYear', false);
  
      function getIsLeapYear () {
          return isLeapYear(this.year());
      }
  
      addFormatToken('w', ['ww', 2], 'wo', 'week');
      addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
  
      // ALIASES
  
      addUnitAlias('week', 'w');
      addUnitAlias('isoWeek', 'W');
  
      // PARSING
  
      addRegexToken('w',  match1to2);
      addRegexToken('ww', match1to2, match2);
      addRegexToken('W',  match1to2);
      addRegexToken('WW', match1to2, match2);
  
      addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
          week[token.substr(0, 1)] = toInt(input);
      });
  
      // HELPERS
  
      // firstDayOfWeek       0 = sun, 6 = sat
      //                      the day of the week that starts the week
      //                      (usually sunday or monday)
      // firstDayOfWeekOfYear 0 = sun, 6 = sat
      //                      the first week is the week that contains the first
      //                      of this day of the week
      //                      (eg. ISO weeks use thursday (4))
      function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
          var end = firstDayOfWeekOfYear - firstDayOfWeek,
              daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
              adjustedMoment;
  
  
          if (daysToDayOfWeek > end) {
              daysToDayOfWeek -= 7;
          }
  
          if (daysToDayOfWeek < end - 7) {
              daysToDayOfWeek += 7;
          }
  
          adjustedMoment = local__createLocal(mom).add(daysToDayOfWeek, 'd');
          return {
              week: Math.ceil(adjustedMoment.dayOfYear() / 7),
              year: adjustedMoment.year()
          };
      }
  
      // LOCALES
  
      function localeWeek (mom) {
          return weekOfYear(mom, this._week.dow, this._week.doy).week;
      }
  
      var defaultLocaleWeek = {
          dow : 0, // Sunday is the first day of the week.
          doy : 6  // The week that contains Jan 1st is the first week of the year.
      };
  
      function localeFirstDayOfWeek () {
          return this._week.dow;
      }
  
      function localeFirstDayOfYear () {
          return this._week.doy;
      }
  
      // MOMENTS
  
      function getSetWeek (input) {
          var week = this.localeData().week(this);
          return input == null ? week : this.add((input - week) * 7, 'd');
      }
  
      function getSetISOWeek (input) {
          var week = weekOfYear(this, 1, 4).week;
          return input == null ? week : this.add((input - week) * 7, 'd');
      }
  
      addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
  
      // ALIASES
  
      addUnitAlias('dayOfYear', 'DDD');
  
      // PARSING
  
      addRegexToken('DDD',  match1to3);
      addRegexToken('DDDD', match3);
      addParseToken(['DDD', 'DDDD'], function (input, array, config) {
          config._dayOfYear = toInt(input);
      });
  
      // HELPERS
  
      //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
      function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
          var week1Jan = 6 + firstDayOfWeek - firstDayOfWeekOfYear, janX = createUTCDate(year, 0, 1 + week1Jan), d = janX.getUTCDay(), dayOfYear;
          if (d < firstDayOfWeek) {
              d += 7;
          }
  
          weekday = weekday != null ? 1 * weekday : firstDayOfWeek;
  
          dayOfYear = 1 + week1Jan + 7 * (week - 1) - d + weekday;
  
          return {
              year: dayOfYear > 0 ? year : year - 1,
              dayOfYear: dayOfYear > 0 ?  dayOfYear : daysInYear(year - 1) + dayOfYear
          };
      }
  
      // MOMENTS
  
      function getSetDayOfYear (input) {
          var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
          return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
      }
  
      // Pick the first defined of two or three arguments.
      function defaults(a, b, c) {
          if (a != null) {
              return a;
          }
          if (b != null) {
              return b;
          }
          return c;
      }
  
      function currentDateArray(config) {
          var now = new Date();
          if (config._useUTC) {
              return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()];
          }
          return [now.getFullYear(), now.getMonth(), now.getDate()];
      }
  
      // convert an array to a date.
      // the array should mirror the parameters below
      // note: all values past the year are optional and will default to the lowest possible value.
      // [year, month, day , hour, minute, second, millisecond]
      function configFromArray (config) {
          var i, date, input = [], currentDate, yearToUse;
  
          if (config._d) {
              return;
          }
  
          currentDate = currentDateArray(config);
  
          //compute day of the year from weeks and weekdays
          if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
              dayOfYearFromWeekInfo(config);
          }
  
          //if the day of the year is set, figure out what it is
          if (config._dayOfYear) {
              yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
  
              if (config._dayOfYear > daysInYear(yearToUse)) {
                  getParsingFlags(config)._overflowDayOfYear = true;
              }
  
              date = createUTCDate(yearToUse, 0, config._dayOfYear);
              config._a[MONTH] = date.getUTCMonth();
              config._a[DATE] = date.getUTCDate();
          }
  
          // Default to current date.
          // * if no year, month, day of month are given, default to today
          // * if day of month is given, default month and year
          // * if month is given, default only year
          // * if year is given, don't default anything
          for (i = 0; i < 3 && config._a[i] == null; ++i) {
              config._a[i] = input[i] = currentDate[i];
          }
  
          // Zero out whatever was not defaulted, including time
          for (; i < 7; i++) {
              config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
          }
  
          // Check for 24:00:00.000
          if (config._a[HOUR] === 24 &&
                  config._a[MINUTE] === 0 &&
                  config._a[SECOND] === 0 &&
                  config._a[MILLISECOND] === 0) {
              config._nextDay = true;
              config._a[HOUR] = 0;
          }
  
          config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
          // Apply timezone offset from input. The actual utcOffset can be changed
          // with parseZone.
          if (config._tzm != null) {
              config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
          }
  
          if (config._nextDay) {
              config._a[HOUR] = 24;
          }
      }
  
      function dayOfYearFromWeekInfo(config) {
          var w, weekYear, week, weekday, dow, doy, temp;
  
          w = config._w;
          if (w.GG != null || w.W != null || w.E != null) {
              dow = 1;
              doy = 4;
  
              // TODO: We need to take the current isoWeekYear, but that depends on
              // how we interpret now (local, utc, fixed offset). So create
              // a now version of current config (take local/utc/offset flags, and
              // create now).
              weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
              week = defaults(w.W, 1);
              weekday = defaults(w.E, 1);
          } else {
              dow = config._locale._week.dow;
              doy = config._locale._week.doy;
  
              weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
              week = defaults(w.w, 1);
  
              if (w.d != null) {
                  // weekday -- low day numbers are considered next week
                  weekday = w.d;
                  if (weekday < dow) {
                      ++week;
                  }
              } else if (w.e != null) {
                  // local weekday -- counting starts from begining of week
                  weekday = w.e + dow;
              } else {
                  // default to begining of week
                  weekday = dow;
              }
          }
          temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
  
          config._a[YEAR] = temp.year;
          config._dayOfYear = temp.dayOfYear;
      }
  
      utils_hooks__hooks.ISO_8601 = function () {};
  
      // date from string and format string
      function configFromStringAndFormat(config) {
          // TODO: Move this to another part of the creation flow to prevent circular deps
          if (config._f === utils_hooks__hooks.ISO_8601) {
              configFromISO(config);
              return;
          }
  
          config._a = [];
          getParsingFlags(config).empty = true;
  
          // This array is used to make a Date, either with `new Date` or `Date.UTC`
          var string = '' + config._i,
              i, parsedInput, tokens, token, skipped,
              stringLength = string.length,
              totalParsedInputLength = 0;
  
          tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
  
          for (i = 0; i < tokens.length; i++) {
              token = tokens[i];
              parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
              if (parsedInput) {
                  skipped = string.substr(0, string.indexOf(parsedInput));
                  if (skipped.length > 0) {
                      getParsingFlags(config).unusedInput.push(skipped);
                  }
                  string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
                  totalParsedInputLength += parsedInput.length;
              }
              // don't parse if it's not a known token
              if (formatTokenFunctions[token]) {
                  if (parsedInput) {
                      getParsingFlags(config).empty = false;
                  }
                  else {
                      getParsingFlags(config).unusedTokens.push(token);
                  }
                  addTimeToArrayFromToken(token, parsedInput, config);
              }
              else if (config._strict && !parsedInput) {
                  getParsingFlags(config).unusedTokens.push(token);
              }
          }
  
          // add remaining unparsed input length to the string
          getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
          if (string.length > 0) {
              getParsingFlags(config).unusedInput.push(string);
          }
  
          // clear _12h flag if hour is <= 12
          if (getParsingFlags(config).bigHour === true &&
                  config._a[HOUR] <= 12 &&
                  config._a[HOUR] > 0) {
              getParsingFlags(config).bigHour = undefined;
          }
          // handle meridiem
          config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
  
          configFromArray(config);
          checkOverflow(config);
      }
  
  
      function meridiemFixWrap (locale, hour, meridiem) {
          var isPm;
  
          if (meridiem == null) {
              // nothing to do
              return hour;
          }
          if (locale.meridiemHour != null) {
              return locale.meridiemHour(hour, meridiem);
          } else if (locale.isPM != null) {
              // Fallback
              isPm = locale.isPM(meridiem);
              if (isPm && hour < 12) {
                  hour += 12;
              }
              if (!isPm && hour === 12) {
                  hour = 0;
              }
              return hour;
          } else {
              // this is not supposed to happen
              return hour;
          }
      }
  
      function configFromStringAndArray(config) {
          var tempConfig,
              bestMoment,
  
              scoreToBeat,
              i,
              currentScore;
  
          if (config._f.length === 0) {
              getParsingFlags(config).invalidFormat = true;
              config._d = new Date(NaN);
              return;
          }
  
          for (i = 0; i < config._f.length; i++) {
              currentScore = 0;
              tempConfig = copyConfig({}, config);
              if (config._useUTC != null) {
                  tempConfig._useUTC = config._useUTC;
              }
              tempConfig._f = config._f[i];
              configFromStringAndFormat(tempConfig);
  
              if (!valid__isValid(tempConfig)) {
                  continue;
              }
  
              // if there is any input that was not parsed add a penalty for that format
              currentScore += getParsingFlags(tempConfig).charsLeftOver;
  
              //or tokens
              currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
  
              getParsingFlags(tempConfig).score = currentScore;
  
              if (scoreToBeat == null || currentScore < scoreToBeat) {
                  scoreToBeat = currentScore;
                  bestMoment = tempConfig;
              }
          }
  
          extend(config, bestMoment || tempConfig);
      }
  
      function configFromObject(config) {
          if (config._d) {
              return;
          }
  
          var i = normalizeObjectUnits(config._i);
          config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
  
          configFromArray(config);
      }
  
      function createFromConfig (config) {
          var res = new Moment(checkOverflow(prepareConfig(config)));
          if (res._nextDay) {
              // Adding is smart enough around DST
              res.add(1, 'd');
              res._nextDay = undefined;
          }
  
          return res;
      }
  
      function prepareConfig (config) {
          var input = config._i,
              format = config._f;
  
          config._locale = config._locale || locale_locales__getLocale(config._l);
  
          if (input === null || (format === undefined && input === '')) {
              return valid__createInvalid({nullInput: true});
          }
  
          if (typeof input === 'string') {
              config._i = input = config._locale.preparse(input);
          }
  
          if (isMoment(input)) {
              return new Moment(checkOverflow(input));
          } else if (isArray(format)) {
              configFromStringAndArray(config);
          } else if (format) {
              configFromStringAndFormat(config);
          } else if (isDate(input)) {
              config._d = input;
          } else {
              configFromInput(config);
          }
  
          return config;
      }
  
      function configFromInput(config) {
          var input = config._i;
          if (input === undefined) {
              config._d = new Date();
          } else if (isDate(input)) {
              config._d = new Date(+input);
          } else if (typeof input === 'string') {
              configFromString(config);
          } else if (isArray(input)) {
              config._a = map(input.slice(0), function (obj) {
                  return parseInt(obj, 10);
              });
              configFromArray(config);
          } else if (typeof(input) === 'object') {
              configFromObject(config);
          } else if (typeof(input) === 'number') {
              // from milliseconds
              config._d = new Date(input);
          } else {
              utils_hooks__hooks.createFromInputFallback(config);
          }
      }
  
      function createLocalOrUTC (input, format, locale, strict, isUTC) {
          var c = {};
  
          if (typeof(locale) === 'boolean') {
              strict = locale;
              locale = undefined;
          }
          // object construction must be done this way.
          // https://github.com/moment/moment/issues/1423
          c._isAMomentObject = true;
          c._useUTC = c._isUTC = isUTC;
          c._l = locale;
          c._i = input;
          c._f = format;
          c._strict = strict;
  
          return createFromConfig(c);
      }
  
      function local__createLocal (input, format, locale, strict) {
          return createLocalOrUTC(input, format, locale, strict, false);
      }
  
      var prototypeMin = deprecate(
           'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
           function () {
               var other = local__createLocal.apply(null, arguments);
               return other < this ? this : other;
           }
       );
  
      var prototypeMax = deprecate(
          'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
          function () {
              var other = local__createLocal.apply(null, arguments);
              return other > this ? this : other;
          }
      );
  
      // Pick a moment m from moments so that m[fn](other) is true for all
      // other. This relies on the function fn to be transitive.
      //
      // moments should either be an array of moment objects or an array, whose
      // first element is an array of moment objects.
      function pickBy(fn, moments) {
          var res, i;
          if (moments.length === 1 && isArray(moments[0])) {
              moments = moments[0];
          }
          if (!moments.length) {
              return local__createLocal();
          }
          res = moments[0];
          for (i = 1; i < moments.length; ++i) {
              if (!moments[i].isValid() || moments[i][fn](res)) {
                  res = moments[i];
              }
          }
          return res;
      }
  
      // TODO: Use [].sort instead?
      function min () {
          var args = [].slice.call(arguments, 0);
  
          return pickBy('isBefore', args);
      }
  
      function max () {
          var args = [].slice.call(arguments, 0);
  
          return pickBy('isAfter', args);
      }
  
      function Duration (duration) {
          var normalizedInput = normalizeObjectUnits(duration),
              years = normalizedInput.year || 0,
              quarters = normalizedInput.quarter || 0,
              months = normalizedInput.month || 0,
              weeks = normalizedInput.week || 0,
              days = normalizedInput.day || 0,
              hours = normalizedInput.hour || 0,
              minutes = normalizedInput.minute || 0,
              seconds = normalizedInput.second || 0,
              milliseconds = normalizedInput.millisecond || 0;
  
          // representation for dateAddRemove
          this._milliseconds = +milliseconds +
              seconds * 1e3 + // 1000
              minutes * 6e4 + // 1000 * 60
              hours * 36e5; // 1000 * 60 * 60
          // Because of dateAddRemove treats 24 hours as different from a
          // day when working around DST, we need to store them separately
          this._days = +days +
              weeks * 7;
          // It is impossible translate months into days without knowing
          // which months you are are talking about, so we have to store
          // it separately.
          this._months = +months +
              quarters * 3 +
              years * 12;
  
          this._data = {};
  
          this._locale = locale_locales__getLocale();
  
          this._bubble();
      }
  
      function isDuration (obj) {
          return obj instanceof Duration;
      }
  
      function offset (token, separator) {
          addFormatToken(token, 0, 0, function () {
              var offset = this.utcOffset();
              var sign = '+';
              if (offset < 0) {
                  offset = -offset;
                  sign = '-';
              }
              return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
          });
      }
  
      offset('Z', ':');
      offset('ZZ', '');
  
      // PARSING
  
      addRegexToken('Z',  matchOffset);
      addRegexToken('ZZ', matchOffset);
      addParseToken(['Z', 'ZZ'], function (input, array, config) {
          config._useUTC = true;
          config._tzm = offsetFromString(input);
      });
  
      // HELPERS
  
      // timezone chunker
      // '+10:00' > ['10',  '00']
      // '-1530'  > ['-15', '30']
      var chunkOffset = /([\+\-]|\d\d)/gi;
  
      function offsetFromString(string) {
          var matches = ((string || '').match(matchOffset) || []);
          var chunk   = matches[matches.length - 1] || [];
          var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
          var minutes = +(parts[1] * 60) + toInt(parts[2]);
  
          return parts[0] === '+' ? minutes : -minutes;
      }
  
      // Return a moment from input, that is local/utc/zone equivalent to model.
      function cloneWithOffset(input, model) {
          var res, diff;
          if (model._isUTC) {
              res = model.clone();
              diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - (+res);
              // Use low-level api, because this fn is low-level api.
              res._d.setTime(+res._d + diff);
              utils_hooks__hooks.updateOffset(res, false);
              return res;
          } else {
              return local__createLocal(input).local();
          }
      }
  
      function getDateOffset (m) {
          // On Firefox.24 Date#getTimezoneOffset returns a floating point.
          // https://github.com/moment/moment/pull/1871
          return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
      }
  
      // HOOKS
  
      // This function will be called whenever a moment is mutated.
      // It is intended to keep the offset in sync with the timezone.
      utils_hooks__hooks.updateOffset = function () {};
  
      // MOMENTS
  
      // keepLocalTime = true means only change the timezone, without
      // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
      // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
      // +0200, so we adjust the time as needed, to be valid.
      //
      // Keeping the time actually adds/subtracts (one hour)
      // from the actual represented time. That is why we call updateOffset
      // a second time. In case it wants us to change the offset again
      // _changeInProgress == true case, then we have to adjust, because
      // there is no such time in the given timezone.
      function getSetOffset (input, keepLocalTime) {
          var offset = this._offset || 0,
              localAdjust;
          if (input != null) {
              if (typeof input === 'string') {
                  input = offsetFromString(input);
              }
              if (Math.abs(input) < 16) {
                  input = input * 60;
              }
              if (!this._isUTC && keepLocalTime) {
                  localAdjust = getDateOffset(this);
              }
              this._offset = input;
              this._isUTC = true;
              if (localAdjust != null) {
                  this.add(localAdjust, 'm');
              }
              if (offset !== input) {
                  if (!keepLocalTime || this._changeInProgress) {
                      add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false);
                  } else if (!this._changeInProgress) {
                      this._changeInProgress = true;
                      utils_hooks__hooks.updateOffset(this, true);
                      this._changeInProgress = null;
                  }
              }
              return this;
          } else {
              return this._isUTC ? offset : getDateOffset(this);
          }
      }
  
      function getSetZone (input, keepLocalTime) {
          if (input != null) {
              if (typeof input !== 'string') {
                  input = -input;
              }
  
              this.utcOffset(input, keepLocalTime);
  
              return this;
          } else {
              return -this.utcOffset();
          }
      }
  
      function setOffsetToUTC (keepLocalTime) {
          return this.utcOffset(0, keepLocalTime);
      }
  
      function setOffsetToLocal (keepLocalTime) {
          if (this._isUTC) {
              this.utcOffset(0, keepLocalTime);
              this._isUTC = false;
  
              if (keepLocalTime) {
                  this.subtract(getDateOffset(this), 'm');
              }
          }
          return this;
      }
  
      function setOffsetToParsedOffset () {
          if (this._tzm) {
              this.utcOffset(this._tzm);
          } else if (typeof this._i === 'string') {
              this.utcOffset(offsetFromString(this._i));
          }
          return this;
      }
  
      function hasAlignedHourOffset (input) {
          input = input ? local__createLocal(input).utcOffset() : 0;
  
          return (this.utcOffset() - input) % 60 === 0;
      }
  
      function isDaylightSavingTime () {
          return (
              this.utcOffset() > this.clone().month(0).utcOffset() ||
              this.utcOffset() > this.clone().month(5).utcOffset()
          );
      }
  
      function isDaylightSavingTimeShifted () {
          if (typeof this._isDSTShifted !== 'undefined') {
              return this._isDSTShifted;
          }
  
          var c = {};
  
          copyConfig(c, this);
          c = prepareConfig(c);
  
          if (c._a) {
              var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
              this._isDSTShifted = this.isValid() &&
                  compareArrays(c._a, other.toArray()) > 0;
          } else {
              this._isDSTShifted = false;
          }
  
          return this._isDSTShifted;
      }
  
      function isLocal () {
          return !this._isUTC;
      }
  
      function isUtcOffset () {
          return this._isUTC;
      }
  
      function isUtc () {
          return this._isUTC && this._offset === 0;
      }
  
      var aspNetRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/;
  
      // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
      // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
      var create__isoRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/;
  
      function create__createDuration (input, key) {
          var duration = input,
              // matching against regexp is expensive, do it on demand
              match = null,
              sign,
              ret,
              diffRes;
  
          if (isDuration(input)) {
              duration = {
                  ms : input._milliseconds,
                  d  : input._days,
                  M  : input._months
              };
          } else if (typeof input === 'number') {
              duration = {};
              if (key) {
                  duration[key] = input;
              } else {
                  duration.milliseconds = input;
              }
          } else if (!!(match = aspNetRegex.exec(input))) {
              sign = (match[1] === '-') ? -1 : 1;
              duration = {
                  y  : 0,
                  d  : toInt(match[DATE])        * sign,
                  h  : toInt(match[HOUR])        * sign,
                  m  : toInt(match[MINUTE])      * sign,
                  s  : toInt(match[SECOND])      * sign,
                  ms : toInt(match[MILLISECOND]) * sign
              };
          } else if (!!(match = create__isoRegex.exec(input))) {
              sign = (match[1] === '-') ? -1 : 1;
              duration = {
                  y : parseIso(match[2], sign),
                  M : parseIso(match[3], sign),
                  d : parseIso(match[4], sign),
                  h : parseIso(match[5], sign),
                  m : parseIso(match[6], sign),
                  s : parseIso(match[7], sign),
                  w : parseIso(match[8], sign)
              };
          } else if (duration == null) {// checks for null or undefined
              duration = {};
          } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
              diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
  
              duration = {};
              duration.ms = diffRes.milliseconds;
              duration.M = diffRes.months;
          }
  
          ret = new Duration(duration);
  
          if (isDuration(input) && hasOwnProp(input, '_locale')) {
              ret._locale = input._locale;
          }
  
          return ret;
      }
  
      create__createDuration.fn = Duration.prototype;
  
      function parseIso (inp, sign) {
          // We'd normally use ~~inp for this, but unfortunately it also
          // converts floats to ints.
          // inp may be undefined, so careful calling replace on it.
          var res = inp && parseFloat(inp.replace(',', '.'));
          // apply sign while we're at it
          return (isNaN(res) ? 0 : res) * sign;
      }
  
      function positiveMomentsDifference(base, other) {
          var res = {milliseconds: 0, months: 0};
  
          res.months = other.month() - base.month() +
              (other.year() - base.year()) * 12;
          if (base.clone().add(res.months, 'M').isAfter(other)) {
              --res.months;
          }
  
          res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
  
          return res;
      }
  
      function momentsDifference(base, other) {
          var res;
          other = cloneWithOffset(other, base);
          if (base.isBefore(other)) {
              res = positiveMomentsDifference(base, other);
          } else {
              res = positiveMomentsDifference(other, base);
              res.milliseconds = -res.milliseconds;
              res.months = -res.months;
          }
  
          return res;
      }
  
      function createAdder(direction, name) {
          return function (val, period) {
              var dur, tmp;
              //invert the arguments, but complain about it
              if (period !== null && !isNaN(+period)) {
                  deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
                  tmp = val; val = period; period = tmp;
              }
  
              val = typeof val === 'string' ? +val : val;
              dur = create__createDuration(val, period);
              add_subtract__addSubtract(this, dur, direction);
              return this;
          };
      }
  
      function add_subtract__addSubtract (mom, duration, isAdding, updateOffset) {
          var milliseconds = duration._milliseconds,
              days = duration._days,
              months = duration._months;
          updateOffset = updateOffset == null ? true : updateOffset;
  
          if (milliseconds) {
              mom._d.setTime(+mom._d + milliseconds * isAdding);
          }
          if (days) {
              get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding);
          }
          if (months) {
              setMonth(mom, get_set__get(mom, 'Month') + months * isAdding);
          }
          if (updateOffset) {
              utils_hooks__hooks.updateOffset(mom, days || months);
          }
      }
  
      var add_subtract__add      = createAdder(1, 'add');
      var add_subtract__subtract = createAdder(-1, 'subtract');
  
      function moment_calendar__calendar (time, formats) {
          // We want to compare the start of today, vs this.
          // Getting start-of-today depends on whether we're local/utc/offset or not.
          var now = time || local__createLocal(),
              sod = cloneWithOffset(now, this).startOf('day'),
              diff = this.diff(sod, 'days', true),
              format = diff < -6 ? 'sameElse' :
                  diff < -1 ? 'lastWeek' :
                  diff < 0 ? 'lastDay' :
                  diff < 1 ? 'sameDay' :
                  diff < 2 ? 'nextDay' :
                  diff < 7 ? 'nextWeek' : 'sameElse';
          return this.format(formats && formats[format] || this.localeData().calendar(format, this, local__createLocal(now)));
      }
  
      function clone () {
          return new Moment(this);
      }
  
      function isAfter (input, units) {
          var inputMs;
          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
          if (units === 'millisecond') {
              input = isMoment(input) ? input : local__createLocal(input);
              return +this > +input;
          } else {
              inputMs = isMoment(input) ? +input : +local__createLocal(input);
              return inputMs < +this.clone().startOf(units);
          }
      }
  
      function isBefore (input, units) {
          var inputMs;
          units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
          if (units === 'millisecond') {
              input = isMoment(input) ? input : local__createLocal(input);
              return +this < +input;
          } else {
              inputMs = isMoment(input) ? +input : +local__createLocal(input);
              return +this.clone().endOf(units) < inputMs;
          }
      }
  
      function isBetween (from, to, units) {
          return this.isAfter(from, units) && this.isBefore(to, units);
      }
  
      function isSame (input, units) {
          var inputMs;
          units = normalizeUnits(units || 'millisecond');
          if (units === 'millisecond') {
              input = isMoment(input) ? input : local__createLocal(input);
              return +this === +input;
          } else {
              inputMs = +local__createLocal(input);
              return +(this.clone().startOf(units)) <= inputMs && inputMs <= +(this.clone().endOf(units));
          }
      }
  
      function diff (input, units, asFloat) {
          var that = cloneWithOffset(input, this),
              zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4,
              delta, output;
  
          units = normalizeUnits(units);
  
          if (units === 'year' || units === 'month' || units === 'quarter') {
              output = monthDiff(this, that);
              if (units === 'quarter') {
                  output = output / 3;
              } else if (units === 'year') {
                  output = output / 12;
              }
          } else {
              delta = this - that;
              output = units === 'second' ? delta / 1e3 : // 1000
                  units === 'minute' ? delta / 6e4 : // 1000 * 60
                  units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60
                  units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
                  units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
                  delta;
          }
          return asFloat ? output : absFloor(output);
      }
  
      function monthDiff (a, b) {
          // difference in months
          var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
              // b is in (anchor - 1 month, anchor + 1 month)
              anchor = a.clone().add(wholeMonthDiff, 'months'),
              anchor2, adjust;
  
          if (b - anchor < 0) {
              anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
              // linear across the month
              adjust = (b - anchor) / (anchor - anchor2);
          } else {
              anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
              // linear across the month
              adjust = (b - anchor) / (anchor2 - anchor);
          }
  
          return -(wholeMonthDiff + adjust);
      }
  
      utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
  
      function toString () {
          return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
      }
  
      function moment_format__toISOString () {
          var m = this.clone().utc();
          if (0 < m.year() && m.year() <= 9999) {
              if ('function' === typeof Date.prototype.toISOString) {
                  // native implementation is ~50x faster, use it when we can
                  return this.toDate().toISOString();
              } else {
                  return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
              }
          } else {
              return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
          }
      }
  
      function format (inputString) {
          var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
          return this.localeData().postformat(output);
      }
  
      function from (time, withoutSuffix) {
          if (!this.isValid()) {
              return this.localeData().invalidDate();
          }
          return create__createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
      }
  
      function fromNow (withoutSuffix) {
          return this.from(local__createLocal(), withoutSuffix);
      }
  
      function to (time, withoutSuffix) {
          if (!this.isValid()) {
              return this.localeData().invalidDate();
          }
          return create__createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
      }
  
      function toNow (withoutSuffix) {
          return this.to(local__createLocal(), withoutSuffix);
      }
  
      function locale (key) {
          var newLocaleData;
  
          if (key === undefined) {
              return this._locale._abbr;
          } else {
              newLocaleData = locale_locales__getLocale(key);
              if (newLocaleData != null) {
                  this._locale = newLocaleData;
              }
              return this;
          }
      }
  
      var lang = deprecate(
          'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
          function (key) {
              if (key === undefined) {
                  return this.localeData();
              } else {
                  return this.locale(key);
              }
          }
      );
  
      function localeData () {
          return this._locale;
      }
  
      function startOf (units) {
          units = normalizeUnits(units);
          // the following switch intentionally omits break keywords
          // to utilize falling through the cases.
          switch (units) {
          case 'year':
              this.month(0);
              /* falls through */
          case 'quarter':
          case 'month':
              this.date(1);
              /* falls through */
          case 'week':
          case 'isoWeek':
          case 'day':
              this.hours(0);
              /* falls through */
          case 'hour':
              this.minutes(0);
              /* falls through */
          case 'minute':
              this.seconds(0);
              /* falls through */
          case 'second':
              this.milliseconds(0);
          }
  
          // weeks are a special case
          if (units === 'week') {
              this.weekday(0);
          }
          if (units === 'isoWeek') {
              this.isoWeekday(1);
          }
  
          // quarters are also special
          if (units === 'quarter') {
              this.month(Math.floor(this.month() / 3) * 3);
          }
  
          return this;
      }
  
      function endOf (units) {
          units = normalizeUnits(units);
          if (units === undefined || units === 'millisecond') {
              return this;
          }
          return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
      }
  
      function to_type__valueOf () {
          return +this._d - ((this._offset || 0) * 60000);
      }
  
      function unix () {
          return Math.floor(+this / 1000);
      }
  
      function toDate () {
          return this._offset ? new Date(+this) : this._d;
      }
  
      function toArray () {
          var m = this;
          return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
      }
  
      function toObject () {
          var m = this;
          return {
              years: m.year(),
              months: m.month(),
              date: m.date(),
              hours: m.hours(),
              minutes: m.minutes(),
              seconds: m.seconds(),
              milliseconds: m.milliseconds()
          };
      }
  
      function moment_valid__isValid () {
          return valid__isValid(this);
      }
  
      function parsingFlags () {
          return extend({}, getParsingFlags(this));
      }
  
      function invalidAt () {
          return getParsingFlags(this).overflow;
      }
  
      addFormatToken(0, ['gg', 2], 0, function () {
          return this.weekYear() % 100;
      });
  
      addFormatToken(0, ['GG', 2], 0, function () {
          return this.isoWeekYear() % 100;
      });
  
      function addWeekYearFormatToken (token, getter) {
          addFormatToken(0, [token, token.length], 0, getter);
      }
  
      addWeekYearFormatToken('gggg',     'weekYear');
      addWeekYearFormatToken('ggggg',    'weekYear');
      addWeekYearFormatToken('GGGG',  'isoWeekYear');
      addWeekYearFormatToken('GGGGG', 'isoWeekYear');
  
      // ALIASES
  
      addUnitAlias('weekYear', 'gg');
      addUnitAlias('isoWeekYear', 'GG');
  
      // PARSING
  
      addRegexToken('G',      matchSigned);
      addRegexToken('g',      matchSigned);
      addRegexToken('GG',     match1to2, match2);
      addRegexToken('gg',     match1to2, match2);
      addRegexToken('GGGG',   match1to4, match4);
      addRegexToken('gggg',   match1to4, match4);
      addRegexToken('GGGGG',  match1to6, match6);
      addRegexToken('ggggg',  match1to6, match6);
  
      addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
          week[token.substr(0, 2)] = toInt(input);
      });
  
      addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
          week[token] = utils_hooks__hooks.parseTwoDigitYear(input);
      });
  
      // HELPERS
  
      function weeksInYear(year, dow, doy) {
          return weekOfYear(local__createLocal([year, 11, 31 + dow - doy]), dow, doy).week;
      }
  
      // MOMENTS
  
      function getSetWeekYear (input) {
          var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
          return input == null ? year : this.add((input - year), 'y');
      }
  
      function getSetISOWeekYear (input) {
          var year = weekOfYear(this, 1, 4).year;
          return input == null ? year : this.add((input - year), 'y');
      }
  
      function getISOWeeksInYear () {
          return weeksInYear(this.year(), 1, 4);
      }
  
      function getWeeksInYear () {
          var weekInfo = this.localeData()._week;
          return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
      }
  
      addFormatToken('Q', 0, 0, 'quarter');
  
      // ALIASES
  
      addUnitAlias('quarter', 'Q');
  
      // PARSING
  
      addRegexToken('Q', match1);
      addParseToken('Q', function (input, array) {
          array[MONTH] = (toInt(input) - 1) * 3;
      });
  
      // MOMENTS
  
      function getSetQuarter (input) {
          return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
      }
  
      addFormatToken('D', ['DD', 2], 'Do', 'date');
  
      // ALIASES
  
      addUnitAlias('date', 'D');
  
      // PARSING
  
      addRegexToken('D',  match1to2);
      addRegexToken('DD', match1to2, match2);
      addRegexToken('Do', function (isStrict, locale) {
          return isStrict ? locale._ordinalParse : locale._ordinalParseLenient;
      });
  
      addParseToken(['D', 'DD'], DATE);
      addParseToken('Do', function (input, array) {
          array[DATE] = toInt(input.match(match1to2)[0], 10);
      });
  
      // MOMENTS
  
      var getSetDayOfMonth = makeGetSet('Date', true);
  
      addFormatToken('d', 0, 'do', 'day');
  
      addFormatToken('dd', 0, 0, function (format) {
          return this.localeData().weekdaysMin(this, format);
      });
  
      addFormatToken('ddd', 0, 0, function (format) {
          return this.localeData().weekdaysShort(this, format);
      });
  
      addFormatToken('dddd', 0, 0, function (format) {
          return this.localeData().weekdays(this, format);
      });
  
      addFormatToken('e', 0, 0, 'weekday');
      addFormatToken('E', 0, 0, 'isoWeekday');
  
      // ALIASES
  
      addUnitAlias('day', 'd');
      addUnitAlias('weekday', 'e');
      addUnitAlias('isoWeekday', 'E');
  
      // PARSING
  
      addRegexToken('d',    match1to2);
      addRegexToken('e',    match1to2);
      addRegexToken('E',    match1to2);
      addRegexToken('dd',   matchWord);
      addRegexToken('ddd',  matchWord);
      addRegexToken('dddd', matchWord);
  
      addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
          var weekday = config._locale.weekdaysParse(input);
          // if we didn't get a weekday name, mark the date as invalid
          if (weekday != null) {
              week.d = weekday;
          } else {
              getParsingFlags(config).invalidWeekday = input;
          }
      });
  
      addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
          week[token] = toInt(input);
      });
  
      // HELPERS
  
      function parseWeekday(input, locale) {
          if (typeof input !== 'string') {
              return input;
          }
  
          if (!isNaN(input)) {
              return parseInt(input, 10);
          }
  
          input = locale.weekdaysParse(input);
          if (typeof input === 'number') {
              return input;
          }
  
          return null;
      }
  
      // LOCALES
  
      var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
      function localeWeekdays (m) {
          return this._weekdays[m.day()];
      }
  
      var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
      function localeWeekdaysShort (m) {
          return this._weekdaysShort[m.day()];
      }
  
      var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
      function localeWeekdaysMin (m) {
          return this._weekdaysMin[m.day()];
      }
  
      function localeWeekdaysParse (weekdayName) {
          var i, mom, regex;
  
          this._weekdaysParse = this._weekdaysParse || [];
  
          for (i = 0; i < 7; i++) {
              // make the regex if we don't have it already
              if (!this._weekdaysParse[i]) {
                  mom = local__createLocal([2000, 1]).day(i);
                  regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
                  this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
              }
              // test the regex
              if (this._weekdaysParse[i].test(weekdayName)) {
                  return i;
              }
          }
      }
  
      // MOMENTS
  
      function getSetDayOfWeek (input) {
          var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
          if (input != null) {
              input = parseWeekday(input, this.localeData());
              return this.add(input - day, 'd');
          } else {
              return day;
          }
      }
  
      function getSetLocaleDayOfWeek (input) {
          var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
          return input == null ? weekday : this.add(input - weekday, 'd');
      }
  
      function getSetISODayOfWeek (input) {
          // behaves the same as moment#day except
          // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
          // as a setter, sunday should belong to the previous week.
          return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
      }
  
      addFormatToken('H', ['HH', 2], 0, 'hour');
      addFormatToken('h', ['hh', 2], 0, function () {
          return this.hours() % 12 || 12;
      });
  
      function meridiem (token, lowercase) {
          addFormatToken(token, 0, 0, function () {
              return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
          });
      }
  
      meridiem('a', true);
      meridiem('A', false);
  
      // ALIASES
  
      addUnitAlias('hour', 'h');
  
      // PARSING
  
      function matchMeridiem (isStrict, locale) {
          return locale._meridiemParse;
      }
  
      addRegexToken('a',  matchMeridiem);
      addRegexToken('A',  matchMeridiem);
      addRegexToken('H',  match1to2);
      addRegexToken('h',  match1to2);
      addRegexToken('HH', match1to2, match2);
      addRegexToken('hh', match1to2, match2);
  
      addParseToken(['H', 'HH'], HOUR);
      addParseToken(['a', 'A'], function (input, array, config) {
          config._isPm = config._locale.isPM(input);
          config._meridiem = input;
      });
      addParseToken(['h', 'hh'], function (input, array, config) {
          array[HOUR] = toInt(input);
          getParsingFlags(config).bigHour = true;
      });
  
      // LOCALES
  
      function localeIsPM (input) {
          // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
          // Using charAt should be more compatible.
          return ((input + '').toLowerCase().charAt(0) === 'p');
      }
  
      var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
      function localeMeridiem (hours, minutes, isLower) {
          if (hours > 11) {
              return isLower ? 'pm' : 'PM';
          } else {
              return isLower ? 'am' : 'AM';
          }
      }
  
  
      // MOMENTS
  
      // Setting the hour should keep the time, because the user explicitly
      // specified which hour he wants. So trying to maintain the same hour (in
      // a new timezone) makes sense. Adding/subtracting hours does not follow
      // this rule.
      var getSetHour = makeGetSet('Hours', true);
  
      addFormatToken('m', ['mm', 2], 0, 'minute');
  
      // ALIASES
  
      addUnitAlias('minute', 'm');
  
      // PARSING
  
      addRegexToken('m',  match1to2);
      addRegexToken('mm', match1to2, match2);
      addParseToken(['m', 'mm'], MINUTE);
  
      // MOMENTS
  
      var getSetMinute = makeGetSet('Minutes', false);
  
      addFormatToken('s', ['ss', 2], 0, 'second');
  
      // ALIASES
  
      addUnitAlias('second', 's');
  
      // PARSING
  
      addRegexToken('s',  match1to2);
      addRegexToken('ss', match1to2, match2);
      addParseToken(['s', 'ss'], SECOND);
  
      // MOMENTS
  
      var getSetSecond = makeGetSet('Seconds', false);
  
      addFormatToken('S', 0, 0, function () {
          return ~~(this.millisecond() / 100);
      });
  
      addFormatToken(0, ['SS', 2], 0, function () {
          return ~~(this.millisecond() / 10);
      });
  
      addFormatToken(0, ['SSS', 3], 0, 'millisecond');
      addFormatToken(0, ['SSSS', 4], 0, function () {
          return this.millisecond() * 10;
      });
      addFormatToken(0, ['SSSSS', 5], 0, function () {
          return this.millisecond() * 100;
      });
      addFormatToken(0, ['SSSSSS', 6], 0, function () {
          return this.millisecond() * 1000;
      });
      addFormatToken(0, ['SSSSSSS', 7], 0, function () {
          return this.millisecond() * 10000;
      });
      addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
          return this.millisecond() * 100000;
      });
      addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
          return this.millisecond() * 1000000;
      });
  
  
      // ALIASES
  
      addUnitAlias('millisecond', 'ms');
  
      // PARSING
  
      addRegexToken('S',    match1to3, match1);
      addRegexToken('SS',   match1to3, match2);
      addRegexToken('SSS',  match1to3, match3);
  
      var token;
      for (token = 'SSSS'; token.length <= 9; token += 'S') {
          addRegexToken(token, matchUnsigned);
      }
  
      function parseMs(input, array) {
          array[MILLISECOND] = toInt(('0.' + input) * 1000);
      }
  
      for (token = 'S'; token.length <= 9; token += 'S') {
          addParseToken(token, parseMs);
      }
      // MOMENTS
  
      var getSetMillisecond = makeGetSet('Milliseconds', false);
  
      addFormatToken('z',  0, 0, 'zoneAbbr');
      addFormatToken('zz', 0, 0, 'zoneName');
  
      // MOMENTS
  
      function getZoneAbbr () {
          return this._isUTC ? 'UTC' : '';
      }
  
      function getZoneName () {
          return this._isUTC ? 'Coordinated Universal Time' : '';
      }
  
      var momentPrototype__proto = Moment.prototype;
  
      momentPrototype__proto.add          = add_subtract__add;
      momentPrototype__proto.calendar     = moment_calendar__calendar;
      momentPrototype__proto.clone        = clone;
      momentPrototype__proto.diff         = diff;
      momentPrototype__proto.endOf        = endOf;
      momentPrototype__proto.format       = format;
      momentPrototype__proto.from         = from;
      momentPrototype__proto.fromNow      = fromNow;
      momentPrototype__proto.to           = to;
      momentPrototype__proto.toNow        = toNow;
      momentPrototype__proto.get          = getSet;
      momentPrototype__proto.invalidAt    = invalidAt;
      momentPrototype__proto.isAfter      = isAfter;
      momentPrototype__proto.isBefore     = isBefore;
      momentPrototype__proto.isBetween    = isBetween;
      momentPrototype__proto.isSame       = isSame;
      momentPrototype__proto.isValid      = moment_valid__isValid;
      momentPrototype__proto.lang         = lang;
      momentPrototype__proto.locale       = locale;
      momentPrototype__proto.localeData   = localeData;
      momentPrototype__proto.max          = prototypeMax;
      momentPrototype__proto.min          = prototypeMin;
      momentPrototype__proto.parsingFlags = parsingFlags;
      momentPrototype__proto.set          = getSet;
      momentPrototype__proto.startOf      = startOf;
      momentPrototype__proto.subtract     = add_subtract__subtract;
      momentPrototype__proto.toArray      = toArray;
      momentPrototype__proto.toObject     = toObject;
      momentPrototype__proto.toDate       = toDate;
      momentPrototype__proto.toISOString  = moment_format__toISOString;
      momentPrototype__proto.toJSON       = moment_format__toISOString;
      momentPrototype__proto.toString     = toString;
      momentPrototype__proto.unix         = unix;
      momentPrototype__proto.valueOf      = to_type__valueOf;
  
      // Year
      momentPrototype__proto.year       = getSetYear;
      momentPrototype__proto.isLeapYear = getIsLeapYear;
  
      // Week Year
      momentPrototype__proto.weekYear    = getSetWeekYear;
      momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
  
      // Quarter
      momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
  
      // Month
      momentPrototype__proto.month       = getSetMonth;
      momentPrototype__proto.daysInMonth = getDaysInMonth;
  
      // Week
      momentPrototype__proto.week           = momentPrototype__proto.weeks        = getSetWeek;
      momentPrototype__proto.isoWeek        = momentPrototype__proto.isoWeeks     = getSetISOWeek;
      momentPrototype__proto.weeksInYear    = getWeeksInYear;
      momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
  
      // Day
      momentPrototype__proto.date       = getSetDayOfMonth;
      momentPrototype__proto.day        = momentPrototype__proto.days             = getSetDayOfWeek;
      momentPrototype__proto.weekday    = getSetLocaleDayOfWeek;
      momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
      momentPrototype__proto.dayOfYear  = getSetDayOfYear;
  
      // Hour
      momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
  
      // Minute
      momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
  
      // Second
      momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
  
      // Millisecond
      momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
  
      // Offset
      momentPrototype__proto.utcOffset            = getSetOffset;
      momentPrototype__proto.utc                  = setOffsetToUTC;
      momentPrototype__proto.local                = setOffsetToLocal;
      momentPrototype__proto.parseZone            = setOffsetToParsedOffset;
      momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
      momentPrototype__proto.isDST                = isDaylightSavingTime;
      momentPrototype__proto.isDSTShifted         = isDaylightSavingTimeShifted;
      momentPrototype__proto.isLocal              = isLocal;
      momentPrototype__proto.isUtcOffset          = isUtcOffset;
      momentPrototype__proto.isUtc                = isUtc;
      momentPrototype__proto.isUTC                = isUtc;
  
      // Timezone
      momentPrototype__proto.zoneAbbr = getZoneAbbr;
      momentPrototype__proto.zoneName = getZoneName;
  
      // Deprecations
      momentPrototype__proto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
      momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
      momentPrototype__proto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);
      momentPrototype__proto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
  
      var momentPrototype = momentPrototype__proto;
  
      function moment__createUnix (input) {
          return local__createLocal(input * 1000);
      }
  
      function moment__createInZone () {
          return local__createLocal.apply(null, arguments).parseZone();
      }
  
      var defaultCalendar = {
          sameDay : '[Today at] LT',
          nextDay : '[Tomorrow at] LT',
          nextWeek : 'dddd [at] LT',
          lastDay : '[Yesterday at] LT',
          lastWeek : '[Last] dddd [at] LT',
          sameElse : 'L'
      };
  
      function locale_calendar__calendar (key, mom, now) {
          var output = this._calendar[key];
          return typeof output === 'function' ? output.call(mom, now) : output;
      }
  
      var defaultLongDateFormat = {
          LTS  : 'h:mm:ss A',
          LT   : 'h:mm A',
          L    : 'MM/DD/YYYY',
          LL   : 'MMMM D, YYYY',
          LLL  : 'MMMM D, YYYY h:mm A',
          LLLL : 'dddd, MMMM D, YYYY h:mm A'
      };
  
      function longDateFormat (key) {
          var format = this._longDateFormat[key],
              formatUpper = this._longDateFormat[key.toUpperCase()];
  
          if (format || !formatUpper) {
              return format;
          }
  
          this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
              return val.slice(1);
          });
  
          return this._longDateFormat[key];
      }
  
      var defaultInvalidDate = 'Invalid date';
  
      function invalidDate () {
          return this._invalidDate;
      }
  
      var defaultOrdinal = '%d';
      var defaultOrdinalParse = /\d{1,2}/;
  
      function ordinal (number) {
          return this._ordinal.replace('%d', number);
      }
  
      function preParsePostFormat (string) {
          return string;
      }
  
      var defaultRelativeTime = {
          future : 'in %s',
          past   : '%s ago',
          s  : 'a few seconds',
          m  : 'a minute',
          mm : '%d minutes',
          h  : 'an hour',
          hh : '%d hours',
          d  : 'a day',
          dd : '%d days',
          M  : 'a month',
          MM : '%d months',
          y  : 'a year',
          yy : '%d years'
      };
  
      function relative__relativeTime (number, withoutSuffix, string, isFuture) {
          var output = this._relativeTime[string];
          return (typeof output === 'function') ?
              output(number, withoutSuffix, string, isFuture) :
              output.replace(/%d/i, number);
      }
  
      function pastFuture (diff, output) {
          var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
          return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
      }
  
      function locale_set__set (config) {
          var prop, i;
          for (i in config) {
              prop = config[i];
              if (typeof prop === 'function') {
                  this[i] = prop;
              } else {
                  this['_' + i] = prop;
              }
          }
          // Lenient ordinal parsing accepts just a number in addition to
          // number + (possibly) stuff coming from _ordinalParseLenient.
          this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + (/\d{1,2}/).source);
      }
  
      var prototype__proto = Locale.prototype;
  
      prototype__proto._calendar       = defaultCalendar;
      prototype__proto.calendar        = locale_calendar__calendar;
      prototype__proto._longDateFormat = defaultLongDateFormat;
      prototype__proto.longDateFormat  = longDateFormat;
      prototype__proto._invalidDate    = defaultInvalidDate;
      prototype__proto.invalidDate     = invalidDate;
      prototype__proto._ordinal        = defaultOrdinal;
      prototype__proto.ordinal         = ordinal;
      prototype__proto._ordinalParse   = defaultOrdinalParse;
      prototype__proto.preparse        = preParsePostFormat;
      prototype__proto.postformat      = preParsePostFormat;
      prototype__proto._relativeTime   = defaultRelativeTime;
      prototype__proto.relativeTime    = relative__relativeTime;
      prototype__proto.pastFuture      = pastFuture;
      prototype__proto.set             = locale_set__set;
  
      // Month
      prototype__proto.months       =        localeMonths;
      prototype__proto._months      = defaultLocaleMonths;
      prototype__proto.monthsShort  =        localeMonthsShort;
      prototype__proto._monthsShort = defaultLocaleMonthsShort;
      prototype__proto.monthsParse  =        localeMonthsParse;
  
      // Week
      prototype__proto.week = localeWeek;
      prototype__proto._week = defaultLocaleWeek;
      prototype__proto.firstDayOfYear = localeFirstDayOfYear;
      prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
  
      // Day of Week
      prototype__proto.weekdays       =        localeWeekdays;
      prototype__proto._weekdays      = defaultLocaleWeekdays;
      prototype__proto.weekdaysMin    =        localeWeekdaysMin;
      prototype__proto._weekdaysMin   = defaultLocaleWeekdaysMin;
      prototype__proto.weekdaysShort  =        localeWeekdaysShort;
      prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
      prototype__proto.weekdaysParse  =        localeWeekdaysParse;
  
      // Hours
      prototype__proto.isPM = localeIsPM;
      prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
      prototype__proto.meridiem = localeMeridiem;
  
      function lists__get (format, index, field, setter) {
          var locale = locale_locales__getLocale();
          var utc = create_utc__createUTC().set(setter, index);
          return locale[field](utc, format);
      }
  
      function list (format, index, field, count, setter) {
          if (typeof format === 'number') {
              index = format;
              format = undefined;
          }
  
          format = format || '';
  
          if (index != null) {
              return lists__get(format, index, field, setter);
          }
  
          var i;
          var out = [];
          for (i = 0; i < count; i++) {
              out[i] = lists__get(format, i, field, setter);
          }
          return out;
      }
  
      function lists__listMonths (format, index) {
          return list(format, index, 'months', 12, 'month');
      }
  
      function lists__listMonthsShort (format, index) {
          return list(format, index, 'monthsShort', 12, 'month');
      }
  
      function lists__listWeekdays (format, index) {
          return list(format, index, 'weekdays', 7, 'day');
      }
  
      function lists__listWeekdaysShort (format, index) {
          return list(format, index, 'weekdaysShort', 7, 'day');
      }
  
      function lists__listWeekdaysMin (format, index) {
          return list(format, index, 'weekdaysMin', 7, 'day');
      }
  
      locale_locales__getSetGlobalLocale('en', {
          ordinalParse: /\d{1,2}(th|st|nd|rd)/,
          ordinal : function (number) {
              var b = number % 10,
                  output = (toInt(number % 100 / 10) === 1) ? 'th' :
                  (b === 1) ? 'st' :
                  (b === 2) ? 'nd' :
                  (b === 3) ? 'rd' : 'th';
              return number + output;
          }
      });
  
      // Side effect imports
      utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
      utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
  
      var mathAbs = Math.abs;
  
      function duration_abs__abs () {
          var data           = this._data;
  
          this._milliseconds = mathAbs(this._milliseconds);
          this._days         = mathAbs(this._days);
          this._months       = mathAbs(this._months);
  
          data.milliseconds  = mathAbs(data.milliseconds);
          data.seconds       = mathAbs(data.seconds);
          data.minutes       = mathAbs(data.minutes);
          data.hours         = mathAbs(data.hours);
          data.months        = mathAbs(data.months);
          data.years         = mathAbs(data.years);
  
          return this;
      }
  
      function duration_add_subtract__addSubtract (duration, input, value, direction) {
          var other = create__createDuration(input, value);
  
          duration._milliseconds += direction * other._milliseconds;
          duration._days         += direction * other._days;
          duration._months       += direction * other._months;
  
          return duration._bubble();
      }
  
      // supports only 2.0-style add(1, 's') or add(duration)
      function duration_add_subtract__add (input, value) {
          return duration_add_subtract__addSubtract(this, input, value, 1);
      }
  
      // supports only 2.0-style subtract(1, 's') or subtract(duration)
      function duration_add_subtract__subtract (input, value) {
          return duration_add_subtract__addSubtract(this, input, value, -1);
      }
  
      function absCeil (number) {
          if (number < 0) {
              return Math.floor(number);
          } else {
              return Math.ceil(number);
          }
      }
  
      function bubble () {
          var milliseconds = this._milliseconds;
          var days         = this._days;
          var months       = this._months;
          var data         = this._data;
          var seconds, minutes, hours, years, monthsFromDays;
  
          // if we have a mix of positive and negative values, bubble down first
          // check: https://github.com/moment/moment/issues/2166
          if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
                  (milliseconds <= 0 && days <= 0 && months <= 0))) {
              milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
              days = 0;
              months = 0;
          }
  
          // The following code bubbles up values, see the tests for
          // examples of what that means.
          data.milliseconds = milliseconds % 1000;
  
          seconds           = absFloor(milliseconds / 1000);
          data.seconds      = seconds % 60;
  
          minutes           = absFloor(seconds / 60);
          data.minutes      = minutes % 60;
  
          hours             = absFloor(minutes / 60);
          data.hours        = hours % 24;
  
          days += absFloor(hours / 24);
  
          // convert days to months
          monthsFromDays = absFloor(daysToMonths(days));
          months += monthsFromDays;
          days -= absCeil(monthsToDays(monthsFromDays));
  
          // 12 months -> 1 year
          years = absFloor(months / 12);
          months %= 12;
  
          data.days   = days;
          data.months = months;
          data.years  = years;
  
          return this;
      }
  
      function daysToMonths (days) {
          // 400 years have 146097 days (taking into account leap year rules)
          // 400 years have 12 months === 4800
          return days * 4800 / 146097;
      }
  
      function monthsToDays (months) {
          // the reverse of daysToMonths
          return months * 146097 / 4800;
      }
  
      function as (units) {
          var days;
          var months;
          var milliseconds = this._milliseconds;
  
          units = normalizeUnits(units);
  
          if (units === 'month' || units === 'year') {
              days   = this._days   + milliseconds / 864e5;
              months = this._months + daysToMonths(days);
              return units === 'month' ? months : months / 12;
          } else {
              // handle milliseconds separately because of floating point math errors (issue #1867)
              days = this._days + Math.round(monthsToDays(this._months));
              switch (units) {
                  case 'week'   : return days / 7     + milliseconds / 6048e5;
                  case 'day'    : return days         + milliseconds / 864e5;
                  case 'hour'   : return days * 24    + milliseconds / 36e5;
                  case 'minute' : return days * 1440  + milliseconds / 6e4;
                  case 'second' : return days * 86400 + milliseconds / 1000;
                  // Math.floor prevents floating point math errors here
                  case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
                  default: throw new Error('Unknown unit ' + units);
              }
          }
      }
  
      // TODO: Use this.as('ms')?
      function duration_as__valueOf () {
          return (
              this._milliseconds +
              this._days * 864e5 +
              (this._months % 12) * 2592e6 +
              toInt(this._months / 12) * 31536e6
          );
      }
  
      function makeAs (alias) {
          return function () {
              return this.as(alias);
          };
      }
  
      var asMilliseconds = makeAs('ms');
      var asSeconds      = makeAs('s');
      var asMinutes      = makeAs('m');
      var asHours        = makeAs('h');
      var asDays         = makeAs('d');
      var asWeeks        = makeAs('w');
      var asMonths       = makeAs('M');
      var asYears        = makeAs('y');
  
      function duration_get__get (units) {
          units = normalizeUnits(units);
          return this[units + 's']();
      }
  
      function makeGetter(name) {
          return function () {
              return this._data[name];
          };
      }
  
      var milliseconds = makeGetter('milliseconds');
      var seconds      = makeGetter('seconds');
      var minutes      = makeGetter('minutes');
      var hours        = makeGetter('hours');
      var days         = makeGetter('days');
      var months       = makeGetter('months');
      var years        = makeGetter('years');
  
      function weeks () {
          return absFloor(this.days() / 7);
      }
  
      var round = Math.round;
      var thresholds = {
          s: 45,  // seconds to minute
          m: 45,  // minutes to hour
          h: 22,  // hours to day
          d: 26,  // days to month
          M: 11   // months to year
      };
  
      // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
      function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
          return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
      }
  
      function duration_humanize__relativeTime (posNegDuration, withoutSuffix, locale) {
          var duration = create__createDuration(posNegDuration).abs();
          var seconds  = round(duration.as('s'));
          var minutes  = round(duration.as('m'));
          var hours    = round(duration.as('h'));
          var days     = round(duration.as('d'));
          var months   = round(duration.as('M'));
          var years    = round(duration.as('y'));
  
          var a = seconds < thresholds.s && ['s', seconds]  ||
                  minutes === 1          && ['m']           ||
                  minutes < thresholds.m && ['mm', minutes] ||
                  hours   === 1          && ['h']           ||
                  hours   < thresholds.h && ['hh', hours]   ||
                  days    === 1          && ['d']           ||
                  days    < thresholds.d && ['dd', days]    ||
                  months  === 1          && ['M']           ||
                  months  < thresholds.M && ['MM', months]  ||
                  years   === 1          && ['y']           || ['yy', years];
  
          a[2] = withoutSuffix;
          a[3] = +posNegDuration > 0;
          a[4] = locale;
          return substituteTimeAgo.apply(null, a);
      }
  
      // This function allows you to set a threshold for relative time strings
      function duration_humanize__getSetRelativeTimeThreshold (threshold, limit) {
          if (thresholds[threshold] === undefined) {
              return false;
          }
          if (limit === undefined) {
              return thresholds[threshold];
          }
          thresholds[threshold] = limit;
          return true;
      }
  
      function humanize (withSuffix) {
          var locale = this.localeData();
          var output = duration_humanize__relativeTime(this, !withSuffix, locale);
  
          if (withSuffix) {
              output = locale.pastFuture(+this, output);
          }
  
          return locale.postformat(output);
      }
  
      var iso_string__abs = Math.abs;
  
      function iso_string__toISOString() {
          // for ISO strings we do not use the normal bubbling rules:
          //  * milliseconds bubble up until they become hours
          //  * days do not bubble at all
          //  * months bubble up until they become years
          // This is because there is no context-free conversion between hours and days
          // (think of clock changes)
          // and also not between days and months (28-31 days per month)
          var seconds = iso_string__abs(this._milliseconds) / 1000;
          var days         = iso_string__abs(this._days);
          var months       = iso_string__abs(this._months);
          var minutes, hours, years;
  
          // 3600 seconds -> 60 minutes -> 1 hour
          minutes           = absFloor(seconds / 60);
          hours             = absFloor(minutes / 60);
          seconds %= 60;
          minutes %= 60;
  
          // 12 months -> 1 year
          years  = absFloor(months / 12);
          months %= 12;
  
  
          // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
          var Y = years;
          var M = months;
          var D = days;
          var h = hours;
          var m = minutes;
          var s = seconds;
          var total = this.asSeconds();
  
          if (!total) {
              // this is the same as C#'s (Noda) and python (isodate)...
              // but not other JS (goog.date)
              return 'P0D';
          }
  
          return (total < 0 ? '-' : '') +
              'P' +
              (Y ? Y + 'Y' : '') +
              (M ? M + 'M' : '') +
              (D ? D + 'D' : '') +
              ((h || m || s) ? 'T' : '') +
              (h ? h + 'H' : '') +
              (m ? m + 'M' : '') +
              (s ? s + 'S' : '');
      }
  
      var duration_prototype__proto = Duration.prototype;
  
      duration_prototype__proto.abs            = duration_abs__abs;
      duration_prototype__proto.add            = duration_add_subtract__add;
      duration_prototype__proto.subtract       = duration_add_subtract__subtract;
      duration_prototype__proto.as             = as;
      duration_prototype__proto.asMilliseconds = asMilliseconds;
      duration_prototype__proto.asSeconds      = asSeconds;
      duration_prototype__proto.asMinutes      = asMinutes;
      duration_prototype__proto.asHours        = asHours;
      duration_prototype__proto.asDays         = asDays;
      duration_prototype__proto.asWeeks        = asWeeks;
      duration_prototype__proto.asMonths       = asMonths;
      duration_prototype__proto.asYears        = asYears;
      duration_prototype__proto.valueOf        = duration_as__valueOf;
      duration_prototype__proto._bubble        = bubble;
      duration_prototype__proto.get            = duration_get__get;
      duration_prototype__proto.milliseconds   = milliseconds;
      duration_prototype__proto.seconds        = seconds;
      duration_prototype__proto.minutes        = minutes;
      duration_prototype__proto.hours          = hours;
      duration_prototype__proto.days           = days;
      duration_prototype__proto.weeks          = weeks;
      duration_prototype__proto.months         = months;
      duration_prototype__proto.years          = years;
      duration_prototype__proto.humanize       = humanize;
      duration_prototype__proto.toISOString    = iso_string__toISOString;
      duration_prototype__proto.toString       = iso_string__toISOString;
      duration_prototype__proto.toJSON         = iso_string__toISOString;
      duration_prototype__proto.locale         = locale;
      duration_prototype__proto.localeData     = localeData;
  
      // Deprecations
      duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
      duration_prototype__proto.lang = lang;
  
      // Side effect imports
  
      addFormatToken('X', 0, 0, 'unix');
      addFormatToken('x', 0, 0, 'valueOf');
  
      // PARSING
  
      addRegexToken('x', matchSigned);
      addRegexToken('X', matchTimestamp);
      addParseToken('X', function (input, array, config) {
          config._d = new Date(parseFloat(input, 10) * 1000);
      });
      addParseToken('x', function (input, array, config) {
          config._d = new Date(toInt(input));
      });
  
      // Side effect imports
  
  
      utils_hooks__hooks.version = '2.10.6';
  
      setHookCallback(local__createLocal);
  
      utils_hooks__hooks.fn                    = momentPrototype;
      utils_hooks__hooks.min                   = min;
      utils_hooks__hooks.max                   = max;
      utils_hooks__hooks.utc                   = create_utc__createUTC;
      utils_hooks__hooks.unix                  = moment__createUnix;
      utils_hooks__hooks.months                = lists__listMonths;
      utils_hooks__hooks.isDate                = isDate;
      utils_hooks__hooks.locale                = locale_locales__getSetGlobalLocale;
      utils_hooks__hooks.invalid               = valid__createInvalid;
      utils_hooks__hooks.duration              = create__createDuration;
      utils_hooks__hooks.isMoment              = isMoment;
      utils_hooks__hooks.weekdays              = lists__listWeekdays;
      utils_hooks__hooks.parseZone             = moment__createInZone;
      utils_hooks__hooks.localeData            = locale_locales__getLocale;
      utils_hooks__hooks.isDuration            = isDuration;
      utils_hooks__hooks.monthsShort           = lists__listMonthsShort;
      utils_hooks__hooks.weekdaysMin           = lists__listWeekdaysMin;
      utils_hooks__hooks.defineLocale          = defineLocale;
      utils_hooks__hooks.weekdaysShort         = lists__listWeekdaysShort;
      utils_hooks__hooks.normalizeUnits        = normalizeUnits;
      utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
  
      var _moment = utils_hooks__hooks;
  
      return _moment;
  
  }));
  },{}],5:[function(require,module,exports){
  // shim for using process in browser
  
  var process = module.exports = {};
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = setTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      clearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          setTimeout(drainQueue, 0);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  },{}],6:[function(require,module,exports){
  'use strict';
  
  module.exports = require('./lib/core.js')
  require('./lib/done.js')
  require('./lib/es6-extensions.js')
  require('./lib/node-extensions.js')
  },{"./lib/core.js":7,"./lib/done.js":8,"./lib/es6-extensions.js":9,"./lib/node-extensions.js":10}],7:[function(require,module,exports){
  'use strict';
  
  var asap = require('asap')
  
  module.exports = Promise;
  function Promise(fn) {
    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
    if (typeof fn !== 'function') throw new TypeError('not a function')
    var state = null
    var value = null
    var deferreds = []
    var self = this
  
    this.then = function(onFulfilled, onRejected) {
      return new self.constructor(function(resolve, reject) {
        handle(new Handler(onFulfilled, onRejected, resolve, reject))
      })
    }
  
    function handle(deferred) {
      if (state === null) {
        deferreds.push(deferred)
        return
      }
      asap(function() {
        var cb = state ? deferred.onFulfilled : deferred.onRejected
        if (cb === null) {
          (state ? deferred.resolve : deferred.reject)(value)
          return
        }
        var ret
        try {
          ret = cb(value)
        }
        catch (e) {
          deferred.reject(e)
          return
        }
        deferred.resolve(ret)
      })
    }
  
    function resolve(newValue) {
      try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
        if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
        if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
          var then = newValue.then
          if (typeof then === 'function') {
            doResolve(then.bind(newValue), resolve, reject)
            return
          }
        }
        state = true
        value = newValue
        finale()
      } catch (e) { reject(e) }
    }
  
    function reject(newValue) {
      state = false
      value = newValue
      finale()
    }
  
    function finale() {
      for (var i = 0, len = deferreds.length; i < len; i++)
        handle(deferreds[i])
      deferreds = null
    }
  
    doResolve(fn, resolve, reject)
  }
  
  
  function Handler(onFulfilled, onRejected, resolve, reject){
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
    this.onRejected = typeof onRejected === 'function' ? onRejected : null
    this.resolve = resolve
    this.reject = reject
  }
  
  /**
   * Take a potentially misbehaving resolver function and make sure
   * onFulfilled and onRejected are only called once.
   *
   * Makes no guarantees about asynchrony.
   */
  function doResolve(fn, onFulfilled, onRejected) {
    var done = false;
    try {
      fn(function (value) {
        if (done) return
        done = true
        onFulfilled(value)
      }, function (reason) {
        if (done) return
        done = true
        onRejected(reason)
      })
    } catch (ex) {
      if (done) return
      done = true
      onRejected(ex)
    }
  }
  
  },{"asap":1}],8:[function(require,module,exports){
  'use strict';
  
  var Promise = require('./core.js')
  var asap = require('asap')
  
  module.exports = Promise
  Promise.prototype.done = function (onFulfilled, onRejected) {
    var self = arguments.length ? this.then.apply(this, arguments) : this
    self.then(null, function (err) {
      asap(function () {
        throw err
      })
    })
  }
  },{"./core.js":7,"asap":1}],9:[function(require,module,exports){
  'use strict';
  
  //This file contains the ES6 extensions to the core Promises/A+ API
  
  var Promise = require('./core.js')
  var asap = require('asap')
  
  module.exports = Promise
  
  /* Static Functions */
  
  function ValuePromise(value) {
    this.then = function (onFulfilled) {
      if (typeof onFulfilled !== 'function') return this
      return new Promise(function (resolve, reject) {
        asap(function () {
          try {
            resolve(onFulfilled(value))
          } catch (ex) {
            reject(ex);
          }
        })
      })
    }
  }
  ValuePromise.prototype = Promise.prototype
  
  var TRUE = new ValuePromise(true)
  var FALSE = new ValuePromise(false)
  var NULL = new ValuePromise(null)
  var UNDEFINED = new ValuePromise(undefined)
  var ZERO = new ValuePromise(0)
  var EMPTYSTRING = new ValuePromise('')
  
  Promise.resolve = function (value) {
    if (value instanceof Promise) return value
  
    if (value === null) return NULL
    if (value === undefined) return UNDEFINED
    if (value === true) return TRUE
    if (value === false) return FALSE
    if (value === 0) return ZERO
    if (value === '') return EMPTYSTRING
  
    if (typeof value === 'object' || typeof value === 'function') {
      try {
        var then = value.then
        if (typeof then === 'function') {
          return new Promise(then.bind(value))
        }
      } catch (ex) {
        return new Promise(function (resolve, reject) {
          reject(ex)
        })
      }
    }
  
    return new ValuePromise(value)
  }
  
  Promise.all = function (arr) {
    var args = Array.prototype.slice.call(arr)
  
    return new Promise(function (resolve, reject) {
      if (args.length === 0) return resolve([])
      var remaining = args.length
      function res(i, val) {
        try {
          if (val && (typeof val === 'object' || typeof val === 'function')) {
            var then = val.then
            if (typeof then === 'function') {
              then.call(val, function (val) { res(i, val) }, reject)
              return
            }
          }
          args[i] = val
          if (--remaining === 0) {
            resolve(args);
          }
        } catch (ex) {
          reject(ex)
        }
      }
      for (var i = 0; i < args.length; i++) {
        res(i, args[i])
      }
    })
  }
  
  Promise.reject = function (value) {
    return new Promise(function (resolve, reject) { 
      reject(value);
    });
  }
  
  Promise.race = function (values) {
    return new Promise(function (resolve, reject) { 
      values.forEach(function(value){
        Promise.resolve(value).then(resolve, reject);
      })
    });
  }
  
  /* Prototype Methods */
  
  Promise.prototype['catch'] = function (onRejected) {
    return this.then(null, onRejected);
  }
  
  },{"./core.js":7,"asap":1}],10:[function(require,module,exports){
  'use strict';
  
  //This file contains then/promise specific extensions that are only useful for node.js interop
  
  var Promise = require('./core.js')
  var asap = require('asap')
  
  module.exports = Promise
  
  /* Static Functions */
  
  Promise.denodeify = function (fn, argumentCount) {
    argumentCount = argumentCount || Infinity
    return function () {
      var self = this
      var args = Array.prototype.slice.call(arguments)
      return new Promise(function (resolve, reject) {
        while (args.length && args.length > argumentCount) {
          args.pop()
        }
        args.push(function (err, res) {
          if (err) reject(err)
          else resolve(res)
        })
        var res = fn.apply(self, args)
        if (res && (typeof res === 'object' || typeof res === 'function') && typeof res.then === 'function') {
          resolve(res)
        }
      })
    }
  }
  Promise.nodeify = function (fn) {
    return function () {
      var args = Array.prototype.slice.call(arguments)
      var callback = typeof args[args.length - 1] === 'function' ? args.pop() : null
      var ctx = this
      try {
        return fn.apply(this, arguments).nodeify(callback, ctx)
      } catch (ex) {
        if (callback === null || typeof callback == 'undefined') {
          return new Promise(function (resolve, reject) { reject(ex) })
        } else {
          asap(function () {
            callback.call(ctx, ex)
          })
        }
      }
    }
  }
  
  Promise.prototype.nodeify = function (callback, ctx) {
    if (typeof callback != 'function') return this
  
    this.then(function (value) {
      asap(function () {
        callback.call(ctx, null, value)
      })
    }, function (err) {
      asap(function () {
        callback.call(ctx, err)
      })
    })
  }
  
  },{"./core.js":7,"asap":1}],11:[function(require,module,exports){
  //     Underscore.js 1.8.3
  //     http://underscorejs.org
  //     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  //     Underscore may be freely distributed under the MIT license.
  
  (function() {
  
    // Baseline setup
    // --------------
  
    // Establish the root object, `window` in the browser, or `exports` on the server.
    var root = this;
  
    // Save the previous value of the `_` variable.
    var previousUnderscore = root._;
  
    // Save bytes in the minified (but not gzipped) version:
    var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
  
    // Create quick reference variables for speed access to core prototypes.
    var
      push             = ArrayProto.push,
      slice            = ArrayProto.slice,
      toString         = ObjProto.toString,
      hasOwnProperty   = ObjProto.hasOwnProperty;
  
    // All **ECMAScript 5** native function implementations that we hope to use
    // are declared here.
    var
      nativeIsArray      = Array.isArray,
      nativeKeys         = Object.keys,
      nativeBind         = FuncProto.bind,
      nativeCreate       = Object.create;
  
    // Naked function reference for surrogate-prototype-swapping.
    var Ctor = function(){};
  
    // Create a safe reference to the Underscore object for use below.
    var _ = function(obj) {
      if (obj instanceof _) return obj;
      if (!(this instanceof _)) return new _(obj);
      this._wrapped = obj;
    };
  
    // Export the Underscore object for **Node.js**, with
    // backwards-compatibility for the old `require()` API. If we're in
    // the browser, add `_` as a global object.
    if (typeof exports !== 'undefined') {
      if (typeof module !== 'undefined' && module.exports) {
        exports = module.exports = _;
      }
      exports._ = _;
    } else {
      root._ = _;
    }
  
    // Current version.
    _.VERSION = '1.8.3';
  
    // Internal function that returns an efficient (for current engines) version
    // of the passed-in callback, to be repeatedly applied in other Underscore
    // functions.
    var optimizeCb = function(func, context, argCount) {
      if (context === void 0) return func;
      switch (argCount == null ? 3 : argCount) {
        case 1: return function(value) {
          return func.call(context, value);
        };
        case 2: return function(value, other) {
          return func.call(context, value, other);
        };
        case 3: return function(value, index, collection) {
          return func.call(context, value, index, collection);
        };
        case 4: return function(accumulator, value, index, collection) {
          return func.call(context, accumulator, value, index, collection);
        };
      }
      return function() {
        return func.apply(context, arguments);
      };
    };
  
    // A mostly-internal function to generate callbacks that can be applied
    // to each element in a collection, returning the desired result — either
    // identity, an arbitrary callback, a property matcher, or a property accessor.
    var cb = function(value, context, argCount) {
      if (value == null) return _.identity;
      if (_.isFunction(value)) return optimizeCb(value, context, argCount);
      if (_.isObject(value)) return _.matcher(value);
      return _.property(value);
    };
    _.iteratee = function(value, context) {
      return cb(value, context, Infinity);
    };
  
    // An internal function for creating assigner functions.
    var createAssigner = function(keysFunc, undefinedOnly) {
      return function(obj) {
        var length = arguments.length;
        if (length < 2 || obj == null) return obj;
        for (var index = 1; index < length; index++) {
          var source = arguments[index],
              keys = keysFunc(source),
              l = keys.length;
          for (var i = 0; i < l; i++) {
            var key = keys[i];
            if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
          }
        }
        return obj;
      };
    };
  
    // An internal function for creating a new object that inherits from another.
    var baseCreate = function(prototype) {
      if (!_.isObject(prototype)) return {};
      if (nativeCreate) return nativeCreate(prototype);
      Ctor.prototype = prototype;
      var result = new Ctor;
      Ctor.prototype = null;
      return result;
    };
  
    var property = function(key) {
      return function(obj) {
        return obj == null ? void 0 : obj[key];
      };
    };
  
    // Helper for collection methods to determine whether a collection
    // should be iterated as an array or as an object
    // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
    // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
    var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
    var getLength = property('length');
    var isArrayLike = function(collection) {
      var length = getLength(collection);
      return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
    };
  
    // Collection Functions
    // --------------------
  
    // The cornerstone, an `each` implementation, aka `forEach`.
    // Handles raw objects in addition to array-likes. Treats all
    // sparse array-likes as if they were dense.
    _.each = _.forEach = function(obj, iteratee, context) {
      iteratee = optimizeCb(iteratee, context);
      var i, length;
      if (isArrayLike(obj)) {
        for (i = 0, length = obj.length; i < length; i++) {
          iteratee(obj[i], i, obj);
        }
      } else {
        var keys = _.keys(obj);
        for (i = 0, length = keys.length; i < length; i++) {
          iteratee(obj[keys[i]], keys[i], obj);
        }
      }
      return obj;
    };
  
    // Return the results of applying the iteratee to each element.
    _.map = _.collect = function(obj, iteratee, context) {
      iteratee = cb(iteratee, context);
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length,
          results = Array(length);
      for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        results[index] = iteratee(obj[currentKey], currentKey, obj);
      }
      return results;
    };
  
    // Create a reducing function iterating left or right.
    function createReduce(dir) {
      // Optimized iterator function as using arguments.length
      // in the main function will deoptimize the, see #1991.
      function iterator(obj, iteratee, memo, keys, index, length) {
        for (; index >= 0 && index < length; index += dir) {
          var currentKey = keys ? keys[index] : index;
          memo = iteratee(memo, obj[currentKey], currentKey, obj);
        }
        return memo;
      }
  
      return function(obj, iteratee, memo, context) {
        iteratee = optimizeCb(iteratee, context, 4);
        var keys = !isArrayLike(obj) && _.keys(obj),
            length = (keys || obj).length,
            index = dir > 0 ? 0 : length - 1;
        // Determine the initial value if none is provided.
        if (arguments.length < 3) {
          memo = obj[keys ? keys[index] : index];
          index += dir;
        }
        return iterator(obj, iteratee, memo, keys, index, length);
      };
    }
  
    // **Reduce** builds up a single result from a list of values, aka `inject`,
    // or `foldl`.
    _.reduce = _.foldl = _.inject = createReduce(1);
  
    // The right-associative version of reduce, also known as `foldr`.
    _.reduceRight = _.foldr = createReduce(-1);
  
    // Return the first value which passes a truth test. Aliased as `detect`.
    _.find = _.detect = function(obj, predicate, context) {
      var key;
      if (isArrayLike(obj)) {
        key = _.findIndex(obj, predicate, context);
      } else {
        key = _.findKey(obj, predicate, context);
      }
      if (key !== void 0 && key !== -1) return obj[key];
    };
  
    // Return all the elements that pass a truth test.
    // Aliased as `select`.
    _.filter = _.select = function(obj, predicate, context) {
      var results = [];
      predicate = cb(predicate, context);
      _.each(obj, function(value, index, list) {
        if (predicate(value, index, list)) results.push(value);
      });
      return results;
    };
  
    // Return all the elements for which a truth test fails.
    _.reject = function(obj, predicate, context) {
      return _.filter(obj, _.negate(cb(predicate)), context);
    };
  
    // Determine whether all of the elements match a truth test.
    // Aliased as `all`.
    _.every = _.all = function(obj, predicate, context) {
      predicate = cb(predicate, context);
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length;
      for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        if (!predicate(obj[currentKey], currentKey, obj)) return false;
      }
      return true;
    };
  
    // Determine if at least one element in the object matches a truth test.
    // Aliased as `any`.
    _.some = _.any = function(obj, predicate, context) {
      predicate = cb(predicate, context);
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length;
      for (var index = 0; index < length; index++) {
        var currentKey = keys ? keys[index] : index;
        if (predicate(obj[currentKey], currentKey, obj)) return true;
      }
      return false;
    };
  
    // Determine if the array or object contains a given item (using `===`).
    // Aliased as `includes` and `include`.
    _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {
      if (!isArrayLike(obj)) obj = _.values(obj);
      if (typeof fromIndex != 'number' || guard) fromIndex = 0;
      return _.indexOf(obj, item, fromIndex) >= 0;
    };
  
    // Invoke a method (with arguments) on every item in a collection.
    _.invoke = function(obj, method) {
      var args = slice.call(arguments, 2);
      var isFunc = _.isFunction(method);
      return _.map(obj, function(value) {
        var func = isFunc ? method : value[method];
        return func == null ? func : func.apply(value, args);
      });
    };
  
    // Convenience version of a common use case of `map`: fetching a property.
    _.pluck = function(obj, key) {
      return _.map(obj, _.property(key));
    };
  
    // Convenience version of a common use case of `filter`: selecting only objects
    // containing specific `key:value` pairs.
    _.where = function(obj, attrs) {
      return _.filter(obj, _.matcher(attrs));
    };
  
    // Convenience version of a common use case of `find`: getting the first object
    // containing specific `key:value` pairs.
    _.findWhere = function(obj, attrs) {
      return _.find(obj, _.matcher(attrs));
    };
  
    // Return the maximum element (or element-based computation).
    _.max = function(obj, iteratee, context) {
      var result = -Infinity, lastComputed = -Infinity,
          value, computed;
      if (iteratee == null && obj != null) {
        obj = isArrayLike(obj) ? obj : _.values(obj);
        for (var i = 0, length = obj.length; i < length; i++) {
          value = obj[i];
          if (value > result) {
            result = value;
          }
        }
      } else {
        iteratee = cb(iteratee, context);
        _.each(obj, function(value, index, list) {
          computed = iteratee(value, index, list);
          if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
            result = value;
            lastComputed = computed;
          }
        });
      }
      return result;
    };
  
    // Return the minimum element (or element-based computation).
    _.min = function(obj, iteratee, context) {
      var result = Infinity, lastComputed = Infinity,
          value, computed;
      if (iteratee == null && obj != null) {
        obj = isArrayLike(obj) ? obj : _.values(obj);
        for (var i = 0, length = obj.length; i < length; i++) {
          value = obj[i];
          if (value < result) {
            result = value;
          }
        }
      } else {
        iteratee = cb(iteratee, context);
        _.each(obj, function(value, index, list) {
          computed = iteratee(value, index, list);
          if (computed < lastComputed || computed === Infinity && result === Infinity) {
            result = value;
            lastComputed = computed;
          }
        });
      }
      return result;
    };
  
    // Shuffle a collection, using the modern version of the
    // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
    _.shuffle = function(obj) {
      var set = isArrayLike(obj) ? obj : _.values(obj);
      var length = set.length;
      var shuffled = Array(length);
      for (var index = 0, rand; index < length; index++) {
        rand = _.random(0, index);
        if (rand !== index) shuffled[index] = shuffled[rand];
        shuffled[rand] = set[index];
      }
      return shuffled;
    };
  
    // Sample **n** random values from a collection.
    // If **n** is not specified, returns a single random element.
    // The internal `guard` argument allows it to work with `map`.
    _.sample = function(obj, n, guard) {
      if (n == null || guard) {
        if (!isArrayLike(obj)) obj = _.values(obj);
        return obj[_.random(obj.length - 1)];
      }
      return _.shuffle(obj).slice(0, Math.max(0, n));
    };
  
    // Sort the object's values by a criterion produced by an iteratee.
    _.sortBy = function(obj, iteratee, context) {
      iteratee = cb(iteratee, context);
      return _.pluck(_.map(obj, function(value, index, list) {
        return {
          value: value,
          index: index,
          criteria: iteratee(value, index, list)
        };
      }).sort(function(left, right) {
        var a = left.criteria;
        var b = right.criteria;
        if (a !== b) {
          if (a > b || a === void 0) return 1;
          if (a < b || b === void 0) return -1;
        }
        return left.index - right.index;
      }), 'value');
    };
  
    // An internal function used for aggregate "group by" operations.
    var group = function(behavior) {
      return function(obj, iteratee, context) {
        var result = {};
        iteratee = cb(iteratee, context);
        _.each(obj, function(value, index) {
          var key = iteratee(value, index, obj);
          behavior(result, value, key);
        });
        return result;
      };
    };
  
    // Groups the object's values by a criterion. Pass either a string attribute
    // to group by, or a function that returns the criterion.
    _.groupBy = group(function(result, value, key) {
      if (_.has(result, key)) result[key].push(value); else result[key] = [value];
    });
  
    // Indexes the object's values by a criterion, similar to `groupBy`, but for
    // when you know that your index values will be unique.
    _.indexBy = group(function(result, value, key) {
      result[key] = value;
    });
  
    // Counts instances of an object that group by a certain criterion. Pass
    // either a string attribute to count by, or a function that returns the
    // criterion.
    _.countBy = group(function(result, value, key) {
      if (_.has(result, key)) result[key]++; else result[key] = 1;
    });
  
    // Safely create a real, live array from anything iterable.
    _.toArray = function(obj) {
      if (!obj) return [];
      if (_.isArray(obj)) return slice.call(obj);
      if (isArrayLike(obj)) return _.map(obj, _.identity);
      return _.values(obj);
    };
  
    // Return the number of elements in an object.
    _.size = function(obj) {
      if (obj == null) return 0;
      return isArrayLike(obj) ? obj.length : _.keys(obj).length;
    };
  
    // Split a collection into two arrays: one whose elements all satisfy the given
    // predicate, and one whose elements all do not satisfy the predicate.
    _.partition = function(obj, predicate, context) {
      predicate = cb(predicate, context);
      var pass = [], fail = [];
      _.each(obj, function(value, key, obj) {
        (predicate(value, key, obj) ? pass : fail).push(value);
      });
      return [pass, fail];
    };
  
    // Array Functions
    // ---------------
  
    // Get the first element of an array. Passing **n** will return the first N
    // values in the array. Aliased as `head` and `take`. The **guard** check
    // allows it to work with `_.map`.
    _.first = _.head = _.take = function(array, n, guard) {
      if (array == null) return void 0;
      if (n == null || guard) return array[0];
      return _.initial(array, array.length - n);
    };
  
    // Returns everything but the last entry of the array. Especially useful on
    // the arguments object. Passing **n** will return all the values in
    // the array, excluding the last N.
    _.initial = function(array, n, guard) {
      return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
    };
  
    // Get the last element of an array. Passing **n** will return the last N
    // values in the array.
    _.last = function(array, n, guard) {
      if (array == null) return void 0;
      if (n == null || guard) return array[array.length - 1];
      return _.rest(array, Math.max(0, array.length - n));
    };
  
    // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
    // Especially useful on the arguments object. Passing an **n** will return
    // the rest N values in the array.
    _.rest = _.tail = _.drop = function(array, n, guard) {
      return slice.call(array, n == null || guard ? 1 : n);
    };
  
    // Trim out all falsy values from an array.
    _.compact = function(array) {
      return _.filter(array, _.identity);
    };
  
    // Internal implementation of a recursive `flatten` function.
    var flatten = function(input, shallow, strict, startIndex) {
      var output = [], idx = 0;
      for (var i = startIndex || 0, length = getLength(input); i < length; i++) {
        var value = input[i];
        if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
          //flatten current level of array or arguments object
          if (!shallow) value = flatten(value, shallow, strict);
          var j = 0, len = value.length;
          output.length += len;
          while (j < len) {
            output[idx++] = value[j++];
          }
        } else if (!strict) {
          output[idx++] = value;
        }
      }
      return output;
    };
  
    // Flatten out an array, either recursively (by default), or just one level.
    _.flatten = function(array, shallow) {
      return flatten(array, shallow, false);
    };
  
    // Return a version of the array that does not contain the specified value(s).
    _.without = function(array) {
      return _.difference(array, slice.call(arguments, 1));
    };
  
    // Produce a duplicate-free version of the array. If the array has already
    // been sorted, you have the option of using a faster algorithm.
    // Aliased as `unique`.
    _.uniq = _.unique = function(array, isSorted, iteratee, context) {
      if (!_.isBoolean(isSorted)) {
        context = iteratee;
        iteratee = isSorted;
        isSorted = false;
      }
      if (iteratee != null) iteratee = cb(iteratee, context);
      var result = [];
      var seen = [];
      for (var i = 0, length = getLength(array); i < length; i++) {
        var value = array[i],
            computed = iteratee ? iteratee(value, i, array) : value;
        if (isSorted) {
          if (!i || seen !== computed) result.push(value);
          seen = computed;
        } else if (iteratee) {
          if (!_.contains(seen, computed)) {
            seen.push(computed);
            result.push(value);
          }
        } else if (!_.contains(result, value)) {
          result.push(value);
        }
      }
      return result;
    };
  
    // Produce an array that contains the union: each distinct element from all of
    // the passed-in arrays.
    _.union = function() {
      return _.uniq(flatten(arguments, true, true));
    };
  
    // Produce an array that contains every item shared between all the
    // passed-in arrays.
    _.intersection = function(array) {
      var result = [];
      var argsLength = arguments.length;
      for (var i = 0, length = getLength(array); i < length; i++) {
        var item = array[i];
        if (_.contains(result, item)) continue;
        for (var j = 1; j < argsLength; j++) {
          if (!_.contains(arguments[j], item)) break;
        }
        if (j === argsLength) result.push(item);
      }
      return result;
    };
  
    // Take the difference between one array and a number of other arrays.
    // Only the elements present in just the first array will remain.
    _.difference = function(array) {
      var rest = flatten(arguments, true, true, 1);
      return _.filter(array, function(value){
        return !_.contains(rest, value);
      });
    };
  
    // Zip together multiple lists into a single array -- elements that share
    // an index go together.
    _.zip = function() {
      return _.unzip(arguments);
    };
  
    // Complement of _.zip. Unzip accepts an array of arrays and groups
    // each array's elements on shared indices
    _.unzip = function(array) {
      var length = array && _.max(array, getLength).length || 0;
      var result = Array(length);
  
      for (var index = 0; index < length; index++) {
        result[index] = _.pluck(array, index);
      }
      return result;
    };
  
    // Converts lists into objects. Pass either a single array of `[key, value]`
    // pairs, or two parallel arrays of the same length -- one of keys, and one of
    // the corresponding values.
    _.object = function(list, values) {
      var result = {};
      for (var i = 0, length = getLength(list); i < length; i++) {
        if (values) {
          result[list[i]] = values[i];
        } else {
          result[list[i][0]] = list[i][1];
        }
      }
      return result;
    };
  
    // Generator function to create the findIndex and findLastIndex functions
    function createPredicateIndexFinder(dir) {
      return function(array, predicate, context) {
        predicate = cb(predicate, context);
        var length = getLength(array);
        var index = dir > 0 ? 0 : length - 1;
        for (; index >= 0 && index < length; index += dir) {
          if (predicate(array[index], index, array)) return index;
        }
        return -1;
      };
    }
  
    // Returns the first index on an array-like that passes a predicate test
    _.findIndex = createPredicateIndexFinder(1);
    _.findLastIndex = createPredicateIndexFinder(-1);
  
    // Use a comparator function to figure out the smallest index at which
    // an object should be inserted so as to maintain order. Uses binary search.
    _.sortedIndex = function(array, obj, iteratee, context) {
      iteratee = cb(iteratee, context, 1);
      var value = iteratee(obj);
      var low = 0, high = getLength(array);
      while (low < high) {
        var mid = Math.floor((low + high) / 2);
        if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
      }
      return low;
    };
  
    // Generator function to create the indexOf and lastIndexOf functions
    function createIndexFinder(dir, predicateFind, sortedIndex) {
      return function(array, item, idx) {
        var i = 0, length = getLength(array);
        if (typeof idx == 'number') {
          if (dir > 0) {
              i = idx >= 0 ? idx : Math.max(idx + length, i);
          } else {
              length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
          }
        } else if (sortedIndex && idx && length) {
          idx = sortedIndex(array, item);
          return array[idx] === item ? idx : -1;
        }
        if (item !== item) {
          idx = predicateFind(slice.call(array, i, length), _.isNaN);
          return idx >= 0 ? idx + i : -1;
        }
        for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
          if (array[idx] === item) return idx;
        }
        return -1;
      };
    }
  
    // Return the position of the first occurrence of an item in an array,
    // or -1 if the item is not included in the array.
    // If the array is large and already in sort order, pass `true`
    // for **isSorted** to use binary search.
    _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
    _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);
  
    // Generate an integer Array containing an arithmetic progression. A port of
    // the native Python `range()` function. See
    // [the Python documentation](http://docs.python.org/library/functions.html#range).
    _.range = function(start, stop, step) {
      if (stop == null) {
        stop = start || 0;
        start = 0;
      }
      step = step || 1;
  
      var length = Math.max(Math.ceil((stop - start) / step), 0);
      var range = Array(length);
  
      for (var idx = 0; idx < length; idx++, start += step) {
        range[idx] = start;
      }
  
      return range;
    };
  
    // Function (ahem) Functions
    // ------------------
  
    // Determines whether to execute a function as a constructor
    // or a normal function with the provided arguments
    var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {
      if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
      var self = baseCreate(sourceFunc.prototype);
      var result = sourceFunc.apply(self, args);
      if (_.isObject(result)) return result;
      return self;
    };
  
    // Create a function bound to a given object (assigning `this`, and arguments,
    // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
    // available.
    _.bind = function(func, context) {
      if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
      if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
      var args = slice.call(arguments, 2);
      var bound = function() {
        return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
      };
      return bound;
    };
  
    // Partially apply a function by creating a version that has had some of its
    // arguments pre-filled, without changing its dynamic `this` context. _ acts
    // as a placeholder, allowing any combination of arguments to be pre-filled.
    _.partial = function(func) {
      var boundArgs = slice.call(arguments, 1);
      var bound = function() {
        var position = 0, length = boundArgs.length;
        var args = Array(length);
        for (var i = 0; i < length; i++) {
          args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
        }
        while (position < arguments.length) args.push(arguments[position++]);
        return executeBound(func, bound, this, this, args);
      };
      return bound;
    };
  
    // Bind a number of an object's methods to that object. Remaining arguments
    // are the method names to be bound. Useful for ensuring that all callbacks
    // defined on an object belong to it.
    _.bindAll = function(obj) {
      var i, length = arguments.length, key;
      if (length <= 1) throw new Error('bindAll must be passed function names');
      for (i = 1; i < length; i++) {
        key = arguments[i];
        obj[key] = _.bind(obj[key], obj);
      }
      return obj;
    };
  
    // Memoize an expensive function by storing its results.
    _.memoize = function(func, hasher) {
      var memoize = function(key) {
        var cache = memoize.cache;
        var address = '' + (hasher ? hasher.apply(this, arguments) : key);
        if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
        return cache[address];
      };
      memoize.cache = {};
      return memoize;
    };
  
    // Delays a function for the given number of milliseconds, and then calls
    // it with the arguments supplied.
    _.delay = function(func, wait) {
      var args = slice.call(arguments, 2);
      return setTimeout(function(){
        return func.apply(null, args);
      }, wait);
    };
  
    // Defers a function, scheduling it to run after the current call stack has
    // cleared.
    _.defer = _.partial(_.delay, _, 1);
  
    // Returns a function, that, when invoked, will only be triggered at most once
    // during a given window of time. Normally, the throttled function will run
    // as much as it can, without ever going more than once per `wait` duration;
    // but if you'd like to disable the execution on the leading edge, pass
    // `{leading: false}`. To disable execution on the trailing edge, ditto.
    _.throttle = function(func, wait, options) {
      var context, args, result;
      var timeout = null;
      var previous = 0;
      if (!options) options = {};
      var later = function() {
        previous = options.leading === false ? 0 : _.now();
        timeout = null;
        result = func.apply(context, args);
        if (!timeout) context = args = null;
      };
      return function() {
        var now = _.now();
        if (!previous && options.leading === false) previous = now;
        var remaining = wait - (now - previous);
        context = this;
        args = arguments;
        if (remaining <= 0 || remaining > wait) {
          if (timeout) {
            clearTimeout(timeout);
            timeout = null;
          }
          previous = now;
          result = func.apply(context, args);
          if (!timeout) context = args = null;
        } else if (!timeout && options.trailing !== false) {
          timeout = setTimeout(later, remaining);
        }
        return result;
      };
    };
  
    // Returns a function, that, as long as it continues to be invoked, will not
    // be triggered. The function will be called after it stops being called for
    // N milliseconds. If `immediate` is passed, trigger the function on the
    // leading edge, instead of the trailing.
    _.debounce = function(func, wait, immediate) {
      var timeout, args, context, timestamp, result;
  
      var later = function() {
        var last = _.now() - timestamp;
  
        if (last < wait && last >= 0) {
          timeout = setTimeout(later, wait - last);
        } else {
          timeout = null;
          if (!immediate) {
            result = func.apply(context, args);
            if (!timeout) context = args = null;
          }
        }
      };
  
      return function() {
        context = this;
        args = arguments;
        timestamp = _.now();
        var callNow = immediate && !timeout;
        if (!timeout) timeout = setTimeout(later, wait);
        if (callNow) {
          result = func.apply(context, args);
          context = args = null;
        }
  
        return result;
      };
    };
  
    // Returns the first function passed as an argument to the second,
    // allowing you to adjust arguments, run code before and after, and
    // conditionally execute the original function.
    _.wrap = function(func, wrapper) {
      return _.partial(wrapper, func);
    };
  
    // Returns a negated version of the passed-in predicate.
    _.negate = function(predicate) {
      return function() {
        return !predicate.apply(this, arguments);
      };
    };
  
    // Returns a function that is the composition of a list of functions, each
    // consuming the return value of the function that follows.
    _.compose = function() {
      var args = arguments;
      var start = args.length - 1;
      return function() {
        var i = start;
        var result = args[start].apply(this, arguments);
        while (i--) result = args[i].call(this, result);
        return result;
      };
    };
  
    // Returns a function that will only be executed on and after the Nth call.
    _.after = function(times, func) {
      return function() {
        if (--times < 1) {
          return func.apply(this, arguments);
        }
      };
    };
  
    // Returns a function that will only be executed up to (but not including) the Nth call.
    _.before = function(times, func) {
      var memo;
      return function() {
        if (--times > 0) {
          memo = func.apply(this, arguments);
        }
        if (times <= 1) func = null;
        return memo;
      };
    };
  
    // Returns a function that will be executed at most one time, no matter how
    // often you call it. Useful for lazy initialization.
    _.once = _.partial(_.before, 2);
  
    // Object Functions
    // ----------------
  
    // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
    var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
    var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
                        'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
  
    function collectNonEnumProps(obj, keys) {
      var nonEnumIdx = nonEnumerableProps.length;
      var constructor = obj.constructor;
      var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;
  
      // Constructor is a special case.
      var prop = 'constructor';
      if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);
  
      while (nonEnumIdx--) {
        prop = nonEnumerableProps[nonEnumIdx];
        if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
          keys.push(prop);
        }
      }
    }
  
    // Retrieve the names of an object's own properties.
    // Delegates to **ECMAScript 5**'s native `Object.keys`
    _.keys = function(obj) {
      if (!_.isObject(obj)) return [];
      if (nativeKeys) return nativeKeys(obj);
      var keys = [];
      for (var key in obj) if (_.has(obj, key)) keys.push(key);
      // Ahem, IE < 9.
      if (hasEnumBug) collectNonEnumProps(obj, keys);
      return keys;
    };
  
    // Retrieve all the property names of an object.
    _.allKeys = function(obj) {
      if (!_.isObject(obj)) return [];
      var keys = [];
      for (var key in obj) keys.push(key);
      // Ahem, IE < 9.
      if (hasEnumBug) collectNonEnumProps(obj, keys);
      return keys;
    };
  
    // Retrieve the values of an object's properties.
    _.values = function(obj) {
      var keys = _.keys(obj);
      var length = keys.length;
      var values = Array(length);
      for (var i = 0; i < length; i++) {
        values[i] = obj[keys[i]];
      }
      return values;
    };
  
    // Returns the results of applying the iteratee to each element of the object
    // In contrast to _.map it returns an object
    _.mapObject = function(obj, iteratee, context) {
      iteratee = cb(iteratee, context);
      var keys =  _.keys(obj),
            length = keys.length,
            results = {},
            currentKey;
        for (var index = 0; index < length; index++) {
          currentKey = keys[index];
          results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
        }
        return results;
    };
  
    // Convert an object into a list of `[key, value]` pairs.
    _.pairs = function(obj) {
      var keys = _.keys(obj);
      var length = keys.length;
      var pairs = Array(length);
      for (var i = 0; i < length; i++) {
        pairs[i] = [keys[i], obj[keys[i]]];
      }
      return pairs;
    };
  
    // Invert the keys and values of an object. The values must be serializable.
    _.invert = function(obj) {
      var result = {};
      var keys = _.keys(obj);
      for (var i = 0, length = keys.length; i < length; i++) {
        result[obj[keys[i]]] = keys[i];
      }
      return result;
    };
  
    // Return a sorted list of the function names available on the object.
    // Aliased as `methods`
    _.functions = _.methods = function(obj) {
      var names = [];
      for (var key in obj) {
        if (_.isFunction(obj[key])) names.push(key);
      }
      return names.sort();
    };
  
    // Extend a given object with all the properties in passed-in object(s).
    _.extend = createAssigner(_.allKeys);
  
    // Assigns a given object with all the own properties in the passed-in object(s)
    // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
    _.extendOwn = _.assign = createAssigner(_.keys);
  
    // Returns the first key on an object that passes a predicate test
    _.findKey = function(obj, predicate, context) {
      predicate = cb(predicate, context);
      var keys = _.keys(obj), key;
      for (var i = 0, length = keys.length; i < length; i++) {
        key = keys[i];
        if (predicate(obj[key], key, obj)) return key;
      }
    };
  
    // Return a copy of the object only containing the whitelisted properties.
    _.pick = function(object, oiteratee, context) {
      var result = {}, obj = object, iteratee, keys;
      if (obj == null) return result;
      if (_.isFunction(oiteratee)) {
        keys = _.allKeys(obj);
        iteratee = optimizeCb(oiteratee, context);
      } else {
        keys = flatten(arguments, false, false, 1);
        iteratee = function(value, key, obj) { return key in obj; };
        obj = Object(obj);
      }
      for (var i = 0, length = keys.length; i < length; i++) {
        var key = keys[i];
        var value = obj[key];
        if (iteratee(value, key, obj)) result[key] = value;
      }
      return result;
    };
  
     // Return a copy of the object without the blacklisted properties.
    _.omit = function(obj, iteratee, context) {
      if (_.isFunction(iteratee)) {
        iteratee = _.negate(iteratee);
      } else {
        var keys = _.map(flatten(arguments, false, false, 1), String);
        iteratee = function(value, key) {
          return !_.contains(keys, key);
        };
      }
      return _.pick(obj, iteratee, context);
    };
  
    // Fill in a given object with default properties.
    _.defaults = createAssigner(_.allKeys, true);
  
    // Creates an object that inherits from the given prototype object.
    // If additional properties are provided then they will be added to the
    // created object.
    _.create = function(prototype, props) {
      var result = baseCreate(prototype);
      if (props) _.extendOwn(result, props);
      return result;
    };
  
    // Create a (shallow-cloned) duplicate of an object.
    _.clone = function(obj) {
      if (!_.isObject(obj)) return obj;
      return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
    };
  
    // Invokes interceptor with the obj, and then returns obj.
    // The primary purpose of this method is to "tap into" a method chain, in
    // order to perform operations on intermediate results within the chain.
    _.tap = function(obj, interceptor) {
      interceptor(obj);
      return obj;
    };
  
    // Returns whether an object has a given set of `key:value` pairs.
    _.isMatch = function(object, attrs) {
      var keys = _.keys(attrs), length = keys.length;
      if (object == null) return !length;
      var obj = Object(object);
      for (var i = 0; i < length; i++) {
        var key = keys[i];
        if (attrs[key] !== obj[key] || !(key in obj)) return false;
      }
      return true;
    };
  
  
    // Internal recursive comparison function for `isEqual`.
    var eq = function(a, b, aStack, bStack) {
      // Identical objects are equal. `0 === -0`, but they aren't identical.
      // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
      if (a === b) return a !== 0 || 1 / a === 1 / b;
      // A strict comparison is necessary because `null == undefined`.
      if (a == null || b == null) return a === b;
      // Unwrap any wrapped objects.
      if (a instanceof _) a = a._wrapped;
      if (b instanceof _) b = b._wrapped;
      // Compare `[[Class]]` names.
      var className = toString.call(a);
      if (className !== toString.call(b)) return false;
      switch (className) {
        // Strings, numbers, regular expressions, dates, and booleans are compared by value.
        case '[object RegExp]':
        // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
        case '[object String]':
          // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
          // equivalent to `new String("5")`.
          return '' + a === '' + b;
        case '[object Number]':
          // `NaN`s are equivalent, but non-reflexive.
          // Object(NaN) is equivalent to NaN
          if (+a !== +a) return +b !== +b;
          // An `egal` comparison is performed for other numeric values.
          return +a === 0 ? 1 / +a === 1 / b : +a === +b;
        case '[object Date]':
        case '[object Boolean]':
          // Coerce dates and booleans to numeric primitive values. Dates are compared by their
          // millisecond representations. Note that invalid dates with millisecond representations
          // of `NaN` are not equivalent.
          return +a === +b;
      }
  
      var areArrays = className === '[object Array]';
      if (!areArrays) {
        if (typeof a != 'object' || typeof b != 'object') return false;
  
        // Objects with different constructors are not equivalent, but `Object`s or `Array`s
        // from different frames are.
        var aCtor = a.constructor, bCtor = b.constructor;
        if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
                                 _.isFunction(bCtor) && bCtor instanceof bCtor)
                            && ('constructor' in a && 'constructor' in b)) {
          return false;
        }
      }
      // Assume equality for cyclic structures. The algorithm for detecting cyclic
      // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
  
      // Initializing stack of traversed objects.
      // It's done here since we only need them for objects and arrays comparison.
      aStack = aStack || [];
      bStack = bStack || [];
      var length = aStack.length;
      while (length--) {
        // Linear search. Performance is inversely proportional to the number of
        // unique nested structures.
        if (aStack[length] === a) return bStack[length] === b;
      }
  
      // Add the first object to the stack of traversed objects.
      aStack.push(a);
      bStack.push(b);
  
      // Recursively compare objects and arrays.
      if (areArrays) {
        // Compare array lengths to determine if a deep comparison is necessary.
        length = a.length;
        if (length !== b.length) return false;
        // Deep compare the contents, ignoring non-numeric properties.
        while (length--) {
          if (!eq(a[length], b[length], aStack, bStack)) return false;
        }
      } else {
        // Deep compare objects.
        var keys = _.keys(a), key;
        length = keys.length;
        // Ensure that both objects contain the same number of properties before comparing deep equality.
        if (_.keys(b).length !== length) return false;
        while (length--) {
          // Deep compare each member
          key = keys[length];
          if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
        }
      }
      // Remove the first object from the stack of traversed objects.
      aStack.pop();
      bStack.pop();
      return true;
    };
  
    // Perform a deep comparison to check if two objects are equal.
    _.isEqual = function(a, b) {
      return eq(a, b);
    };
  
    // Is a given array, string, or object empty?
    // An "empty" object has no enumerable own-properties.
    _.isEmpty = function(obj) {
      if (obj == null) return true;
      if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;
      return _.keys(obj).length === 0;
    };
  
    // Is a given value a DOM element?
    _.isElement = function(obj) {
      return !!(obj && obj.nodeType === 1);
    };
  
    // Is a given value an array?
    // Delegates to ECMA5's native Array.isArray
    _.isArray = nativeIsArray || function(obj) {
      return toString.call(obj) === '[object Array]';
    };
  
    // Is a given variable an object?
    _.isObject = function(obj) {
      var type = typeof obj;
      return type === 'function' || type === 'object' && !!obj;
    };
  
    // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.
    _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {
      _['is' + name] = function(obj) {
        return toString.call(obj) === '[object ' + name + ']';
      };
    });
  
    // Define a fallback version of the method in browsers (ahem, IE < 9), where
    // there isn't any inspectable "Arguments" type.
    if (!_.isArguments(arguments)) {
      _.isArguments = function(obj) {
        return _.has(obj, 'callee');
      };
    }
  
    // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
    // IE 11 (#1621), and in Safari 8 (#1929).
    if (typeof /./ != 'function' && typeof Int8Array != 'object') {
      _.isFunction = function(obj) {
        return typeof obj == 'function' || false;
      };
    }
  
    // Is a given object a finite number?
    _.isFinite = function(obj) {
      return isFinite(obj) && !isNaN(parseFloat(obj));
    };
  
    // Is the given value `NaN`? (NaN is the only number which does not equal itself).
    _.isNaN = function(obj) {
      return _.isNumber(obj) && obj !== +obj;
    };
  
    // Is a given value a boolean?
    _.isBoolean = function(obj) {
      return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
    };
  
    // Is a given value equal to null?
    _.isNull = function(obj) {
      return obj === null;
    };
  
    // Is a given variable undefined?
    _.isUndefined = function(obj) {
      return obj === void 0;
    };
  
    // Shortcut function for checking if an object has a given property directly
    // on itself (in other words, not on a prototype).
    _.has = function(obj, key) {
      return obj != null && hasOwnProperty.call(obj, key);
    };
  
    // Utility Functions
    // -----------------
  
    // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
    // previous owner. Returns a reference to the Underscore object.
    _.noConflict = function() {
      root._ = previousUnderscore;
      return this;
    };
  
    // Keep the identity function around for default iteratees.
    _.identity = function(value) {
      return value;
    };
  
    // Predicate-generating functions. Often useful outside of Underscore.
    _.constant = function(value) {
      return function() {
        return value;
      };
    };
  
    _.noop = function(){};
  
    _.property = property;
  
    // Generates a function for a given object that returns a given property.
    _.propertyOf = function(obj) {
      return obj == null ? function(){} : function(key) {
        return obj[key];
      };
    };
  
    // Returns a predicate for checking whether an object has a given set of
    // `key:value` pairs.
    _.matcher = _.matches = function(attrs) {
      attrs = _.extendOwn({}, attrs);
      return function(obj) {
        return _.isMatch(obj, attrs);
      };
    };
  
    // Run a function **n** times.
    _.times = function(n, iteratee, context) {
      var accum = Array(Math.max(0, n));
      iteratee = optimizeCb(iteratee, context, 1);
      for (var i = 0; i < n; i++) accum[i] = iteratee(i);
      return accum;
    };
  
    // Return a random integer between min and max (inclusive).
    _.random = function(min, max) {
      if (max == null) {
        max = min;
        min = 0;
      }
      return min + Math.floor(Math.random() * (max - min + 1));
    };
  
    // A (possibly faster) way to get the current timestamp as an integer.
    _.now = Date.now || function() {
      return new Date().getTime();
    };
  
     // List of HTML entities for escaping.
    var escapeMap = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#x27;',
      '`': '&#x60;'
    };
    var unescapeMap = _.invert(escapeMap);
  
    // Functions for escaping and unescaping strings to/from HTML interpolation.
    var createEscaper = function(map) {
      var escaper = function(match) {
        return map[match];
      };
      // Regexes for identifying a key that needs to be escaped
      var source = '(?:' + _.keys(map).join('|') + ')';
      var testRegexp = RegExp(source);
      var replaceRegexp = RegExp(source, 'g');
      return function(string) {
        string = string == null ? '' : '' + string;
        return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
      };
    };
    _.escape = createEscaper(escapeMap);
    _.unescape = createEscaper(unescapeMap);
  
    // If the value of the named `property` is a function then invoke it with the
    // `object` as context; otherwise, return it.
    _.result = function(object, property, fallback) {
      var value = object == null ? void 0 : object[property];
      if (value === void 0) {
        value = fallback;
      }
      return _.isFunction(value) ? value.call(object) : value;
    };
  
    // Generate a unique integer id (unique within the entire client session).
    // Useful for temporary DOM ids.
    var idCounter = 0;
    _.uniqueId = function(prefix) {
      var id = ++idCounter + '';
      return prefix ? prefix + id : id;
    };
  
    // By default, Underscore uses ERB-style template delimiters, change the
    // following template settings to use alternative delimiters.
    _.templateSettings = {
      evaluate    : /<%([\s\S]+?)%>/g,
      interpolate : /<%=([\s\S]+?)%>/g,
      escape      : /<%-([\s\S]+?)%>/g
    };
  
    // When customizing `templateSettings`, if you don't want to define an
    // interpolation, evaluation or escaping regex, we need one that is
    // guaranteed not to match.
    var noMatch = /(.)^/;
  
    // Certain characters need to be escaped so that they can be put into a
    // string literal.
    var escapes = {
      "'":      "'",
      '\\':     '\\',
      '\r':     'r',
      '\n':     'n',
      '\u2028': 'u2028',
      '\u2029': 'u2029'
    };
  
    var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
  
    var escapeChar = function(match) {
      return '\\' + escapes[match];
    };
  
    // JavaScript micro-templating, similar to John Resig's implementation.
    // Underscore templating handles arbitrary delimiters, preserves whitespace,
    // and correctly escapes quotes within interpolated code.
    // NB: `oldSettings` only exists for backwards compatibility.
    _.template = function(text, settings, oldSettings) {
      if (!settings && oldSettings) settings = oldSettings;
      settings = _.defaults({}, settings, _.templateSettings);
  
      // Combine delimiters into one regular expression via alternation.
      var matcher = RegExp([
        (settings.escape || noMatch).source,
        (settings.interpolate || noMatch).source,
        (settings.evaluate || noMatch).source
      ].join('|') + '|$', 'g');
  
      // Compile the template source, escaping string literals appropriately.
      var index = 0;
      var source = "__p+='";
      text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
        source += text.slice(index, offset).replace(escaper, escapeChar);
        index = offset + match.length;
  
        if (escape) {
          source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
        } else if (interpolate) {
          source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
        } else if (evaluate) {
          source += "';\n" + evaluate + "\n__p+='";
        }
  
        // Adobe VMs need the match returned to produce the correct offest.
        return match;
      });
      source += "';\n";
  
      // If a variable is not specified, place data values in local scope.
      if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
  
      source = "var __t,__p='',__j=Array.prototype.join," +
        "print=function(){__p+=__j.call(arguments,'');};\n" +
        source + 'return __p;\n';
  
      try {
        var render = new Function(settings.variable || 'obj', '_', source);
      } catch (e) {
        e.source = source;
        throw e;
      }
  
      var template = function(data) {
        return render.call(this, data, _);
      };
  
      // Provide the compiled source as a convenience for precompilation.
      var argument = settings.variable || 'obj';
      template.source = 'function(' + argument + '){\n' + source + '}';
  
      return template;
    };
  
    // Add a "chain" function. Start chaining a wrapped Underscore object.
    _.chain = function(obj) {
      var instance = _(obj);
      instance._chain = true;
      return instance;
    };
  
    // OOP
    // ---------------
    // If Underscore is called as a function, it returns a wrapped object that
    // can be used OO-style. This wrapper holds altered versions of all the
    // underscore functions. Wrapped objects may be chained.
  
    // Helper function to continue chaining intermediate results.
    var result = function(instance, obj) {
      return instance._chain ? _(obj).chain() : obj;
    };
  
    // Add your own custom functions to the Underscore object.
    _.mixin = function(obj) {
      _.each(_.functions(obj), function(name) {
        var func = _[name] = obj[name];
        _.prototype[name] = function() {
          var args = [this._wrapped];
          push.apply(args, arguments);
          return result(this, func.apply(_, args));
        };
      });
    };
  
    // Add all of the Underscore functions to the wrapper object.
    _.mixin(_);
  
    // Add all mutator Array functions to the wrapper.
    _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
      var method = ArrayProto[name];
      _.prototype[name] = function() {
        var obj = this._wrapped;
        method.apply(obj, arguments);
        if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
        return result(this, obj);
      };
    });
  
    // Add all accessor Array functions to the wrapper.
    _.each(['concat', 'join', 'slice'], function(name) {
      var method = ArrayProto[name];
      _.prototype[name] = function() {
        return result(this, method.apply(this._wrapped, arguments));
      };
    });
  
    // Extracts the result from a wrapped and chained object.
    _.prototype.value = function() {
      return this._wrapped;
    };
  
    // Provide unwrapping proxy for some methods used in engine operations
    // such as arithmetic and JSON stringification.
    _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
  
    _.prototype.toString = function() {
      return '' + this._wrapped;
    };
  
    // AMD registration happens at the end for compatibility with AMD loaders
    // that may not enforce next-turn semantics on modules. Even though general
    // practice for AMD registration is to be anonymous, underscore registers
    // as a named module because, like jQuery, it is a base library that is
    // popular enough to be bundled in a third party lib, but not be part of
    // an AMD load request. Those cases could generate an error when an
    // anonymous define() is called outside of a loader request.
    if (typeof define === 'function' && define.amd) {
      define('underscore', [], function() {
        return _;
      });
    }
  }.call(this));
  
  },{}],12:[function(require,module,exports){
  /**
   * Service for sending network requests.
   */
  
  var xhr = require('./lib/xhr');
  var jsonp = require('./lib/jsonp');
  var Promise = require('./lib/promise');
  
  module.exports = function (_) {
  
      var originUrl = _.url.parse(location.href);
      var jsonType = {'Content-Type': 'application/json;charset=utf-8'};
  
      function Http(url, options) {
  
          var promise;
  
          if (_.isPlainObject(url)) {
              options = url;
              url = '';
          }
  
          options = _.extend({url: url}, options);
          options = _.extend(true, {},
              Http.options, this.options, options
          );
  
          if (options.crossOrigin === null) {
              options.crossOrigin = crossOrigin(options.url);
          }
  
          options.method = options.method.toUpperCase();
          options.headers = _.extend({}, Http.headers.common,
              !options.crossOrigin ? Http.headers.custom : {},
              Http.headers[options.method.toLowerCase()],
              options.headers
          );
  
          if (_.isPlainObject(options.data) && /^(GET|JSONP)$/i.test(options.method)) {
              _.extend(options.params, options.data);
              delete options.data;
          }
  
          if (options.emulateHTTP && !options.crossOrigin && /^(PUT|PATCH|DELETE)$/i.test(options.method)) {
              options.headers['X-HTTP-Method-Override'] = options.method;
              options.method = 'POST';
          }
  
          if (options.emulateJSON && _.isPlainObject(options.data)) {
              options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
              options.data = _.url.params(options.data);
          }
  
          if (_.isObject(options.data) && /FormData/i.test(options.data.toString())) {
              delete options.headers['Content-Type'];
          }
  
          if (_.isPlainObject(options.data)) {
              options.data = JSON.stringify(options.data);
          }
  
          promise = (options.method == 'JSONP' ? jsonp : xhr).call(this.vm, _, options);
          promise = extendPromise(promise.then(transformResponse, transformResponse), this.vm);
  
          if (options.success) {
              promise = promise.success(options.success);
          }
  
          if (options.error) {
              promise = promise.error(options.error);
          }
  
          return promise;
      }
  
      function extendPromise(promise, vm) {
  
          promise.success = function (fn) {
  
              return extendPromise(promise.then(function (response) {
                  return fn.call(vm, response.data, response.status, response) || response;
              }), vm);
  
          };
  
          promise.error = function (fn) {
  
              return extendPromise(promise.then(undefined, function (response) {
                  return fn.call(vm, response.data, response.status, response) || response;
              }), vm);
  
          };
  
          promise.always = function (fn) {
  
              var cb = function (response) {
                  return fn.call(vm, response.data, response.status, response) || response;
              };
  
              return extendPromise(promise.then(cb, cb), vm);
          };
  
          return promise;
      }
  
      function transformResponse(response) {
  
          try {
              response.data = JSON.parse(response.responseText);
          } catch (e) {
              response.data = response.responseText;
          }
  
          return response.ok ? response : Promise.reject(response);
      }
  
      function crossOrigin(url) {
  
          var requestUrl = _.url.parse(url);
  
          return (requestUrl.protocol !== originUrl.protocol || requestUrl.host !== originUrl.host);
      }
  
      Http.options = {
          method: 'get',
          params: {},
          data: '',
          xhr: null,
          jsonp: 'callback',
          beforeSend: null,
          crossOrigin: null,
          emulateHTTP: false,
          emulateJSON: false
      };
  
      Http.headers = {
          put: jsonType,
          post: jsonType,
          patch: jsonType,
          delete: jsonType,
          common: {'Accept': 'application/json, text/plain, */*'},
          custom: {'X-Requested-With': 'XMLHttpRequest'}
      };
  
      ['get', 'put', 'post', 'patch', 'delete', 'jsonp'].forEach(function (method) {
  
          Http[method] = function (url, data, success, options) {
  
              if (_.isFunction(data)) {
                  options = success;
                  success = data;
                  data = undefined;
              }
  
              return this(url, _.extend({method: method, data: data, success: success}, options));
          };
      });
  
      return _.http = Http;
  };
  
  },{"./lib/jsonp":14,"./lib/promise":15,"./lib/xhr":17}],13:[function(require,module,exports){
  /**
   * Install plugin.
   */
  
  function install(Vue) {
  
      var _ = require('./lib/util')(Vue);
  
      Vue.url = require('./url')(_);
      Vue.http = require('./http')(_);
      Vue.resource = require('./resource')(_);
  
      Object.defineProperties(Vue.prototype, {
  
          $url: {
              get: function () {
                  return _.options(Vue.url, this, this.$options.url);
              }
          },
  
          $http: {
              get: function () {
                  return _.options(Vue.http, this, this.$options.http);
              }
          },
  
          $resource: {
              get: function () {
                  return Vue.resource.bind(this);
              }
          }
  
      });
  }
  
  if (window.Vue) {
      Vue.use(install);
  }
  
  module.exports = install;
  },{"./http":12,"./lib/util":16,"./resource":18,"./url":19}],14:[function(require,module,exports){
  /**
   * JSONP request.
   */
  
  var Promise = require('./promise');
  
  module.exports = function (_, options) {
  
      var callback = '_jsonp' + Math.random().toString(36).substr(2), response = {}, script, body;
  
      options.params[options.jsonp] = callback;
  
      if (_.isFunction(options.beforeSend)) {
          options.beforeSend.call(this, {}, options);
      }
  
      return new Promise(function (resolve, reject) {
  
          script = document.createElement('script');
          script.src = _.url(options);
          script.type = 'text/javascript';
          script.async = true;
  
          window[callback] = function (data) {
              body = data;
          };
  
          var handler = function (event) {
  
              delete window[callback];
              document.body.removeChild(script);
  
              if (event.type === 'load' && !body) {
                  event.type = 'error';
              }
  
              response.ok = event.type !== 'error';
              response.status = response.ok ? 200 : 404;
              response.responseText = body ? body : event.type;
  
              (response.ok ? resolve : reject)(response);
          };
  
          script.onload = handler;
          script.onerror = handler;
  
          document.body.appendChild(script);
      });
  
  };
  
  },{"./promise":15}],15:[function(require,module,exports){
  /**
   * Promises/A+ polyfill v1.1.0 (https://github.com/bramstein/promis)
   */
  
  var RESOLVED = 0;
  var REJECTED = 1;
  var PENDING  = 2;
  
  function Promise(executor) {
  
      this.state = PENDING;
      this.value = undefined;
      this.deferred = [];
  
      var promise = this;
  
      try {
          executor(function (x) {
              promise.resolve(x);
          }, function (r) {
              promise.reject(r);
          });
      } catch (e) {
          promise.reject(e);
      }
  }
  
  Promise.reject = function (r) {
      return new Promise(function (resolve, reject) {
          reject(r);
      });
  };
  
  Promise.resolve = function (x) {
      return new Promise(function (resolve, reject) {
          resolve(x);
      });
  };
  
  Promise.all = function all(iterable) {
      return new Promise(function (resolve, reject) {
          var count = 0,
              result = [];
  
          if (iterable.length === 0) {
              resolve(result);
          }
  
          function resolver(i) {
              return function (x) {
                  result[i] = x;
                  count += 1;
  
                  if (count === iterable.length) {
                      resolve(result);
                  }
              };
          }
  
          for (var i = 0; i < iterable.length; i += 1) {
              iterable[i].then(resolver(i), reject);
          }
      });
  };
  
  Promise.race = function race(iterable) {
      return new Promise(function (resolve, reject) {
          for (var i = 0; i < iterable.length; i += 1) {
              iterable[i].then(resolve, reject);
          }
      });
  };
  
  var p = Promise.prototype;
  
  p.resolve = function resolve(x) {
      var promise = this;
  
      if (promise.state === PENDING) {
          if (x === promise) {
              throw new TypeError('Promise settled with itself.');
          }
  
          var called = false;
  
          try {
              var then = x && x['then'];
  
              if (x !== null && typeof x === 'object' && typeof then === 'function') {
                  then.call(x, function (x) {
                      if (!called) {
                          promise.resolve(x);
                      }
                      called = true;
  
                  }, function (r) {
                      if (!called) {
                          promise.reject(r);
                      }
                      called = true;
                  });
                  return;
              }
          } catch (e) {
              if (!called) {
                  promise.reject(e);
              }
              return;
          }
          promise.state = RESOLVED;
          promise.value = x;
          promise.notify();
      }
  };
  
  p.reject = function reject(reason) {
      var promise = this;
  
      if (promise.state === PENDING) {
          if (reason === promise) {
              throw new TypeError('Promise settled with itself.');
          }
  
          promise.state = REJECTED;
          promise.value = reason;
          promise.notify();
      }
  };
  
  p.notify = function notify() {
      var promise = this;
  
      async(function () {
          if (promise.state !== PENDING) {
              while (promise.deferred.length) {
                  var deferred = promise.deferred.shift(),
                      onResolved = deferred[0],
                      onRejected = deferred[1],
                      resolve = deferred[2],
                      reject = deferred[3];
  
                  try {
                      if (promise.state === RESOLVED) {
                          if (typeof onResolved === 'function') {
                              resolve(onResolved.call(undefined, promise.value));
                          } else {
                              resolve(promise.value);
                          }
                      } else if (promise.state === REJECTED) {
                          if (typeof onRejected === 'function') {
                              resolve(onRejected.call(undefined, promise.value));
                          } else {
                              reject(promise.value);
                          }
                      }
                  } catch (e) {
                      reject(e);
                  }
              }
          }
      });
  };
  
  p.catch = function (onRejected) {
      return this.then(undefined, onRejected);
  };
  
  p.then = function then(onResolved, onRejected) {
      var promise = this;
  
      return new Promise(function (resolve, reject) {
          promise.deferred.push([onResolved, onRejected, resolve, reject]);
          promise.notify();
      });
  };
  
  var queue = [];
  var async = function (callback) {
      queue.push(callback);
  
      if (queue.length === 1) {
          async.async();
      }
  };
  
  async.run = function () {
      while (queue.length) {
          queue[0]();
          queue.shift();
      }
  };
  
  if (window.MutationObserver) {
      var el = document.createElement('div');
      var mo = new MutationObserver(async.run);
  
      mo.observe(el, {
          attributes: true
      });
  
      async.async = function () {
          el.setAttribute("x", 0);
      };
  } else {
      async.async = function () {
          setTimeout(async.run);
      };
  }
  
  module.exports = window.Promise || Promise;
  
  },{}],16:[function(require,module,exports){
  /**
   * Utility functions.
   */
  
  module.exports = function (Vue) {
  
      var _ = Vue.util.extend({}, Vue.util);
  
      _.isString = function (value) {
          return typeof value === 'string';
      };
  
      _.isFunction = function (value) {
          return typeof value === 'function';
      };
  
      _.options = function (fn, obj, options) {
  
          options = options || {};
  
          if (_.isFunction(options)) {
              options = options.call(obj);
          }
  
          return _.extend(fn.bind({vm: obj, options: options}), fn, {options: options});
      };
  
      _.each = function (obj, iterator) {
  
          var i, key;
  
          if (typeof obj.length == 'number') {
              for (i = 0; i < obj.length; i++) {
                  iterator.call(obj[i], obj[i], i);
              }
          } else if (_.isObject(obj)) {
              for (key in obj) {
                  if (obj.hasOwnProperty(key)) {
                      iterator.call(obj[key], obj[key], key);
                  }
              }
          }
  
          return obj;
      };
  
      _.extend = function (target) {
  
          var array = [], args = array.slice.call(arguments, 1), deep;
  
          if (typeof target == 'boolean') {
              deep = target;
              target = args.shift();
          }
  
          args.forEach(function (arg) {
              extend(target, arg, deep);
          });
  
          return target;
      };
  
      function extend(target, source, deep) {
          for (var key in source) {
              if (deep && (_.isPlainObject(source[key]) || _.isArray(source[key]))) {
                  if (_.isPlainObject(source[key]) && !_.isPlainObject(target[key])) {
                      target[key] = {};
                  }
                  if (_.isArray(source[key]) && !_.isArray(target[key])) {
                      target[key] = [];
                  }
                  extend(target[key], source[key], deep);
              } else if (source[key] !== undefined) {
                  target[key] = source[key];
              }
          }
      }
  
      return _;
  };
  
  },{}],17:[function(require,module,exports){
  /**
   * XMLHttp request.
   */
  
  var Promise = require('./promise');
  var XDomain = window.XDomainRequest;
  
  module.exports = function (_, options) {
  
      var request = new XMLHttpRequest(), promise;
  
      if (XDomain && options.crossOrigin) {
          request = new XDomainRequest(); options.headers = {};
      }
  
      if (_.isPlainObject(options.xhr)) {
          _.extend(request, options.xhr);
      }
  
      if (_.isFunction(options.beforeSend)) {
          options.beforeSend.call(this, request, options);
      }
  
      promise = new Promise(function (resolve, reject) {
  
          request.open(options.method, _.url(options), true);
  
          _.each(options.headers, function (value, header) {
              request.setRequestHeader(header, value);
          });
  
          var handler = function (event) {
  
              request.ok = event.type === 'load';
  
              if (request.ok && request.status) {
                  request.ok = request.status >= 200 && request.status < 300;
              }
  
              (request.ok ? resolve : reject)(request);
          };
  
          request.onload = handler;
          request.onabort = handler;
          request.onerror = handler;
  
          request.send(options.data);
      });
  
      return promise;
  };
  
  },{"./promise":15}],18:[function(require,module,exports){
  /**
   * Service for interacting with RESTful services.
   */
  
  module.exports = function (_) {
  
      function Resource(url, params, actions, options) {
  
          var self = this, resource = {};
  
          actions = _.extend({},
              Resource.actions,
              actions
          );
  
          _.each(actions, function (action, name) {
  
              action = _.extend(true, {url: url, params: params || {}}, options, action);
  
              resource[name] = function () {
                  return (self.$http || _.http)(opts(action, arguments));
              };
          });
  
          return resource;
      }
  
      function opts(action, args) {
  
          var options = _.extend({}, action), params = {}, data, success, error;
  
          switch (args.length) {
  
              case 4:
  
                  error = args[3];
                  success = args[2];
  
              case 3:
              case 2:
  
                  if (_.isFunction(args[1])) {
  
                      if (_.isFunction(args[0])) {
  
                          success = args[0];
                          error = args[1];
  
                          break;
                      }
  
                      success = args[1];
                      error = args[2];
  
                  } else {
  
                      params = args[0];
                      data = args[1];
                      success = args[2];
  
                      break;
                  }
  
              case 1:
  
                  if (_.isFunction(args[0])) {
                      success = args[0];
                  } else if (/^(POST|PUT|PATCH)$/i.test(options.method)) {
                      data = args[0];
                  } else {
                      params = args[0];
                  }
  
                  break;
  
              case 0:
  
                  break;
  
              default:
  
                  throw 'Expected up to 4 arguments [params, data, success, error], got ' + args.length + ' arguments';
          }
  
          options.data = data;
          options.params = _.extend({}, options.params, params);
  
          if (success) {
              options.success = success;
          }
  
          if (error) {
              options.error = error;
          }
  
          return options;
      }
  
      Resource.actions = {
  
          get: {method: 'GET'},
          save: {method: 'POST'},
          query: {method: 'GET'},
          update: {method: 'PUT'},
          remove: {method: 'DELETE'},
          delete: {method: 'DELETE'}
  
      };
  
      return _.resource = Resource;
  };
  
  },{}],19:[function(require,module,exports){
  /**
   * Service for URL templating.
   */
  
  var ie = document.documentMode;
  var el = document.createElement('a');
  
  module.exports = function (_) {
  
      function Url(url, params) {
  
          var urlParams = {}, queryParams = {}, options = url, query;
  
          if (!_.isPlainObject(options)) {
              options = {url: url, params: params};
          }
  
          options = _.extend(true, {},
              Url.options, this.options, options
          );
  
          url = options.url.replace(/(\/?):([a-z]\w*)/gi, function (match, slash, name) {
  
              if (options.params[name]) {
                  urlParams[name] = true;
                  return slash + encodeUriSegment(options.params[name]);
              }
  
              return '';
          });
  
          if (_.isString(options.root) && !url.match(/^(https?:)?\//)) {
              url = options.root + '/' + url;
          }
  
          _.each(options.params, function (value, key) {
              if (!urlParams[key]) {
                  queryParams[key] = value;
              }
          });
  
          query = Url.params(queryParams);
  
          if (query) {
              url += (url.indexOf('?') == -1 ? '?' : '&') + query;
          }
  
          return url;
      }
  
      /**
       * Url options.
       */
  
      Url.options = {
          url: '',
          root: null,
          params: {}
      };
  
      /**
       * Encodes a Url parameter string.
       *
       * @param {Object} obj
       */
  
      Url.params = function (obj) {
  
          var params = [];
  
          params.add = function (key, value) {
  
              if (_.isFunction (value)) {
                  value = value();
              }
  
              if (value === null) {
                  value = '';
              }
  
              this.push(encodeUriSegment(key) + '=' + encodeUriSegment(value));
          };
  
          serialize(params, obj);
  
          return params.join('&');
      };
  
      /**
       * Parse a URL and return its components.
       *
       * @param {String} url
       */
  
      Url.parse = function (url) {
  
          if (ie) {
              el.href = url;
              url = el.href;
          }
  
          el.href = url;
  
          return {
              href: el.href,
              protocol: el.protocol ? el.protocol.replace(/:$/, '') : '',
              port: el.port,
              host: el.host,
              hostname: el.hostname,
              pathname: el.pathname.charAt(0) === '/' ? el.pathname : '/' + el.pathname,
              search: el.search ? el.search.replace(/^\?/, '') : '',
              hash: el.hash ? el.hash.replace(/^#/, '') : ''
          };
      };
  
      function serialize(params, obj, scope) {
  
          var array = _.isArray(obj), plain = _.isPlainObject(obj), hash;
  
          _.each(obj, function (value, key) {
  
              hash = _.isObject(value) || _.isArray(value);
  
              if (scope) {
                  key = scope + '[' + (plain || hash ? key : '') + ']';
              }
  
              if (!scope && array) {
                  params.add(value.name, value.value);
              } else if (hash) {
                  serialize(params, value, key);
              } else {
                  params.add(key, value);
              }
          });
      }
  
      function encodeUriSegment(value) {
  
          return encodeUriQuery(value, true).
              replace(/%26/gi, '&').
              replace(/%3D/gi, '=').
              replace(/%2B/gi, '+');
      }
  
      function encodeUriQuery(value, spaces) {
  
          return encodeURIComponent(value).
              replace(/%40/gi, '@').
              replace(/%3A/gi, ':').
              replace(/%24/g, '$').
              replace(/%2C/gi, ',').
              replace(/%20/g, (spaces ? '%20' : '+'));
      }
  
      return _.url = Url;
  };
  
  },{}],20:[function(require,module,exports){
  var _ = require('../util')
  var Watcher = require('../watcher')
  var Path = require('../parsers/path')
  var textParser = require('../parsers/text')
  var dirParser = require('../parsers/directive')
  var expParser = require('../parsers/expression')
  var filterRE = /[^|]\|[^|]/
  
  /**
   * Get the value from an expression on this vm.
   *
   * @param {String} exp
   * @param {Boolean} [asStatement]
   * @return {*}
   */
  
  exports.$get = function (exp, asStatement) {
    var res = expParser.parse(exp)
    if (res) {
      if (asStatement && !expParser.isSimplePath(exp)) {
        var self = this
        return function statementHandler () {
          res.get.call(self, self)
        }
      } else {
        try {
          return res.get.call(this, this)
        } catch (e) {}
      }
    }
  }
  
  /**
   * Set the value from an expression on this vm.
   * The expression must be a valid left-hand
   * expression in an assignment.
   *
   * @param {String} exp
   * @param {*} val
   */
  
  exports.$set = function (exp, val) {
    var res = expParser.parse(exp, true)
    if (res && res.set) {
      res.set.call(this, this, val)
    }
  }
  
  /**
   * Delete a property on the VM
   *
   * @param {String} key
   */
  
  exports.$delete = function (key) {
    _.delete(this._data, key)
  }
  
  /**
   * Watch an expression, trigger callback when its
   * value changes.
   *
   * @param {String|Function} expOrFn
   * @param {Function} cb
   * @param {Object} [options]
   *                 - {Boolean} deep
   *                 - {Boolean} immediate
   * @return {Function} - unwatchFn
   */
  
  exports.$watch = function (expOrFn, cb, options) {
    var vm = this
    var parsed
    if (typeof expOrFn === 'string') {
      parsed = dirParser.parse(expOrFn)
      expOrFn = parsed.expression
    }
    var watcher = new Watcher(vm, expOrFn, cb, {
      deep: options && options.deep,
      filters: parsed && parsed.filters
    })
    if (options && options.immediate) {
      cb.call(vm, watcher.value)
    }
    return function unwatchFn () {
      watcher.teardown()
    }
  }
  
  /**
   * Evaluate a text directive, including filters.
   *
   * @param {String} text
   * @param {Boolean} [asStatement]
   * @return {String}
   */
  
  exports.$eval = function (text, asStatement) {
    // check for filters.
    if (filterRE.test(text)) {
      var dir = dirParser.parse(text)
      // the filter regex check might give false positive
      // for pipes inside strings, so it's possible that
      // we don't get any filters here
      var val = this.$get(dir.expression, asStatement)
      return dir.filters
        ? this._applyFilters(val, null, dir.filters)
        : val
    } else {
      // no filter
      return this.$get(text, asStatement)
    }
  }
  
  /**
   * Interpolate a piece of template text.
   *
   * @param {String} text
   * @return {String}
   */
  
  exports.$interpolate = function (text) {
    var tokens = textParser.parse(text)
    var vm = this
    if (tokens) {
      if (tokens.length === 1) {
        return vm.$eval(tokens[0].value) + ''
      } else {
        return tokens.map(function (token) {
          return token.tag
            ? vm.$eval(token.value)
            : token.value
        }).join('')
      }
    } else {
      return text
    }
  }
  
  /**
   * Log instance data as a plain JS object
   * so that it is easier to inspect in console.
   * This method assumes console is available.
   *
   * @param {String} [path]
   */
  
  exports.$log = function (path) {
    var data = path
      ? Path.get(this._data, path)
      : this._data
    if (data) {
      data = clean(data)
    }
    // include computed fields
    if (!path) {
      for (var key in this.$options.computed) {
        data[key] = clean(this[key])
      }
    }
    console.log(data)
  }
  
  /**
   * "clean" a getter/setter converted object into a plain
   * object copy.
   *
   * @param {Object} - obj
   * @return {Object}
   */
  
  function clean (obj) {
    return JSON.parse(JSON.stringify(obj))
  }
  
  },{"../parsers/directive":70,"../parsers/expression":71,"../parsers/path":72,"../parsers/text":74,"../util":82,"../watcher":86}],21:[function(require,module,exports){
  var _ = require('../util')
  var transition = require('../transition')
  
  /**
   * Convenience on-instance nextTick. The callback is
   * auto-bound to the instance, and this avoids component
   * modules having to rely on the global Vue.
   *
   * @param {Function} fn
   */
  
  exports.$nextTick = function (fn) {
    _.nextTick(fn, this)
  }
  
  /**
   * Append instance to target
   *
   * @param {Node} target
   * @param {Function} [cb]
   * @param {Boolean} [withTransition] - defaults to true
   */
  
  exports.$appendTo = function (target, cb, withTransition) {
    return insert(
      this, target, cb, withTransition,
      append, transition.append
    )
  }
  
  /**
   * Prepend instance to target
   *
   * @param {Node} target
   * @param {Function} [cb]
   * @param {Boolean} [withTransition] - defaults to true
   */
  
  exports.$prependTo = function (target, cb, withTransition) {
    target = query(target)
    if (target.hasChildNodes()) {
      this.$before(target.firstChild, cb, withTransition)
    } else {
      this.$appendTo(target, cb, withTransition)
    }
    return this
  }
  
  /**
   * Insert instance before target
   *
   * @param {Node} target
   * @param {Function} [cb]
   * @param {Boolean} [withTransition] - defaults to true
   */
  
  exports.$before = function (target, cb, withTransition) {
    return insert(
      this, target, cb, withTransition,
      before, transition.before
    )
  }
  
  /**
   * Insert instance after target
   *
   * @param {Node} target
   * @param {Function} [cb]
   * @param {Boolean} [withTransition] - defaults to true
   */
  
  exports.$after = function (target, cb, withTransition) {
    target = query(target)
    if (target.nextSibling) {
      this.$before(target.nextSibling, cb, withTransition)
    } else {
      this.$appendTo(target.parentNode, cb, withTransition)
    }
    return this
  }
  
  /**
   * Remove instance from DOM
   *
   * @param {Function} [cb]
   * @param {Boolean} [withTransition] - defaults to true
   */
  
  exports.$remove = function (cb, withTransition) {
    if (!this.$el.parentNode) {
      return cb && cb()
    }
    var inDoc = this._isAttached && _.inDoc(this.$el)
    // if we are not in document, no need to check
    // for transitions
    if (!inDoc) withTransition = false
    var self = this
    var realCb = function () {
      if (inDoc) self._callHook('detached')
      if (cb) cb()
    }
    if (this._isFragment) {
      _.removeNodeRange(
        this._fragmentStart,
        this._fragmentEnd,
        this, this._fragment, realCb
      )
    } else {
      var op = withTransition === false
        ? remove
        : transition.remove
      op(this.$el, this, realCb)
    }
    return this
  }
  
  /**
   * Shared DOM insertion function.
   *
   * @param {Vue} vm
   * @param {Element} target
   * @param {Function} [cb]
   * @param {Boolean} [withTransition]
   * @param {Function} op1 - op for non-transition insert
   * @param {Function} op2 - op for transition insert
   * @return vm
   */
  
  function insert (vm, target, cb, withTransition, op1, op2) {
    target = query(target)
    var targetIsDetached = !_.inDoc(target)
    var op = withTransition === false || targetIsDetached
        ? op1
        : op2
    var shouldCallHook =
      !targetIsDetached &&
      !vm._isAttached &&
      !_.inDoc(vm.$el)
    if (vm._isFragment) {
      _.mapNodeRange(vm._fragmentStart, vm._fragmentEnd, function (node) {
        op(node, target, vm)
      })
      cb && cb()
    } else {
      op(vm.$el, target, vm, cb)
    }
    if (shouldCallHook) {
      vm._callHook('attached')
    }
    return vm
  }
  
  /**
   * Check for selectors
   *
   * @param {String|Element} el
   */
  
  function query (el) {
    return typeof el === 'string'
      ? document.querySelector(el)
      : el
  }
  
  /**
   * Append operation that takes a callback.
   *
   * @param {Node} el
   * @param {Node} target
   * @param {Vue} vm - unused
   * @param {Function} [cb]
   */
  
  function append (el, target, vm, cb) {
    target.appendChild(el)
    if (cb) cb()
  }
  
  /**
   * InsertBefore operation that takes a callback.
   *
   * @param {Node} el
   * @param {Node} target
   * @param {Vue} vm - unused
   * @param {Function} [cb]
   */
  
  function before (el, target, vm, cb) {
    _.before(el, target)
    if (cb) cb()
  }
  
  /**
   * Remove operation that takes a callback.
   *
   * @param {Node} el
   * @param {Vue} vm - unused
   * @param {Function} [cb]
   */
  
  function remove (el, vm, cb) {
    _.remove(el)
    if (cb) cb()
  }
  
  },{"../transition":75,"../util":82}],22:[function(require,module,exports){
  var _ = require('../util')
  
  /**
   * Listen on the given `event` with `fn`.
   *
   * @param {String} event
   * @param {Function} fn
   */
  
  exports.$on = function (event, fn) {
    (this._events[event] || (this._events[event] = []))
      .push(fn)
    modifyListenerCount(this, event, 1)
    return this
  }
  
  /**
   * Adds an `event` listener that will be invoked a single
   * time then automatically removed.
   *
   * @param {String} event
   * @param {Function} fn
   */
  
  exports.$once = function (event, fn) {
    var self = this
    function on () {
      self.$off(event, on)
      fn.apply(this, arguments)
    }
    on.fn = fn
    this.$on(event, on)
    return this
  }
  
  /**
   * Remove the given callback for `event` or all
   * registered callbacks.
   *
   * @param {String} event
   * @param {Function} fn
   */
  
  exports.$off = function (event, fn) {
    var cbs
    // all
    if (!arguments.length) {
      if (this.$parent) {
        for (event in this._events) {
          cbs = this._events[event]
          if (cbs) {
            modifyListenerCount(this, event, -cbs.length)
          }
        }
      }
      this._events = {}
      return this
    }
    // specific event
    cbs = this._events[event]
    if (!cbs) {
      return this
    }
    if (arguments.length === 1) {
      modifyListenerCount(this, event, -cbs.length)
      this._events[event] = null
      return this
    }
    // specific handler
    var cb
    var i = cbs.length
    while (i--) {
      cb = cbs[i]
      if (cb === fn || cb.fn === fn) {
        modifyListenerCount(this, event, -1)
        cbs.splice(i, 1)
        break
      }
    }
    return this
  }
  
  /**
   * Trigger an event on self.
   *
   * @param {String} event
   */
  
  exports.$emit = function (event) {
    var cbs = this._events[event]
    this._shouldPropagate = !cbs
    if (cbs) {
      cbs = cbs.length > 1
        ? _.toArray(cbs)
        : cbs
      var args = _.toArray(arguments, 1)
      for (var i = 0, l = cbs.length; i < l; i++) {
        var res = cbs[i].apply(this, args)
        if (res === true) {
          this._shouldPropagate = true
        }
      }
    }
    return this
  }
  
  /**
   * Recursively broadcast an event to all children instances.
   *
   * @param {String} event
   * @param {...*} additional arguments
   */
  
  exports.$broadcast = function (event) {
    // if no child has registered for this event,
    // then there's no need to broadcast.
    if (!this._eventsCount[event]) return
    var children = this.$children
    for (var i = 0, l = children.length; i < l; i++) {
      var child = children[i]
      child.$emit.apply(child, arguments)
      if (child._shouldPropagate) {
        child.$broadcast.apply(child, arguments)
      }
    }
    return this
  }
  
  /**
   * Recursively propagate an event up the parent chain.
   *
   * @param {String} event
   * @param {...*} additional arguments
   */
  
  exports.$dispatch = function () {
    this.$emit.apply(this, arguments)
    var parent = this.$parent
    while (parent) {
      parent.$emit.apply(parent, arguments)
      parent = parent._shouldPropagate
        ? parent.$parent
        : null
    }
    return this
  }
  
  /**
   * Modify the listener counts on all parents.
   * This bookkeeping allows $broadcast to return early when
   * no child has listened to a certain event.
   *
   * @param {Vue} vm
   * @param {String} event
   * @param {Number} count
   */
  
  var hookRE = /^hook:/
  function modifyListenerCount (vm, event, count) {
    var parent = vm.$parent
    // hooks do not get broadcasted so no need
    // to do bookkeeping for them
    if (!parent || !count || hookRE.test(event)) return
    while (parent) {
      parent._eventsCount[event] =
        (parent._eventsCount[event] || 0) + count
      parent = parent.$parent
    }
  }
  
  },{"../util":82}],23:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var config = require('../config')
  
  /**
   * Expose useful internals
   */
  
  exports.util = _
  exports.config = config
  exports.set = _.set
  exports.delete = _.delete
  exports.nextTick = _.nextTick
  
  /**
   * The following are exposed for advanced usage / plugins
   */
  
  exports.compiler = require('../compiler')
  exports.FragmentFactory = require('../fragment/factory')
  exports.internalDirectives = require('../directives/internal')
  exports.parsers = {
    path: require('../parsers/path'),
    text: require('../parsers/text'),
    template: require('../parsers/template'),
    directive: require('../parsers/directive'),
    expression: require('../parsers/expression')
  }
  
  /**
   * Each instance constructor, including Vue, has a unique
   * cid. This enables us to create wrapped "child
   * constructors" for prototypal inheritance and cache them.
   */
  
  exports.cid = 0
  var cid = 1
  
  /**
   * Class inheritance
   *
   * @param {Object} extendOptions
   */
  
  exports.extend = function (extendOptions) {
    extendOptions = extendOptions || {}
    var Super = this
    var isFirstExtend = Super.cid === 0
    if (isFirstExtend && extendOptions._Ctor) {
      return extendOptions._Ctor
    }
    var name = extendOptions.name || Super.options.name
    var Sub = createClass(name || 'VueComponent')
    Sub.prototype = Object.create(Super.prototype)
    Sub.prototype.constructor = Sub
    Sub.cid = cid++
    Sub.options = _.mergeOptions(
      Super.options,
      extendOptions
    )
    Sub['super'] = Super
    // allow further extension
    Sub.extend = Super.extend
    // create asset registers, so extended classes
    // can have their private assets too.
    config._assetTypes.forEach(function (type) {
      Sub[type] = Super[type]
    })
    // enable recursive self-lookup
    if (name) {
      Sub.options.components[name] = Sub
    }
    // cache constructor
    if (isFirstExtend) {
      extendOptions._Ctor = Sub
    }
    return Sub
  }
  
  /**
   * A function that returns a sub-class constructor with the
   * given name. This gives us much nicer output when
   * logging instances in the console.
   *
   * @param {String} name
   * @return {Function}
   */
  
  function createClass (name) {
    return new Function(
      'return function ' + _.classify(name) +
      ' (options) { this._init(options) }'
    )()
  }
  
  /**
   * Plugin system
   *
   * @param {Object} plugin
   */
  
  exports.use = function (plugin) {
    /* istanbul ignore if */
    if (plugin.installed) {
      return
    }
    // additional parameters
    var args = _.toArray(arguments, 1)
    args.unshift(this)
    if (typeof plugin.install === 'function') {
      plugin.install.apply(plugin, args)
    } else {
      plugin.apply(null, args)
    }
    plugin.installed = true
    return this
  }
  
  /**
   * Apply a global mixin by merging it into the default
   * options.
   */
  
  exports.mixin = function (mixin) {
    var Vue = _.Vue
    Vue.options = _.mergeOptions(Vue.options, mixin)
  }
  
  /**
   * Create asset registration methods with the following
   * signature:
   *
   * @param {String} id
   * @param {*} definition
   */
  
  config._assetTypes.forEach(function (type) {
    exports[type] = function (id, definition) {
      if (!definition) {
        return this.options[type + 's'][id]
      } else {
        /* istanbul ignore if */
        if (process.env.NODE_ENV !== 'production') {
          if (type === 'component' && _.commonTagRE.test(id)) {
            _.warn(
              'Do not use built-in HTML elements as component ' +
              'id: ' + id
            )
          }
        }
        if (
          type === 'component' &&
          _.isPlainObject(definition)
        ) {
          definition.name = id
          definition = _.Vue.extend(definition)
        }
        this.options[type + 's'][id] = definition
        return definition
      }
    }
  })
  
  }).call(this,require('_process'))
  },{"../compiler":29,"../config":31,"../directives/internal":38,"../fragment/factory":60,"../parsers/directive":70,"../parsers/expression":71,"../parsers/path":72,"../parsers/template":73,"../parsers/text":74,"../util":82,"_process":5}],24:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var compiler = require('../compiler')
  
  /**
   * Set instance target element and kick off the compilation
   * process. The passed in `el` can be a selector string, an
   * existing Element, or a DocumentFragment (for block
   * instances).
   *
   * @param {Element|DocumentFragment|string} el
   * @public
   */
  
  exports.$mount = function (el) {
    if (this._isCompiled) {
      process.env.NODE_ENV !== 'production' && _.warn(
        '$mount() should be called only once.'
      )
      return
    }
    el = _.query(el)
    if (!el) {
      el = document.createElement('div')
    }
    this._compile(el)
    this._initDOMHooks()
    if (_.inDoc(this.$el)) {
      this._callHook('attached')
      ready.call(this)
    } else {
      this.$once('hook:attached', ready)
    }
    return this
  }
  
  /**
   * Mark an instance as ready.
   */
  
  function ready () {
    this._isAttached = true
    this._isReady = true
    this._callHook('ready')
  }
  
  /**
   * Teardown the instance, simply delegate to the internal
   * _destroy.
   */
  
  exports.$destroy = function (remove, deferCleanup) {
    this._destroy(remove, deferCleanup)
  }
  
  /**
   * Partially compile a piece of DOM and return a
   * decompile function.
   *
   * @param {Element|DocumentFragment} el
   * @param {Vue} [host]
   * @return {Function}
   */
  
  exports.$compile = function (el, host, scope, frag) {
    return compiler.compile(el, this.$options, true)(
      this, el, host, scope, frag
    )
  }
  
  }).call(this,require('_process'))
  },{"../compiler":29,"../util":82,"_process":5}],25:[function(require,module,exports){
  (function (process){
  var _ = require('./util')
  var config = require('./config')
  
  // we have two separate queues: one for directive updates
  // and one for user watcher registered via $watch().
  // we want to guarantee directive updates to be called
  // before user watchers so that when user watchers are
  // triggered, the DOM would have already been in updated
  // state.
  var queue = []
  var userQueue = []
  var has = {}
  var circular = {}
  var waiting = false
  var internalQueueDepleted = false
  
  /**
   * Reset the batcher's state.
   */
  
  function resetBatcherState () {
    queue = []
    userQueue = []
    has = {}
    circular = {}
    waiting = internalQueueDepleted = false
  }
  
  /**
   * Flush both queues and run the watchers.
   */
  
  function flushBatcherQueue () {
    runBatcherQueue(queue)
    internalQueueDepleted = true
    runBatcherQueue(userQueue)
    // dev tool hook
    /* istanbul ignore if */
    if (process.env.NODE_ENV !== 'production') {
      if (_.inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
        window.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit('flush')
      }
    }
    resetBatcherState()
  }
  
  /**
   * Run the watchers in a single queue.
   *
   * @param {Array} queue
   */
  
  function runBatcherQueue (queue) {
    // do not cache length because more watchers might be pushed
    // as we run existing watchers
    for (var i = 0; i < queue.length; i++) {
      var watcher = queue[i]
      var id = watcher.id
      has[id] = null
      watcher.run()
      // in dev build, check and stop circular updates.
      if (process.env.NODE_ENV !== 'production' && has[id] != null) {
        circular[id] = (circular[id] || 0) + 1
        if (circular[id] > config._maxUpdateCount) {
          queue.splice(has[id], 1)
          _.warn(
            'You may have an infinite update loop for watcher ' +
            'with expression: ' + watcher.expression
          )
        }
      }
    }
  }
  
  /**
   * Push a watcher into the watcher queue.
   * Jobs with duplicate IDs will be skipped unless it's
   * pushed when the queue is being flushed.
   *
   * @param {Watcher} watcher
   *   properties:
   *   - {Number} id
   *   - {Function} run
   */
  
  exports.push = function (watcher) {
    var id = watcher.id
    if (has[id] == null) {
      // if an internal watcher is pushed, but the internal
      // queue is already depleted, we run it immediately.
      if (internalQueueDepleted && !watcher.user) {
        watcher.run()
        return
      }
      // push watcher into appropriate queue
      var q = watcher.user ? userQueue : queue
      has[id] = q.length
      q.push(watcher)
      // queue the flush
      if (!waiting) {
        waiting = true
        _.nextTick(flushBatcherQueue)
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"./config":31,"./util":82,"_process":5}],26:[function(require,module,exports){
  /**
   * A doubly linked list-based Least Recently Used (LRU)
   * cache. Will keep most recently used items while
   * discarding least recently used items when its limit is
   * reached. This is a bare-bone version of
   * Rasmus Andersson's js-lru:
   *
   *   https://github.com/rsms/js-lru
   *
   * @param {Number} limit
   * @constructor
   */
  
  function Cache (limit) {
    this.size = 0
    this.limit = limit
    this.head = this.tail = undefined
    this._keymap = Object.create(null)
  }
  
  var p = Cache.prototype
  
  /**
   * Put <value> into the cache associated with <key>.
   * Returns the entry which was removed to make room for
   * the new entry. Otherwise undefined is returned.
   * (i.e. if there was enough room already).
   *
   * @param {String} key
   * @param {*} value
   * @return {Entry|undefined}
   */
  
  p.put = function (key, value) {
    var entry = {
      key: key,
      value: value
    }
    this._keymap[key] = entry
    if (this.tail) {
      this.tail.newer = entry
      entry.older = this.tail
    } else {
      this.head = entry
    }
    this.tail = entry
    if (this.size === this.limit) {
      return this.shift()
    } else {
      this.size++
    }
  }
  
  /**
   * Purge the least recently used (oldest) entry from the
   * cache. Returns the removed entry or undefined if the
   * cache was empty.
   */
  
  p.shift = function () {
    var entry = this.head
    if (entry) {
      this.head = this.head.newer
      this.head.older = undefined
      entry.newer = entry.older = undefined
      this._keymap[entry.key] = undefined
    }
    return entry
  }
  
  /**
   * Get and register recent use of <key>. Returns the value
   * associated with <key> or undefined if not in cache.
   *
   * @param {String} key
   * @param {Boolean} returnEntry
   * @return {Entry|*}
   */
  
  p.get = function (key, returnEntry) {
    var entry = this._keymap[key]
    if (entry === undefined) return
    if (entry === this.tail) {
      return returnEntry
        ? entry
        : entry.value
    }
    // HEAD--------------TAIL
    //   <.older   .newer>
    //  <--- add direction --
    //   A  B  C  <D>  E
    if (entry.newer) {
      if (entry === this.head) {
        this.head = entry.newer
      }
      entry.newer.older = entry.older // C <-- E.
    }
    if (entry.older) {
      entry.older.newer = entry.newer // C. --> E
    }
    entry.newer = undefined // D --x
    entry.older = this.tail // D. --> E
    if (this.tail) {
      this.tail.newer = entry // E. <-- D
    }
    this.tail = entry
    return returnEntry
      ? entry
      : entry.value
  }
  
  module.exports = Cache
  
  },{}],27:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var dirParser = require('../parsers/directive')
  var propDef = require('../directives/internal/prop')
  var propBindingModes = require('../config')._propBindingModes
  var empty = {}
  
  // regexes
  var identRE = require('../parsers/path').identRE
  var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/
  
  /**
   * Compile props on a root element and return
   * a props link function.
   *
   * @param {Element|DocumentFragment} el
   * @param {Array} propOptions
   * @return {Function} propsLinkFn
   */
  
  module.exports = function compileProps (el, propOptions) {
    var props = []
    var names = Object.keys(propOptions)
    var i = names.length
    var options, name, attr, value, path, parsed, prop
    while (i--) {
      name = names[i]
      options = propOptions[name] || empty
  
      if (process.env.NODE_ENV !== 'production' && name === '$data') {
        _.warn('Do not use $data as prop.')
        continue
      }
  
      // props could contain dashes, which will be
      // interpreted as minus calculations by the parser
      // so we need to camelize the path here
      path = _.camelize(name)
      if (!identRE.test(path)) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'Invalid prop key: "' + name + '". Prop keys ' +
          'must be valid identifiers.'
        )
        continue
      }
  
      prop = {
        name: name,
        path: path,
        options: options,
        mode: propBindingModes.ONE_WAY,
        raw: null
      }
  
      attr = _.hyphenate(name)
      // first check dynamic version
      if ((value = _.getBindAttr(el, attr)) === null) {
        if ((value = _.getBindAttr(el, attr + '.sync')) !== null) {
          prop.mode = propBindingModes.TWO_WAY
        } else if ((value = _.getBindAttr(el, attr + '.once')) !== null) {
          prop.mode = propBindingModes.ONE_TIME
        }
      }
      if (value !== null) {
        // has dynamic binding!
        prop.raw = value
        parsed = dirParser.parse(value)
        value = parsed.expression
        prop.filters = parsed.filters
        // check binding type
        if (_.isLiteral(value)) {
          // for expressions containing literal numbers and
          // booleans, there's no need to setup a prop binding,
          // so we can optimize them as a one-time set.
          prop.optimizedLiteral = true
        } else {
          prop.dynamic = true
          // check non-settable path for two-way bindings
          if (process.env.NODE_ENV !== 'production' &&
              prop.mode === propBindingModes.TWO_WAY &&
              !settablePathRE.test(value)) {
            prop.mode = propBindingModes.ONE_WAY
            _.warn(
              'Cannot bind two-way prop with non-settable ' +
              'parent path: ' + value
            )
          }
        }
        prop.parentPath = value
  
        // warn required two-way
        if (
          process.env.NODE_ENV !== 'production' &&
          options.twoWay &&
          prop.mode !== propBindingModes.TWO_WAY
        ) {
          _.warn(
            'Prop "' + name + '" expects a two-way binding type.'
          )
        }
      } else if ((value = _.attr(el, attr)) !== null) {
        // has literal binding!
        prop.raw = value
      } else if (options.required) {
        // warn missing required
        process.env.NODE_ENV !== 'production' && _.warn(
          'Missing required prop: ' + name
        )
      }
      // push prop
      props.push(prop)
    }
    return makePropsLinkFn(props)
  }
  
  /**
   * Build a function that applies props to a vm.
   *
   * @param {Array} props
   * @return {Function} propsLinkFn
   */
  
  function makePropsLinkFn (props) {
    return function propsLinkFn (vm, scope) {
      // store resolved props info
      vm._props = {}
      var i = props.length
      var prop, path, options, value, raw
      while (i--) {
        prop = props[i]
        raw = prop.raw
        path = prop.path
        options = prop.options
        vm._props[path] = prop
        if (raw === null) {
          // initialize absent prop
          _.initProp(vm, prop, getDefault(vm, options))
        } else if (prop.dynamic) {
          // dynamic prop
          if (vm._context) {
            if (prop.mode === propBindingModes.ONE_TIME) {
              // one time binding
              value = (scope || vm._context).$get(prop.parentPath)
              _.initProp(vm, prop, value)
            } else {
              // dynamic binding
              vm._bindDir({
                name: 'prop',
                def: propDef,
                prop: prop
              }, null, null, scope) // el, host, scope
            }
          } else {
            process.env.NODE_ENV !== 'production' && _.warn(
              'Cannot bind dynamic prop on a root instance' +
              ' with no parent: ' + prop.name + '="' +
              raw + '"'
            )
          }
        } else if (prop.optimizedLiteral) {
          // optimized literal, cast it and just set once
          var stripped = _.stripQuotes(raw)
          value = stripped === raw
            ? _.toBoolean(_.toNumber(raw))
            : stripped
          _.initProp(vm, prop, value)
        } else {
          // string literal, but we need to cater for
          // Boolean props with no value
          value = options.type === Boolean && raw === ''
            ? true
            : raw
          _.initProp(vm, prop, value)
        }
      }
    }
  }
  
  /**
   * Get the default value of a prop.
   *
   * @param {Vue} vm
   * @param {Object} options
   * @return {*}
   */
  
  function getDefault (vm, options) {
    // no default, return undefined
    if (!options.hasOwnProperty('default')) {
      // absent boolean value defaults to false
      return options.type === Boolean
        ? false
        : undefined
    }
    var def = options.default
    // warn against non-factory defaults for Object & Array
    if (_.isObject(def)) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Object/Array as default prop values will be shared ' +
        'across multiple instances. Use a factory function ' +
        'to return the default value instead.'
      )
    }
    // call factory function for non-Function types
    return typeof def === 'function' && options.type !== Function
      ? def.call(vm)
      : def
  }
  
  }).call(this,require('_process'))
  },{"../config":31,"../directives/internal/prop":39,"../parsers/directive":70,"../parsers/path":72,"../util":82,"_process":5}],28:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var publicDirectives = require('../directives/public')
  var internalDirectives = require('../directives/internal')
  var compileProps = require('./compile-props')
  var textParser = require('../parsers/text')
  var dirParser = require('../parsers/directive')
  var templateParser = require('../parsers/template')
  var resolveAsset = _.resolveAsset
  
  // special binding prefixes
  var bindRE = /^v-bind:|^:/
  var onRE = /^v-on:|^@/
  var argRE = /:(.*)$/
  var modifierRE = /\.[^\.]+/g
  var transitionRE = /^(v-bind:|:)?transition$/
  
  // terminal directives
  var terminalDirectives = [
    'for',
    'if'
  ]
  
  // default directive priority
  var DEFAULT_PRIORITY = 1000
  
  /**
   * Compile a template and return a reusable composite link
   * function, which recursively contains more link functions
   * inside. This top level compile function would normally
   * be called on instance root nodes, but can also be used
   * for partial compilation if the partial argument is true.
   *
   * The returned composite link function, when called, will
   * return an unlink function that tearsdown all directives
   * created during the linking phase.
   *
   * @param {Element|DocumentFragment} el
   * @param {Object} options
   * @param {Boolean} partial
   * @return {Function}
   */
  
  exports.compile = function (el, options, partial) {
    // link function for the node itself.
    var nodeLinkFn = partial || !options._asComponent
      ? compileNode(el, options)
      : null
    // link function for the childNodes
    var childLinkFn =
      !(nodeLinkFn && nodeLinkFn.terminal) &&
      el.tagName !== 'SCRIPT' &&
      el.hasChildNodes()
        ? compileNodeList(el.childNodes, options)
        : null
  
    /**
     * A composite linker function to be called on a already
     * compiled piece of DOM, which instantiates all directive
     * instances.
     *
     * @param {Vue} vm
     * @param {Element|DocumentFragment} el
     * @param {Vue} [host] - host vm of transcluded content
     * @param {Object} [scope] - v-for scope
     * @param {Fragment} [frag] - link context fragment
     * @return {Function|undefined}
     */
  
    return function compositeLinkFn (vm, el, host, scope, frag) {
      // cache childNodes before linking parent, fix #657
      var childNodes = _.toArray(el.childNodes)
      // link
      var dirs = linkAndCapture(function compositeLinkCapturer () {
        if (nodeLinkFn) nodeLinkFn(vm, el, host, scope, frag)
        if (childLinkFn) childLinkFn(vm, childNodes, host, scope, frag)
      }, vm)
      return makeUnlinkFn(vm, dirs)
    }
  }
  
  /**
   * Apply a linker to a vm/element pair and capture the
   * directives created during the process.
   *
   * @param {Function} linker
   * @param {Vue} vm
   */
  
  function linkAndCapture (linker, vm) {
    var originalDirCount = vm._directives.length
    linker()
    var dirs = vm._directives.slice(originalDirCount)
    dirs.sort(directiveComparator)
    for (var i = 0, l = dirs.length; i < l; i++) {
      dirs[i]._bind()
    }
    return dirs
  }
  
  /**
   * Directive priority sort comparator
   *
   * @param {Object} a
   * @param {Object} b
   */
  
  function directiveComparator (a, b) {
    a = a.descriptor.def.priority || DEFAULT_PRIORITY
    b = b.descriptor.def.priority || DEFAULT_PRIORITY
    return a > b ? -1 : a === b ? 0 : 1
  }
  
  /**
   * Linker functions return an unlink function that
   * tearsdown all directives instances generated during
   * the process.
   *
   * We create unlink functions with only the necessary
   * information to avoid retaining additional closures.
   *
   * @param {Vue} vm
   * @param {Array} dirs
   * @param {Vue} [context]
   * @param {Array} [contextDirs]
   * @return {Function}
   */
  
  function makeUnlinkFn (vm, dirs, context, contextDirs) {
    return function unlink (destroying) {
      teardownDirs(vm, dirs, destroying)
      if (context && contextDirs) {
        teardownDirs(context, contextDirs)
      }
    }
  }
  
  /**
   * Teardown partial linked directives.
   *
   * @param {Vue} vm
   * @param {Array} dirs
   * @param {Boolean} destroying
   */
  
  function teardownDirs (vm, dirs, destroying) {
    var i = dirs.length
    while (i--) {
      dirs[i]._teardown()
      if (!destroying) {
        vm._directives.$remove(dirs[i])
      }
    }
  }
  
  /**
   * Compile link props on an instance.
   *
   * @param {Vue} vm
   * @param {Element} el
   * @param {Object} props
   * @param {Object} [scope]
   * @return {Function}
   */
  
  exports.compileAndLinkProps = function (vm, el, props, scope) {
    var propsLinkFn = compileProps(el, props)
    var propDirs = linkAndCapture(function () {
      propsLinkFn(vm, scope)
    }, vm)
    return makeUnlinkFn(vm, propDirs)
  }
  
  /**
   * Compile the root element of an instance.
   *
   * 1. attrs on context container (context scope)
   * 2. attrs on the component template root node, if
   *    replace:true (child scope)
   *
   * If this is a fragment instance, we only need to compile 1.
   *
   * @param {Vue} vm
   * @param {Element} el
   * @param {Object} options
   * @param {Object} contextOptions
   * @return {Function}
   */
  
  exports.compileRoot = function (el, options, contextOptions) {
    var containerAttrs = options._containerAttrs
    var replacerAttrs = options._replacerAttrs
    var contextLinkFn, replacerLinkFn
  
    // only need to compile other attributes for
    // non-fragment instances
    if (el.nodeType !== 11) {
      // for components, container and replacer need to be
      // compiled separately and linked in different scopes.
      if (options._asComponent) {
        // 2. container attributes
        if (containerAttrs && contextOptions) {
          contextLinkFn = compileDirectives(containerAttrs, contextOptions)
        }
        if (replacerAttrs) {
          // 3. replacer attributes
          replacerLinkFn = compileDirectives(replacerAttrs, options)
        }
      } else {
        // non-component, just compile as a normal element.
        replacerLinkFn = compileDirectives(el.attributes, options)
      }
    } else if (process.env.NODE_ENV !== 'production' && containerAttrs) {
      // warn container directives for fragment instances
      var names = containerAttrs
        .filter(function (attr) {
          // allow vue-loader/vueify scoped css attributes
          return attr.name.indexOf('_v-') < 0 &&
            // allow event listeners
            !onRE.test(attr.name) &&
            // allow slots
            attr.name !== 'slot'
        })
        .map(function (attr) {
          return '"' + attr.name + '"'
        })
      if (names.length) {
        var plural = names.length > 1
        _.warn(
          'Attribute' + (plural ? 's ' : ' ') + names.join(', ') +
          (plural ? ' are' : ' is') + ' ignored on component ' +
          '<' + options.el.tagName.toLowerCase() + '> because ' +
          'the component is a fragment instance: ' +
          'http://vuejs.org/guide/components.html#Fragment_Instance'
        )
      }
    }
  
    return function rootLinkFn (vm, el, scope) {
      // link context scope dirs
      var context = vm._context
      var contextDirs
      if (context && contextLinkFn) {
        contextDirs = linkAndCapture(function () {
          contextLinkFn(context, el, null, scope)
        }, context)
      }
  
      // link self
      var selfDirs = linkAndCapture(function () {
        if (replacerLinkFn) replacerLinkFn(vm, el)
      }, vm)
  
      // return the unlink function that tearsdown context
      // container directives.
      return makeUnlinkFn(vm, selfDirs, context, contextDirs)
    }
  }
  
  /**
   * Compile a node and return a nodeLinkFn based on the
   * node type.
   *
   * @param {Node} node
   * @param {Object} options
   * @return {Function|null}
   */
  
  function compileNode (node, options) {
    var type = node.nodeType
    if (type === 1 && node.tagName !== 'SCRIPT') {
      return compileElement(node, options)
    } else if (type === 3 && node.data.trim()) {
      return compileTextNode(node, options)
    } else {
      return null
    }
  }
  
  /**
   * Compile an element and return a nodeLinkFn.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Function|null}
   */
  
  function compileElement (el, options) {
    // preprocess textareas.
    // textarea treats its text content as the initial value.
    // just bind it as an attr directive for value.
    if (el.tagName === 'TEXTAREA') {
      var tokens = textParser.parse(el.value)
      if (tokens) {
        el.setAttribute(':value', textParser.tokensToExp(tokens))
        el.value = ''
      }
    }
    var linkFn
    var hasAttrs = el.hasAttributes()
    // check terminal directives (for & if)
    if (hasAttrs) {
      linkFn = checkTerminalDirectives(el, options)
    }
    // check element directives
    if (!linkFn) {
      linkFn = checkElementDirectives(el, options)
    }
    // check component
    if (!linkFn) {
      linkFn = checkComponent(el, options)
    }
    // normal directives
    if (!linkFn && hasAttrs) {
      linkFn = compileDirectives(el.attributes, options)
    }
    return linkFn
  }
  
  /**
   * Compile a textNode and return a nodeLinkFn.
   *
   * @param {TextNode} node
   * @param {Object} options
   * @return {Function|null} textNodeLinkFn
   */
  
  function compileTextNode (node, options) {
    // skip marked text nodes
    if (node._skip) {
      return removeText
    }
  
    var tokens = textParser.parse(node.wholeText)
    if (!tokens) {
      return null
    }
  
    // mark adjacent text nodes as skipped,
    // because we are using node.wholeText to compile
    // all adjacent text nodes together. This fixes
    // issues in IE where sometimes it splits up a single
    // text node into multiple ones.
    var next = node.nextSibling
    while (next && next.nodeType === 3) {
      next._skip = true
      next = next.nextSibling
    }
  
    var frag = document.createDocumentFragment()
    var el, token
    for (var i = 0, l = tokens.length; i < l; i++) {
      token = tokens[i]
      el = token.tag
        ? processTextToken(token, options)
        : document.createTextNode(token.value)
      frag.appendChild(el)
    }
    return makeTextNodeLinkFn(tokens, frag, options)
  }
  
  /**
   * Linker for an skipped text node.
   *
   * @param {Vue} vm
   * @param {Text} node
   */
  
  function removeText (vm, node) {
    _.remove(node)
  }
  
  /**
   * Process a single text token.
   *
   * @param {Object} token
   * @param {Object} options
   * @return {Node}
   */
  
  function processTextToken (token, options) {
    var el
    if (token.oneTime) {
      el = document.createTextNode(token.value)
    } else {
      if (token.html) {
        el = document.createComment('v-html')
        setTokenType('html')
      } else {
        // IE will clean up empty textNodes during
        // frag.cloneNode(true), so we have to give it
        // something here...
        el = document.createTextNode(' ')
        setTokenType('text')
      }
    }
    function setTokenType (type) {
      if (token.descriptor) return
      var parsed = dirParser.parse(token.value)
      token.descriptor = {
        name: type,
        def: publicDirectives[type],
        expression: parsed.expression,
        filters: parsed.filters
      }
    }
    return el
  }
  
  /**
   * Build a function that processes a textNode.
   *
   * @param {Array<Object>} tokens
   * @param {DocumentFragment} frag
   */
  
  function makeTextNodeLinkFn (tokens, frag) {
    return function textNodeLinkFn (vm, el, host, scope) {
      var fragClone = frag.cloneNode(true)
      var childNodes = _.toArray(fragClone.childNodes)
      var token, value, node
      for (var i = 0, l = tokens.length; i < l; i++) {
        token = tokens[i]
        value = token.value
        if (token.tag) {
          node = childNodes[i]
          if (token.oneTime) {
            value = (scope || vm).$eval(value)
            if (token.html) {
              _.replace(node, templateParser.parse(value, true))
            } else {
              node.data = value
            }
          } else {
            vm._bindDir(token.descriptor, node, host, scope)
          }
        }
      }
      _.replace(el, fragClone)
    }
  }
  
  /**
   * Compile a node list and return a childLinkFn.
   *
   * @param {NodeList} nodeList
   * @param {Object} options
   * @return {Function|undefined}
   */
  
  function compileNodeList (nodeList, options) {
    var linkFns = []
    var nodeLinkFn, childLinkFn, node
    for (var i = 0, l = nodeList.length; i < l; i++) {
      node = nodeList[i]
      nodeLinkFn = compileNode(node, options)
      childLinkFn =
        !(nodeLinkFn && nodeLinkFn.terminal) &&
        node.tagName !== 'SCRIPT' &&
        node.hasChildNodes()
          ? compileNodeList(node.childNodes, options)
          : null
      linkFns.push(nodeLinkFn, childLinkFn)
    }
    return linkFns.length
      ? makeChildLinkFn(linkFns)
      : null
  }
  
  /**
   * Make a child link function for a node's childNodes.
   *
   * @param {Array<Function>} linkFns
   * @return {Function} childLinkFn
   */
  
  function makeChildLinkFn (linkFns) {
    return function childLinkFn (vm, nodes, host, scope, frag) {
      var node, nodeLinkFn, childrenLinkFn
      for (var i = 0, n = 0, l = linkFns.length; i < l; n++) {
        node = nodes[n]
        nodeLinkFn = linkFns[i++]
        childrenLinkFn = linkFns[i++]
        // cache childNodes before linking parent, fix #657
        var childNodes = _.toArray(node.childNodes)
        if (nodeLinkFn) {
          nodeLinkFn(vm, node, host, scope, frag)
        }
        if (childrenLinkFn) {
          childrenLinkFn(vm, childNodes, host, scope, frag)
        }
      }
    }
  }
  
  /**
   * Check for element directives (custom elements that should
   * be resovled as terminal directives).
   *
   * @param {Element} el
   * @param {Object} options
   */
  
  function checkElementDirectives (el, options) {
    var tag = el.tagName.toLowerCase()
    if (_.commonTagRE.test(tag)) return
    var def = resolveAsset(options, 'elementDirectives', tag)
    if (def) {
      return makeTerminalNodeLinkFn(el, tag, '', options, def)
    }
  }
  
  /**
   * Check if an element is a component. If yes, return
   * a component link function.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Function|undefined}
   */
  
  function checkComponent (el, options) {
    var component = _.checkComponent(el, options)
    if (component) {
      var ref = _.findRef(el)
      var descriptor = {
        name: 'component',
        ref: ref,
        expression: component.id,
        def: internalDirectives.component,
        modifiers: {
          literal: !component.dynamic
        }
      }
      var componentLinkFn = function (vm, el, host, scope, frag) {
        if (ref) {
          _.defineReactive((scope || vm).$refs, ref, null)
        }
        vm._bindDir(descriptor, el, host, scope, frag)
      }
      componentLinkFn.terminal = true
      return componentLinkFn
    }
  }
  
  /**
   * Check an element for terminal directives in fixed order.
   * If it finds one, return a terminal link function.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Function} terminalLinkFn
   */
  
  function checkTerminalDirectives (el, options) {
    // skip v-pre
    if (_.attr(el, 'v-pre') !== null) {
      return skip
    }
    // skip v-else block, but only if following v-if
    if (el.hasAttribute('v-else')) {
      var prev = el.previousElementSibling
      if (prev && prev.hasAttribute('v-if')) {
        return skip
      }
    }
    var value, dirName
    for (var i = 0, l = terminalDirectives.length; i < l; i++) {
      dirName = terminalDirectives[i]
      /* eslint-disable no-cond-assign */
      if (value = el.getAttribute('v-' + dirName)) {
        return makeTerminalNodeLinkFn(el, dirName, value, options)
      }
      /* eslint-enable no-cond-assign */
    }
  }
  
  function skip () {}
  skip.terminal = true
  
  /**
   * Build a node link function for a terminal directive.
   * A terminal link function terminates the current
   * compilation recursion and handles compilation of the
   * subtree in the directive.
   *
   * @param {Element} el
   * @param {String} dirName
   * @param {String} value
   * @param {Object} options
   * @param {Object} [def]
   * @return {Function} terminalLinkFn
   */
  
  function makeTerminalNodeLinkFn (el, dirName, value, options, def) {
    var parsed = dirParser.parse(value)
    var descriptor = {
      name: dirName,
      expression: parsed.expression,
      filters: parsed.filters,
      raw: value,
      // either an element directive, or if/for
      def: def || publicDirectives[dirName]
    }
    // check ref for v-for and router-view
    if (dirName === 'for' || dirName === 'router-view') {
      descriptor.ref = _.findRef(el)
    }
    var fn = function terminalNodeLinkFn (vm, el, host, scope, frag) {
      if (descriptor.ref) {
        _.defineReactive((scope || vm).$refs, descriptor.ref, null)
      }
      vm._bindDir(descriptor, el, host, scope, frag)
    }
    fn.terminal = true
    return fn
  }
  
  /**
   * Compile the directives on an element and return a linker.
   *
   * @param {Array|NamedNodeMap} attrs
   * @param {Object} options
   * @return {Function}
   */
  
  function compileDirectives (attrs, options) {
    var i = attrs.length
    var dirs = []
    var attr, name, value, rawName, rawValue, dirName, arg, modifiers, dirDef, tokens
    while (i--) {
      attr = attrs[i]
      name = rawName = attr.name
      value = rawValue = attr.value
      tokens = textParser.parse(value)
      // reset arg
      arg = null
      // check modifiers
      modifiers = parseModifiers(name)
      name = name.replace(modifierRE, '')
  
      // attribute interpolations
      if (tokens) {
        value = textParser.tokensToExp(tokens)
        arg = name
        pushDir('bind', publicDirectives.bind, true)
        // warn against mixing mustaches with v-bind
        if (process.env.NODE_ENV !== 'production') {
          if (name === 'class' && Array.prototype.some.call(attrs, function (attr) {
            return attr.name === ':class' || attr.name === 'v-bind:class'
          })) {
            _.warn(
              'class="' + rawValue + '": Do not mix mustache interpolation ' +
              'and v-bind for "class" on the same element. Use one or the other.'
            )
          }
        }
      } else
  
      // special attribute: transition
      if (transitionRE.test(name)) {
        modifiers.literal = !bindRE.test(name)
        pushDir('transition', internalDirectives.transition)
      } else
  
      // event handlers
      if (onRE.test(name)) {
        arg = name.replace(onRE, '')
        pushDir('on', publicDirectives.on)
      } else
  
      // attribute bindings
      if (bindRE.test(name)) {
        dirName = name.replace(bindRE, '')
        if (dirName === 'style' || dirName === 'class') {
          pushDir(dirName, internalDirectives[dirName])
        } else {
          arg = dirName
          pushDir('bind', publicDirectives.bind)
        }
      } else
  
      // normal directives
      if (name.indexOf('v-') === 0) {
        // check arg
        arg = (arg = name.match(argRE)) && arg[1]
        if (arg) {
          name = name.replace(argRE, '')
        }
        // extract directive name
        dirName = name.slice(2)
  
        // skip v-else (when used with v-show)
        if (dirName === 'else') {
          continue
        }
  
        dirDef = resolveAsset(options, 'directives', dirName)
  
        if (process.env.NODE_ENV !== 'production') {
          _.assertAsset(dirDef, 'directive', dirName)
        }
  
        if (dirDef) {
          pushDir(dirName, dirDef)
        }
      }
    }
  
    /**
     * Push a directive.
     *
     * @param {String} dirName
     * @param {Object|Function} def
     * @param {Boolean} [interp]
     */
  
    function pushDir (dirName, def, interp) {
      var parsed = dirParser.parse(value)
      dirs.push({
        name: dirName,
        attr: rawName,
        raw: rawValue,
        def: def,
        arg: arg,
        modifiers: modifiers,
        expression: parsed.expression,
        filters: parsed.filters,
        interp: interp
      })
    }
  
    if (dirs.length) {
      return makeNodeLinkFn(dirs)
    }
  }
  
  /**
   * Parse modifiers from directive attribute name.
   *
   * @param {String} name
   * @return {Object}
   */
  
  function parseModifiers (name) {
    var res = Object.create(null)
    var match = name.match(modifierRE)
    if (match) {
      var i = match.length
      while (i--) {
        res[match[i].slice(1)] = true
      }
    }
    return res
  }
  
  /**
   * Build a link function for all directives on a single node.
   *
   * @param {Array} directives
   * @return {Function} directivesLinkFn
   */
  
  function makeNodeLinkFn (directives) {
    return function nodeLinkFn (vm, el, host, scope, frag) {
      // reverse apply because it's sorted low to high
      var i = directives.length
      while (i--) {
        vm._bindDir(directives[i], el, host, scope, frag)
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../directives/internal":38,"../directives/public":48,"../parsers/directive":70,"../parsers/template":73,"../parsers/text":74,"../util":82,"./compile-props":27,"_process":5}],29:[function(require,module,exports){
  var _ = require('../util')
  
  _.extend(exports, require('./compile'))
  _.extend(exports, require('./transclude'))
  
  },{"../util":82,"./compile":28,"./transclude":30}],30:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var templateParser = require('../parsers/template')
  var specialCharRE = /[^\w\-:\.]/
  
  /**
   * Process an element or a DocumentFragment based on a
   * instance option object. This allows us to transclude
   * a template node/fragment before the instance is created,
   * so the processed fragment can then be cloned and reused
   * in v-for.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Element|DocumentFragment}
   */
  
  exports.transclude = function (el, options) {
    // extract container attributes to pass them down
    // to compiler, because they need to be compiled in
    // parent scope. we are mutating the options object here
    // assuming the same object will be used for compile
    // right after this.
    if (options) {
      options._containerAttrs = extractAttrs(el)
    }
    // for template tags, what we want is its content as
    // a documentFragment (for fragment instances)
    if (_.isTemplate(el)) {
      el = templateParser.parse(el)
    }
    if (options) {
      if (options._asComponent && !options.template) {
        options.template = '<slot></slot>'
      }
      if (options.template) {
        options._content = _.extractContent(el)
        el = transcludeTemplate(el, options)
      }
    }
    if (el instanceof DocumentFragment) {
      // anchors for fragment instance
      // passing in `persist: true` to avoid them being
      // discarded by IE during template cloning
      _.prepend(_.createAnchor('v-start', true), el)
      el.appendChild(_.createAnchor('v-end', true))
    }
    return el
  }
  
  /**
   * Process the template option.
   * If the replace option is true this will swap the $el.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Element|DocumentFragment}
   */
  
  function transcludeTemplate (el, options) {
    var template = options.template
    var frag = templateParser.parse(template, true)
    if (frag) {
      var replacer = frag.firstChild
      var tag = replacer.tagName && replacer.tagName.toLowerCase()
      if (options.replace) {
        /* istanbul ignore if */
        if (el === document.body) {
          process.env.NODE_ENV !== 'production' && _.warn(
            'You are mounting an instance with a template to ' +
            '<body>. This will replace <body> entirely. You ' +
            'should probably use `replace: false` here.'
          )
        }
        // there are many cases where the instance must
        // become a fragment instance: basically anything that
        // can create more than 1 root nodes.
        if (
          // multi-children template
          frag.childNodes.length > 1 ||
          // non-element template
          replacer.nodeType !== 1 ||
          // single nested component
          tag === 'component' ||
          _.resolveAsset(options, 'components', tag) ||
          replacer.hasAttribute('is') ||
          replacer.hasAttribute(':is') ||
          replacer.hasAttribute('v-bind:is') ||
          // element directive
          _.resolveAsset(options, 'elementDirectives', tag) ||
          // for block
          replacer.hasAttribute('v-for') ||
          // if block
          replacer.hasAttribute('v-if')
        ) {
          return frag
        } else {
          options._replacerAttrs = extractAttrs(replacer)
          mergeAttrs(el, replacer)
          return replacer
        }
      } else {
        el.appendChild(frag)
        return el
      }
    } else {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Invalid template option: ' + template
      )
    }
  }
  
  /**
   * Helper to extract a component container's attributes
   * into a plain object array.
   *
   * @param {Element} el
   * @return {Array}
   */
  
  function extractAttrs (el) {
    if (el.nodeType === 1 && el.hasAttributes()) {
      return _.toArray(el.attributes)
    }
  }
  
  /**
   * Merge the attributes of two elements, and make sure
   * the class names are merged properly.
   *
   * @param {Element} from
   * @param {Element} to
   */
  
  function mergeAttrs (from, to) {
    var attrs = from.attributes
    var i = attrs.length
    var name, value
    while (i--) {
      name = attrs[i].name
      value = attrs[i].value
      if (!to.hasAttribute(name) && !specialCharRE.test(name)) {
        to.setAttribute(name, value)
      } else if (name === 'class') {
        value = to.getAttribute(name) + ' ' + value
        to.setAttribute(name, value)
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../parsers/template":73,"../util":82,"_process":5}],31:[function(require,module,exports){
  module.exports = {
  
    /**
     * Whether to print debug messages.
     * Also enables stack trace for warnings.
     *
     * @type {Boolean}
     */
  
    debug: false,
  
    /**
     * Whether to suppress warnings.
     *
     * @type {Boolean}
     */
  
    silent: false,
  
    /**
     * Whether to use async rendering.
     */
  
    async: true,
  
    /**
     * Whether to warn against errors caught when evaluating
     * expressions.
     */
  
    warnExpressionErrors: true,
  
    /**
     * Whether or not to handle fully object properties which
     * are already backed by getters and seters. Depending on
     * use case and environment, this might introduce non-neglible
     * performance penalties.
     */
    convertAllProperties: false,
  
    /**
     * Internal flag to indicate the delimiters have been
     * changed.
     *
     * @type {Boolean}
     */
  
    _delimitersChanged: true,
  
    /**
     * List of asset types that a component can own.
     *
     * @type {Array}
     */
  
    _assetTypes: [
      'component',
      'directive',
      'elementDirective',
      'filter',
      'transition',
      'partial'
    ],
  
    /**
     * prop binding modes
     */
  
    _propBindingModes: {
      ONE_WAY: 0,
      TWO_WAY: 1,
      ONE_TIME: 2
    },
  
    /**
     * Max circular updates allowed in a batcher flush cycle.
     */
  
    _maxUpdateCount: 100
  
  }
  
  /**
   * Interpolation delimiters. Changing these would trigger
   * the text parser to re-compile the regular expressions.
   *
   * @type {Array<String>}
   */
  
  var delimiters = ['{{', '}}']
  var unsafeDelimiters = ['{{{', '}}}']
  var textParser = require('./parsers/text')
  
  Object.defineProperty(module.exports, 'delimiters', {
    get: function () {
      return delimiters
    },
    set: function (val) {
      delimiters = val
      textParser.compileRegex()
    }
  })
  
  Object.defineProperty(module.exports, 'unsafeDelimiters', {
    get: function () {
      return unsafeDelimiters
    },
    set: function (val) {
      unsafeDelimiters = val
      textParser.compileRegex()
    }
  })
  
  },{"./parsers/text":74}],32:[function(require,module,exports){
  (function (process){
  var _ = require('./util')
  var Watcher = require('./watcher')
  var expParser = require('./parsers/expression')
  function noop () {}
  
  /**
   * A directive links a DOM element with a piece of data,
   * which is the result of evaluating an expression.
   * It registers a watcher with the expression and calls
   * the DOM update function when a change is triggered.
   *
   * @param {String} name
   * @param {Node} el
   * @param {Vue} vm
   * @param {Object} descriptor
   *                 - {String} name
   *                 - {Object} def
   *                 - {String} expression
   *                 - {Array<Object>} [filters]
   *                 - {Boolean} literal
   *                 - {String} attr
   *                 - {String} raw
   * @param {Object} def - directive definition object
   * @param {Vue} [host] - transclusion host component
   * @param {Object} [scope] - v-for scope
   * @param {Fragment} [frag] - owner fragment
   * @constructor
   */
  
  function Directive (descriptor, vm, el, host, scope, frag) {
    this.vm = vm
    this.el = el
    // copy descriptor properties
    this.descriptor = descriptor
    this.name = descriptor.name
    this.expression = descriptor.expression
    this.arg = descriptor.arg
    this.modifiers = descriptor.modifiers
    this.filters = descriptor.filters
    this.literal = this.modifiers && this.modifiers.literal
    // private
    this._locked = false
    this._bound = false
    this._listeners = null
    // link context
    this._host = host
    this._scope = scope
    this._frag = frag
    // store directives on node in dev mode
    if (process.env.NODE_ENV !== 'production' && this.el) {
      this.el._vue_directives = this.el._vue_directives || []
      this.el._vue_directives.push(this)
    }
  }
  
  /**
   * Initialize the directive, mixin definition properties,
   * setup the watcher, call definition bind() and update()
   * if present.
   *
   * @param {Object} def
   */
  
  Directive.prototype._bind = function () {
    var name = this.name
    var descriptor = this.descriptor
  
    // remove attribute
    if (
      (name !== 'cloak' || this.vm._isCompiled) &&
      this.el && this.el.removeAttribute
    ) {
      var attr = descriptor.attr || ('v-' + name)
      this.el.removeAttribute(attr)
    }
  
    // copy def properties
    var def = descriptor.def
    if (typeof def === 'function') {
      this.update = def
    } else {
      _.extend(this, def)
    }
  
    // setup directive params
    this._setupParams()
  
    // initial bind
    if (this.bind) {
      this.bind()
    }
  
    if (this.literal) {
      this.update && this.update(descriptor.raw)
    } else if (
      (this.expression || this.modifiers) &&
      (this.update || this.twoWay) &&
      !this._checkStatement()
    ) {
      // wrapped updater for context
      var dir = this
      if (this.update) {
        this._update = function (val, oldVal) {
          if (!dir._locked) {
            dir.update(val, oldVal)
          }
        }
      } else {
        this._update = noop
      }
      var preProcess = this._preProcess
        ? _.bind(this._preProcess, this)
        : null
      var postProcess = this._postProcess
        ? _.bind(this._postProcess, this)
        : null
      var watcher = this._watcher = new Watcher(
        this.vm,
        this.expression,
        this._update, // callback
        {
          filters: this.filters,
          twoWay: this.twoWay,
          deep: this.deep,
          preProcess: preProcess,
          postProcess: postProcess,
          scope: this._scope
        }
      )
      // v-model with inital inline value need to sync back to
      // model instead of update to DOM on init. They would
      // set the afterBind hook to indicate that.
      if (this.afterBind) {
        this.afterBind()
      } else if (this.update) {
        this.update(watcher.value)
      }
    }
    this._bound = true
  }
  
  /**
   * Setup all param attributes, e.g. track-by,
   * transition-mode, etc...
   */
  
  Directive.prototype._setupParams = function () {
    if (!this.params) {
      return
    }
    var params = this.params
    // swap the params array with a fresh object.
    this.params = Object.create(null)
    var i = params.length
    var key, val, mappedKey
    while (i--) {
      key = params[i]
      mappedKey = _.camelize(key)
      val = _.getBindAttr(this.el, key)
      if (val != null) {
        // dynamic
        this._setupParamWatcher(mappedKey, val)
      } else {
        // static
        val = _.attr(this.el, key)
        if (val != null) {
          this.params[mappedKey] = val === '' ? true : val
        }
      }
    }
  }
  
  /**
   * Setup a watcher for a dynamic param.
   *
   * @param {String} key
   * @param {String} expression
   */
  
  Directive.prototype._setupParamWatcher = function (key, expression) {
    var self = this
    var called = false
    var unwatch = (this._scope || this.vm).$watch(expression, function (val, oldVal) {
      self.params[key] = val
      // since we are in immediate mode,
      // only call the param change callbacks if this is not the first update.
      if (called) {
        var cb = self.paramWatchers && self.paramWatchers[key]
        if (cb) {
          cb.call(self, val, oldVal)
        }
      } else {
        called = true
      }
    }, {
      immediate: true
    })
    ;(this._paramUnwatchFns || (this._paramUnwatchFns = [])).push(unwatch)
  }
  
  /**
   * Check if the directive is a function caller
   * and if the expression is a callable one. If both true,
   * we wrap up the expression and use it as the event
   * handler.
   *
   * e.g. on-click="a++"
   *
   * @return {Boolean}
   */
  
  Directive.prototype._checkStatement = function () {
    var expression = this.expression
    if (
      expression && this.acceptStatement &&
      !expParser.isSimplePath(expression)
    ) {
      var fn = expParser.parse(expression).get
      var scope = this._scope || this.vm
      var handler = function (e) {
        scope.$event = e
        fn.call(scope, scope)
        scope.$event = null
      }
      if (this.filters) {
        handler = scope._applyFilters(handler, null, this.filters)
      }
      this.update(handler)
      return true
    }
  }
  
  /**
   * Set the corresponding value with the setter.
   * This should only be used in two-way directives
   * e.g. v-model.
   *
   * @param {*} value
   * @public
   */
  
  Directive.prototype.set = function (value) {
    /* istanbul ignore else */
    if (this.twoWay) {
      this._withLock(function () {
        this._watcher.set(value)
      })
    } else if (process.env.NODE_ENV !== 'production') {
      _.warn(
        'Directive.set() can only be used inside twoWay' +
        'directives.'
      )
    }
  }
  
  /**
   * Execute a function while preventing that function from
   * triggering updates on this directive instance.
   *
   * @param {Function} fn
   */
  
  Directive.prototype._withLock = function (fn) {
    var self = this
    self._locked = true
    fn.call(self)
    _.nextTick(function () {
      self._locked = false
    })
  }
  
  /**
   * Convenience method that attaches a DOM event listener
   * to the directive element and autometically tears it down
   * during unbind.
   *
   * @param {String} event
   * @param {Function} handler
   */
  
  Directive.prototype.on = function (event, handler) {
    _.on(this.el, event, handler)
    ;(this._listeners || (this._listeners = []))
      .push([event, handler])
  }
  
  /**
   * Teardown the watcher and call unbind.
   */
  
  Directive.prototype._teardown = function () {
    if (this._bound) {
      this._bound = false
      if (this.unbind) {
        this.unbind()
      }
      if (this._watcher) {
        this._watcher.teardown()
      }
      var listeners = this._listeners
      var i
      if (listeners) {
        i = listeners.length
        while (i--) {
          _.off(this.el, listeners[i][0], listeners[i][1])
        }
      }
      var unwatchFns = this._paramUnwatchFns
      if (unwatchFns) {
        i = unwatchFns.length
        while (i--) {
          unwatchFns[i]()
        }
      }
      if (process.env.NODE_ENV !== 'production' && this.el) {
        this.el._vue_directives.$remove(this)
      }
      this.vm = this.el = this._watcher = this._listeners = null
    }
  }
  
  module.exports = Directive
  
  }).call(this,require('_process'))
  },{"./parsers/expression":71,"./util":82,"./watcher":86,"_process":5}],33:[function(require,module,exports){
  exports.slot = require('./slot')
  exports.partial = require('./partial')
  
  },{"./partial":34,"./slot":35}],34:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  var vIf = require('../public/if')
  var FragmentFactory = require('../../fragment/factory')
  
  module.exports = {
  
    priority: 1750,
  
    params: ['name'],
  
    // watch changes to name for dynamic partials
    paramWatchers: {
      name: function (value) {
        vIf.remove.call(this)
        if (value) {
          this.insert(value)
        }
      }
    },
  
    bind: function () {
      this.anchor = _.createAnchor('v-partial')
      _.replace(this.el, this.anchor)
      this.insert(this.params.name)
    },
  
    insert: function (id) {
      var partial = _.resolveAsset(this.vm.$options, 'partials', id)
      if (process.env.NODE_ENV !== 'production') {
        _.assertAsset(partial, 'partial', id)
      }
      if (partial) {
        this.factory = new FragmentFactory(this.vm, partial)
        vIf.insert.call(this)
      }
    },
  
    unbind: function () {
      if (this.frag) {
        this.frag.destroy()
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../../fragment/factory":60,"../../util":82,"../public/if":47,"_process":5}],35:[function(require,module,exports){
  var _ = require('../../util')
  var templateParser = require('../../parsers/template')
  
  // This is the elementDirective that handles <content>
  // transclusions. It relies on the raw content of an
  // instance being stored as `$options._content` during
  // the transclude phase.
  
  module.exports = {
  
    priority: 1750,
  
    params: ['name'],
  
    bind: function () {
      var host = this.vm
      var raw = host.$options._content
      var content
      if (!raw) {
        this.fallback()
        return
      }
      var context = host._context
      var slotName = this.params.name
      if (!slotName) {
        // Default content
        var self = this
        var compileDefaultContent = function () {
          self.compile(
            extractFragment(raw.childNodes, raw, true),
            context,
            host
          )
        }
        if (!host._isCompiled) {
          // defer until the end of instance compilation,
          // because the default outlet must wait until all
          // other possible outlets with selectors have picked
          // out their contents.
          host.$once('hook:compiled', compileDefaultContent)
        } else {
          compileDefaultContent()
        }
      } else {
        var selector = '[slot="' + slotName + '"]'
        var nodes = raw.querySelectorAll(selector)
        if (nodes.length) {
          content = extractFragment(nodes, raw)
          if (content.hasChildNodes()) {
            this.compile(content, context, host)
          } else {
            this.fallback()
          }
        } else {
          this.fallback()
        }
      }
    },
  
    fallback: function () {
      this.compile(_.extractContent(this.el, true), this.vm)
    },
  
    compile: function (content, context, host) {
      if (content && context) {
        var scope = host
          ? host._scope
          : this._scope
        this.unlink = context.$compile(
          content, host, scope, this._frag
        )
      }
      if (content) {
        _.replace(this.el, content)
      } else {
        _.remove(this.el)
      }
    },
  
    unbind: function () {
      if (this.unlink) {
        this.unlink()
      }
    }
  }
  
  /**
   * Extract qualified content nodes from a node list.
   *
   * @param {NodeList} nodes
   * @param {Element} parent
   * @param {Boolean} main
   * @return {DocumentFragment}
   */
  
  function extractFragment (nodes, parent, main) {
    var frag = document.createDocumentFragment()
    for (var i = 0, l = nodes.length; i < l; i++) {
      var node = nodes[i]
      // if this is the main outlet, we want to skip all
      // previously selected nodes;
      // otherwise, we want to mark the node as selected.
      // clone the node so the original raw content remains
      // intact. this ensures proper re-compilation in cases
      // where the outlet is inside a conditional block
      if (main && !node.__v_selected) {
        append(node)
      } else if (!main && node.parentNode === parent) {
        node.__v_selected = true
        append(node)
      }
    }
    return frag
  
    function append (node) {
      if (_.isTemplate(node) &&
          !node.hasAttribute('v-if') &&
          !node.hasAttribute('v-for')) {
        node = templateParser.parse(node)
      }
      node = templateParser.clone(node)
      frag.appendChild(node)
    }
  }
  
  },{"../../parsers/template":73,"../../util":82}],36:[function(require,module,exports){
  var _ = require('../../util')
  var addClass = _.addClass
  var removeClass = _.removeClass
  
  module.exports = {
  
    deep: true,
  
    update: function (value) {
      if (value && typeof value === 'string') {
        this.handleObject(stringToObject(value))
      } else if (_.isPlainObject(value)) {
        this.handleObject(value)
      } else if (_.isArray(value)) {
        this.handleArray(value)
      } else {
        this.cleanup()
      }
    },
  
    handleObject: function (value) {
      this.cleanup(value)
      var keys = this.prevKeys = Object.keys(value)
      for (var i = 0, l = keys.length; i < l; i++) {
        var key = keys[i]
        if (value[key]) {
          addClass(this.el, key)
        } else {
          removeClass(this.el, key)
        }
      }
    },
  
    handleArray: function (value) {
      this.cleanup(value)
      for (var i = 0, l = value.length; i < l; i++) {
        if (value[i]) {
          addClass(this.el, value[i])
        }
      }
      this.prevKeys = value.slice()
    },
  
    cleanup: function (value) {
      if (this.prevKeys) {
        var i = this.prevKeys.length
        while (i--) {
          var key = this.prevKeys[i]
          if (key && (!value || !contains(value, key))) {
            removeClass(this.el, key)
          }
        }
      }
    }
  }
  
  function stringToObject (value) {
    var res = {}
    var keys = value.trim().split(/\s+/)
    var i = keys.length
    while (i--) {
      res[keys[i]] = true
    }
    return res
  }
  
  function contains (value, key) {
    return _.isArray(value)
      ? value.indexOf(key) > -1
      : value.hasOwnProperty(key)
  }
  
  },{"../../util":82}],37:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  var templateParser = require('../../parsers/template')
  
  module.exports = {
  
    priority: 1500,
  
    params: [
      'keep-alive',
      'transition-mode',
      'inline-template'
    ],
  
    /**
     * Setup. Two possible usages:
     *
     * - static:
     *   <comp> or <div v-component="comp">
     *
     * - dynamic:
     *   <component :is="view">
     */
  
    bind: function () {
      if (!this.el.__vue__) {
        // keep-alive cache
        this.keepAlive = this.params.keepAlive
        if (this.keepAlive) {
          this.cache = {}
        }
        // check inline-template
        if (this.params.inlineTemplate) {
          // extract inline template as a DocumentFragment
          this.inlineTemplate = _.extractContent(this.el, true)
        }
        // component resolution related state
        this.pendingComponentCb =
        this.Component = null
        // transition related state
        this.pendingRemovals = 0
        this.pendingRemovalCb = null
        // create a ref anchor
        this.anchor = _.createAnchor('v-component')
        _.replace(this.el, this.anchor)
        // remove is attribute.
        // this is removed during compilation, but because compilation is
        // cached, when the component is used elsewhere this attribute
        // will remain at link time.
        this.el.removeAttribute('is')
        // remove ref, same as above
        if (this.descriptor.ref) {
          this.el.removeAttribute('v-ref:' + _.hyphenate(this.descriptor.ref))
        }
        // if static, build right now.
        if (this.literal) {
          this.setComponent(this.expression)
        }
      } else {
        process.env.NODE_ENV !== 'production' && _.warn(
          'cannot mount component "' + this.expression + '" ' +
          'on already mounted element: ' + this.el
        )
      }
    },
  
    /**
     * Public update, called by the watcher in the dynamic
     * literal scenario, e.g. <component :is="view">
     */
  
    update: function (value) {
      if (!this.literal) {
        this.setComponent(value)
      }
    },
  
    /**
     * Switch dynamic components. May resolve the component
     * asynchronously, and perform transition based on
     * specified transition mode. Accepts a few additional
     * arguments specifically for vue-router.
     *
     * The callback is called when the full transition is
     * finished.
     *
     * @param {String} value
     * @param {Function} [cb]
     */
  
    setComponent: function (value, cb) {
      this.invalidatePending()
      if (!value) {
        // just remove current
        this.unbuild(true)
        this.remove(this.childVM, cb)
        this.childVM = null
      } else {
        var self = this
        this.resolveComponent(value, function () {
          self.mountComponent(cb)
        })
      }
    },
  
    /**
     * Resolve the component constructor to use when creating
     * the child vm.
     */
  
    resolveComponent: function (id, cb) {
      var self = this
      this.pendingComponentCb = _.cancellable(function (Component) {
        self.ComponentName = Component.options.name || id
        self.Component = Component
        cb()
      })
      this.vm._resolveComponent(id, this.pendingComponentCb)
    },
  
    /**
     * Create a new instance using the current constructor and
     * replace the existing instance. This method doesn't care
     * whether the new component and the old one are actually
     * the same.
     *
     * @param {Function} [cb]
     */
  
    mountComponent: function (cb) {
      // actual mount
      this.unbuild(true)
      var self = this
      var activateHook = this.Component.options.activate
      var cached = this.getCached()
      var newComponent = this.build()
      if (activateHook && !cached) {
        this.waitingFor = newComponent
        activateHook.call(newComponent, function () {
          self.waitingFor = null
          self.transition(newComponent, cb)
        })
      } else {
        // update ref for kept-alive component
        if (cached) {
          newComponent._updateRef()
        }
        this.transition(newComponent, cb)
      }
    },
  
    /**
     * When the component changes or unbinds before an async
     * constructor is resolved, we need to invalidate its
     * pending callback.
     */
  
    invalidatePending: function () {
      if (this.pendingComponentCb) {
        this.pendingComponentCb.cancel()
        this.pendingComponentCb = null
      }
    },
  
    /**
     * Instantiate/insert a new child vm.
     * If keep alive and has cached instance, insert that
     * instance; otherwise build a new one and cache it.
     *
     * @param {Object} [extraOptions]
     * @return {Vue} - the created instance
     */
  
    build: function (extraOptions) {
      var cached = this.getCached()
      if (cached) {
        return cached
      }
      if (this.Component) {
        // default options
        var options = {
          name: this.ComponentName,
          el: templateParser.clone(this.el),
          template: this.inlineTemplate,
          // make sure to add the child with correct parent
          // if this is a transcluded component, its parent
          // should be the transclusion host.
          parent: this._host || this.vm,
          // if no inline-template, then the compiled
          // linker can be cached for better performance.
          _linkerCachable: !this.inlineTemplate,
          _ref: this.descriptor.ref,
          _asComponent: true,
          _isRouterView: this._isRouterView,
          // if this is a transcluded component, context
          // will be the common parent vm of this instance
          // and its host.
          _context: this.vm,
          // if this is inside an inline v-for, the scope
          // will be the intermediate scope created for this
          // repeat fragment. this is used for linking props
          // and container directives.
          _scope: this._scope,
          // pass in the owner fragment of this component.
          // this is necessary so that the fragment can keep
          // track of its contained components in order to
          // call attach/detach hooks for them.
          _frag: this._frag
        }
        // extra options
        // in 1.0.0 this is used by vue-router only
        /* istanbul ignore if */
        if (extraOptions) {
          _.extend(options, extraOptions)
        }
        var child = new this.Component(options)
        if (this.keepAlive) {
          this.cache[this.Component.cid] = child
        }
        /* istanbul ignore if */
        if (process.env.NODE_ENV !== 'production' &&
            this.el.hasAttribute('transition') &&
            child._isFragment) {
          _.warn(
            'Transitions will not work on a fragment instance. ' +
            'Template: ' + child.$options.template
          )
        }
        return child
      }
    },
  
    /**
     * Try to get a cached instance of the current component.
     *
     * @return {Vue|undefined}
     */
  
    getCached: function () {
      return this.keepAlive && this.cache[this.Component.cid]
    },
  
    /**
     * Teardown the current child, but defers cleanup so
     * that we can separate the destroy and removal steps.
     *
     * @param {Boolean} defer
     */
  
    unbuild: function (defer) {
      if (this.waitingFor) {
        this.waitingFor.$destroy()
        this.waitingFor = null
      }
      var child = this.childVM
      if (!child || this.keepAlive) {
        if (child) {
          // remove ref
          child._updateRef(true)
        }
        return
      }
      // the sole purpose of `deferCleanup` is so that we can
      // "deactivate" the vm right now and perform DOM removal
      // later.
      child.$destroy(false, defer)
    },
  
    /**
     * Remove current destroyed child and manually do
     * the cleanup after removal.
     *
     * @param {Function} cb
     */
  
    remove: function (child, cb) {
      var keepAlive = this.keepAlive
      if (child) {
        // we may have a component switch when a previous
        // component is still being transitioned out.
        // we want to trigger only one lastest insertion cb
        // when the existing transition finishes. (#1119)
        this.pendingRemovals++
        this.pendingRemovalCb = cb
        var self = this
        child.$remove(function () {
          self.pendingRemovals--
          if (!keepAlive) child._cleanup()
          if (!self.pendingRemovals && self.pendingRemovalCb) {
            self.pendingRemovalCb()
            self.pendingRemovalCb = null
          }
        })
      } else if (cb) {
        cb()
      }
    },
  
    /**
     * Actually swap the components, depending on the
     * transition mode. Defaults to simultaneous.
     *
     * @param {Vue} target
     * @param {Function} [cb]
     */
  
    transition: function (target, cb) {
      var self = this
      var current = this.childVM
      // for devtool inspection
      if (process.env.NODE_ENV !== 'production') {
        if (current) current._inactive = true
        target._inactive = false
      }
      this.childVM = target
      switch (self.params.transitionMode) {
        case 'in-out':
          target.$before(self.anchor, function () {
            self.remove(current, cb)
          })
          break
        case 'out-in':
          self.remove(current, function () {
            target.$before(self.anchor, cb)
          })
          break
        default:
          self.remove(current)
          target.$before(self.anchor, cb)
      }
    },
  
    /**
     * Unbind.
     */
  
    unbind: function () {
      this.invalidatePending()
      // Do not defer cleanup when unbinding
      this.unbuild()
      // destroy all keep-alive cached instances
      if (this.cache) {
        for (var key in this.cache) {
          this.cache[key].$destroy()
        }
        this.cache = null
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../../parsers/template":73,"../../util":82,"_process":5}],38:[function(require,module,exports){
  exports.style = require('./style')
  exports['class'] = require('./class')
  exports.component = require('./component')
  exports.prop = require('./prop')
  exports.transition = require('./transition')
  
  },{"./class":36,"./component":37,"./prop":39,"./style":40,"./transition":41}],39:[function(require,module,exports){
  // NOTE: the prop internal directive is compiled and linked
  // during _initScope(), before the created hook is called.
  // The purpose is to make the initial prop values available
  // inside `created` hooks and `data` functions.
  
  var _ = require('../../util')
  var Watcher = require('../../watcher')
  var bindingModes = require('../../config')._propBindingModes
  
  module.exports = {
  
    bind: function () {
  
      var child = this.vm
      var parent = child._context
      // passed in from compiler directly
      var prop = this.descriptor.prop
      var childKey = prop.path
      var parentKey = prop.parentPath
      var twoWay = prop.mode === bindingModes.TWO_WAY
  
      var parentWatcher = this.parentWatcher = new Watcher(
        parent,
        parentKey,
        function (val) {
          if (_.assertProp(prop, val)) {
            child[childKey] = val
          }
        }, {
          twoWay: twoWay,
          filters: prop.filters,
          // important: props need to be observed on the
          // v-for scope if present
          scope: this._scope
        }
      )
  
      // set the child initial value.
      _.initProp(child, prop, parentWatcher.value)
  
      // setup two-way binding
      if (twoWay) {
        // important: defer the child watcher creation until
        // the created hook (after data observation)
        var self = this
        child.$once('hook:created', function () {
          self.childWatcher = new Watcher(
            child,
            childKey,
            function (val) {
              parentWatcher.set(val)
            }, {
              // ensure sync upward before parent sync down.
              // this is necessary in cases e.g. the child
              // mutates a prop array, then replaces it. (#1683)
              sync: true
            }
          )
        })
      }
    },
  
    unbind: function () {
      this.parentWatcher.teardown()
      if (this.childWatcher) {
        this.childWatcher.teardown()
      }
    }
  }
  
  },{"../../config":31,"../../util":82,"../../watcher":86}],40:[function(require,module,exports){
  var _ = require('../../util')
  var prefixes = ['-webkit-', '-moz-', '-ms-']
  var camelPrefixes = ['Webkit', 'Moz', 'ms']
  var importantRE = /!important;?$/
  var testEl = null
  var propCache = {}
  
  module.exports = {
  
    deep: true,
  
    update: function (value) {
      if (typeof value === 'string') {
        this.el.style.cssText = value
      } else if (_.isArray(value)) {
        this.handleObject(value.reduce(_.extend, {}))
      } else {
        this.handleObject(value || {})
      }
    },
  
    handleObject: function (value) {
      // cache object styles so that only changed props
      // are actually updated.
      var cache = this.cache || (this.cache = {})
      var name, val
      for (name in cache) {
        if (!(name in value)) {
          this.handleSingle(name, null)
          delete cache[name]
        }
      }
      for (name in value) {
        val = value[name]
        if (val !== cache[name]) {
          cache[name] = val
          this.handleSingle(name, val)
        }
      }
    },
  
    handleSingle: function (prop, value) {
      prop = normalize(prop)
      if (!prop) return // unsupported prop
      // cast possible numbers/booleans into strings
      if (value != null) value += ''
      if (value) {
        var isImportant = importantRE.test(value)
          ? 'important'
          : ''
        if (isImportant) {
          value = value.replace(importantRE, '').trim()
        }
        this.el.style.setProperty(prop, value, isImportant)
      } else {
        this.el.style.removeProperty(prop)
      }
    }
  
  }
  
  /**
   * Normalize a CSS property name.
   * - cache result
   * - auto prefix
   * - camelCase -> dash-case
   *
   * @param {String} prop
   * @return {String}
   */
  
  function normalize (prop) {
    if (propCache[prop]) {
      return propCache[prop]
    }
    var res = prefix(prop)
    propCache[prop] = propCache[res] = res
    return res
  }
  
  /**
   * Auto detect the appropriate prefix for a CSS property.
   * https://gist.github.com/paulirish/523692
   *
   * @param {String} prop
   * @return {String}
   */
  
  function prefix (prop) {
    prop = _.hyphenate(prop)
    var camel = _.camelize(prop)
    var upper = camel.charAt(0).toUpperCase() + camel.slice(1)
    if (!testEl) {
      testEl = document.createElement('div')
    }
    if (camel in testEl.style) {
      return prop
    }
    var i = prefixes.length
    var prefixed
    while (i--) {
      prefixed = camelPrefixes[i] + upper
      if (prefixed in testEl.style) {
        return prefixes[i] + prop
      }
    }
  }
  
  },{"../../util":82}],41:[function(require,module,exports){
  var _ = require('../../util')
  var Transition = require('../../transition/transition')
  
  module.exports = {
  
    priority: 1100,
  
    update: function (id, oldId) {
      var el = this.el
      // resolve on owner vm
      var hooks = _.resolveAsset(this.vm.$options, 'transitions', id)
      id = id || 'v'
      // apply on closest vm
      el.__v_trans = new Transition(el, id, hooks, this.el.__vue__ || this.vm)
      if (oldId) {
        _.removeClass(el, oldId + '-transition')
      }
      _.addClass(el, id + '-transition')
    }
  }
  
  },{"../../transition/transition":77,"../../util":82}],42:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  
  // xlink
  var xlinkNS = 'http://www.w3.org/1999/xlink'
  var xlinkRE = /^xlink:/
  
  // these input element attributes should also set their
  // corresponding properties
  var inputProps = {
    value: 1,
    checked: 1,
    selected: 1
  }
  
  // these attributes should set a hidden property for
  // binding v-model to object values
  var modelProps = {
    value: '_value',
    'true-value': '_trueValue',
    'false-value': '_falseValue'
  }
  
  // check for attributes that prohibit interpolations
  var disallowedInterpAttrRE = /^v-|^:|^@|^(is|transition|transition-mode|debounce|track-by|stagger|enter-stagger|leave-stagger)$/
  
  module.exports = {
  
    priority: 850,
  
    bind: function () {
      var attr = this.arg
      var tag = this.el.tagName
      // should be deep watch on object mode
      if (!attr) {
        this.deep = true
      }
      // handle interpolation bindings
      if (this.descriptor.interp) {
        // only allow binding on native attributes
        if (
          disallowedInterpAttrRE.test(attr) ||
          (attr === 'name' && (tag === 'PARTIAL' || tag === 'SLOT'))
        ) {
          process.env.NODE_ENV !== 'production' && _.warn(
            attr + '="' + this.descriptor.raw + '": ' +
            'attribute interpolation is not allowed in Vue.js ' +
            'directives and special attributes.'
          )
          this.el.removeAttribute(attr)
          this.invalid = true
        }
  
        /* istanbul ignore if */
        if (process.env.NODE_ENV !== 'production') {
          var raw = attr + '="' + this.descriptor.raw + '": '
          // warn src
          if (attr === 'src') {
            _.warn(
              raw + 'interpolation in "src" attribute will cause ' +
              'a 404 request. Use v-bind:src instead.'
            )
          }
  
          // warn style
          if (attr === 'style') {
            _.warn(
              raw + 'interpolation in "style" attribute will cause ' +
              'the attribute to be discarded in Internet Explorer. ' +
              'Use v-bind:style instead.'
            )
          }
        }
      }
    },
  
    update: function (value) {
      if (this.invalid) {
        return
      }
      var attr = this.arg
      if (this.arg) {
        this.handleSingle(attr, value)
      } else {
        this.handleObject(value || {})
      }
    },
  
    // share object handler with v-bind:class
    handleObject: require('../internal/style').handleObject,
  
    handleSingle: function (attr, value) {
      if (inputProps[attr] && attr in this.el) {
        this.el[attr] = attr === 'value'
          ? (value || '') // IE9 will set input.value to "null" for null...
          : value
      }
      // set model props
      var modelProp = modelProps[attr]
      if (modelProp) {
        this.el[modelProp] = value
        // update v-model if present
        var model = this.el.__v_model
        if (model) {
          model.listener()
        }
      }
      // do not set value attribute for textarea
      if (attr === 'value' && this.el.tagName === 'TEXTAREA') {
        this.el.removeAttribute(attr)
        return
      }
      // update attribute
      if (value != null && value !== false) {
        if (xlinkRE.test(attr)) {
          this.el.setAttributeNS(xlinkNS, attr, value)
        } else {
          this.el.setAttribute(attr, value)
        }
      } else {
        this.el.removeAttribute(attr)
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../../util":82,"../internal/style":40,"_process":5}],43:[function(require,module,exports){
  module.exports = {
    bind: function () {
      var el = this.el
      this.vm.$once('hook:compiled', function () {
        el.removeAttribute('v-cloak')
      })
    }
  }
  
  },{}],44:[function(require,module,exports){
  var _ = require('../../util')
  
  module.exports = {
  
    priority: 1500,
  
    bind: function () {
      /* istanbul ignore if */
      if (!this.arg) {
        return
      }
      var id = this.id = _.camelize(this.arg)
      var refs = (this._scope || this.vm).$els
      if (refs.hasOwnProperty(id)) {
        refs[id] = this.el
      } else {
        _.defineReactive(refs, id, this.el)
      }
    },
  
    unbind: function () {
      var refs = (this._scope || this.vm).$els
      if (refs[this.id] === this.el) {
        refs[this.id] = null
      }
    }
  }
  
  },{"../../util":82}],45:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  var FragmentFactory = require('../../fragment/factory')
  var isObject = _.isObject
  var uid = 0
  
  module.exports = {
  
    priority: 2000,
  
    params: [
      'track-by',
      'stagger',
      'enter-stagger',
      'leave-stagger'
    ],
  
    bind: function () {
      // support "item in items" syntax
      var inMatch = this.expression.match(/(.*) in (.*)/)
      if (inMatch) {
        var itMatch = inMatch[1].match(/\((.*),(.*)\)/)
        if (itMatch) {
          this.iterator = itMatch[1].trim()
          this.alias = itMatch[2].trim()
        } else {
          this.alias = inMatch[1].trim()
        }
        this.expression = inMatch[2]
      }
  
      if (!this.alias) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'Alias is required in v-for.'
        )
        return
      }
  
      // uid as a cache identifier
      this.id = '__v-for__' + (++uid)
  
      // check if this is an option list,
      // so that we know if we need to update the <select>'s
      // v-model when the option list has changed.
      // because v-model has a lower priority than v-for,
      // the v-model is not bound here yet, so we have to
      // retrive it in the actual updateModel() function.
      var tag = this.el.tagName
      this.isOption =
        (tag === 'OPTION' || tag === 'OPTGROUP') &&
        this.el.parentNode.tagName === 'SELECT'
  
      // setup anchor nodes
      this.start = _.createAnchor('v-for-start')
      this.end = _.createAnchor('v-for-end')
      _.replace(this.el, this.end)
      _.before(this.start, this.end)
  
      // cache
      this.cache = Object.create(null)
  
      // fragment factory
      this.factory = new FragmentFactory(this.vm, this.el)
    },
  
    update: function (data) {
      this.diff(data)
      this.updateRef()
      this.updateModel()
    },
  
    /**
     * Diff, based on new data and old data, determine the
     * minimum amount of DOM manipulations needed to make the
     * DOM reflect the new data Array.
     *
     * The algorithm diffs the new data Array by storing a
     * hidden reference to an owner vm instance on previously
     * seen data. This allows us to achieve O(n) which is
     * better than a levenshtein distance based algorithm,
     * which is O(m * n).
     *
     * @param {Array} data
     */
  
    diff: function (data) {
      // check if the Array was converted from an Object
      var item = data[0]
      var convertedFromObject = this.fromObject =
        isObject(item) &&
        item.hasOwnProperty('$key') &&
        item.hasOwnProperty('$value')
  
      var trackByKey = this.params.trackBy
      var oldFrags = this.frags
      var frags = this.frags = new Array(data.length)
      var alias = this.alias
      var iterator = this.iterator
      var start = this.start
      var end = this.end
      var inDoc = _.inDoc(start)
      var init = !oldFrags
      var i, l, frag, key, value, primitive
  
      // First pass, go through the new Array and fill up
      // the new frags array. If a piece of data has a cached
      // instance for it, we reuse it. Otherwise build a new
      // instance.
      for (i = 0, l = data.length; i < l; i++) {
        item = data[i]
        key = convertedFromObject ? item.$key : null
        value = convertedFromObject ? item.$value : item
        primitive = !isObject(value)
        frag = !init && this.getCachedFrag(value, i, key)
        if (frag) { // reusable fragment
          frag.reused = true
          // update $index
          frag.scope.$index = i
          // update $key
          if (key) {
            frag.scope.$key = key
          }
          // update iterator
          if (iterator) {
            frag.scope[iterator] = key !== null ? key : i
          }
          // update data for track-by, object repeat &
          // primitive values.
          if (trackByKey || convertedFromObject || primitive) {
            frag.scope[alias] = value
          }
        } else { // new isntance
          frag = this.create(value, alias, i, key)
          frag.fresh = !init
        }
        frags[i] = frag
        if (init) {
          frag.before(end)
        }
      }
  
      // we're done for the initial render.
      if (init) {
        return
      }
  
      // Second pass, go through the old fragments and
      // destroy those who are not reused (and remove them
      // from cache)
      var removalIndex = 0
      var totalRemoved = oldFrags.length - frags.length
      for (i = 0, l = oldFrags.length; i < l; i++) {
        frag = oldFrags[i]
        if (!frag.reused) {
          this.deleteCachedFrag(frag)
          this.remove(frag, removalIndex++, totalRemoved, inDoc)
        }
      }
  
      // Final pass, move/insert new fragments into the
      // right place.
      var targetPrev, prevEl, currentPrev
      var insertionIndex = 0
      for (i = 0, l = frags.length; i < l; i++) {
        frag = frags[i]
        // this is the frag that we should be after
        targetPrev = frags[i - 1]
        prevEl = targetPrev
          ? targetPrev.staggerCb
            ? targetPrev.staggerAnchor
            : targetPrev.end || targetPrev.node
          : start
        if (frag.reused && !frag.staggerCb) {
          currentPrev = findPrevFrag(frag, start, this.id)
          if (currentPrev !== targetPrev) {
            this.move(frag, prevEl)
          }
        } else {
          // new instance, or still in stagger.
          // insert with updated stagger index.
          this.insert(frag, insertionIndex++, prevEl, inDoc)
        }
        frag.reused = frag.fresh = false
      }
    },
  
    /**
     * Create a new fragment instance.
     *
     * @param {*} value
     * @param {String} alias
     * @param {Number} index
     * @param {String} [key]
     * @return {Fragment}
     */
  
    create: function (value, alias, index, key) {
      var host = this._host
      // create iteration scope
      var parentScope = this._scope || this.vm
      var scope = Object.create(parentScope)
      // ref holder for the scope
      scope.$refs = Object.create(parentScope.$refs)
      scope.$els = Object.create(parentScope.$els)
      // make sure point $parent to parent scope
      scope.$parent = parentScope
      // for two-way binding on alias
      scope.$forContext = this
      // define scope properties
      _.defineReactive(scope, alias, value)
      _.defineReactive(scope, '$index', index)
      if (key) {
        _.defineReactive(scope, '$key', key)
      } else if (scope.$key) {
        // avoid accidental fallback
        _.define(scope, '$key', null)
      }
      if (this.iterator) {
        _.defineReactive(scope, this.iterator, key !== null ? key : index)
      }
      var frag = this.factory.create(host, scope, this._frag)
      frag.forId = this.id
      this.cacheFrag(value, frag, index, key)
      return frag
    },
  
    /**
     * Update the v-ref on owner vm.
     */
  
    updateRef: function () {
      var ref = this.descriptor.ref
      if (!ref) return
      var hash = (this._scope || this.vm).$refs
      var refs
      if (!this.fromObject) {
        refs = this.frags.map(findVmFromFrag)
      } else {
        refs = {}
        this.frags.forEach(function (frag) {
          refs[frag.scope.$key] = findVmFromFrag(frag)
        })
      }
      hash[ref] = refs
    },
  
    /**
     * For option lists, update the containing v-model on
     * parent <select>.
     */
  
    updateModel: function () {
      if (this.isOption) {
        var parent = this.start.parentNode
        var model = parent && parent.__v_model
        if (model) {
          model.forceUpdate()
        }
      }
    },
  
    /**
     * Insert a fragment. Handles staggering.
     *
     * @param {Fragment} frag
     * @param {Number} index
     * @param {Node} prevEl
     * @param {Boolean} inDoc
     */
  
    insert: function (frag, index, prevEl, inDoc) {
      if (frag.staggerCb) {
        frag.staggerCb.cancel()
        frag.staggerCb = null
      }
      var staggerAmount = this.getStagger(frag, index, null, 'enter')
      if (inDoc && staggerAmount) {
        // create an anchor and insert it synchronously,
        // so that we can resolve the correct order without
        // worrying about some elements not inserted yet
        var anchor = frag.staggerAnchor
        if (!anchor) {
          anchor = frag.staggerAnchor = _.createAnchor('stagger-anchor')
          anchor.__vfrag__ = frag
        }
        _.after(anchor, prevEl)
        var op = frag.staggerCb = _.cancellable(function () {
          frag.staggerCb = null
          frag.before(anchor)
          _.remove(anchor)
        })
        setTimeout(op, staggerAmount)
      } else {
        frag.before(prevEl.nextSibling)
      }
    },
  
    /**
     * Remove a fragment. Handles staggering.
     *
     * @param {Fragment} frag
     * @param {Number} index
     * @param {Number} total
     * @param {Boolean} inDoc
     */
  
    remove: function (frag, index, total, inDoc) {
      if (frag.staggerCb) {
        frag.staggerCb.cancel()
        frag.staggerCb = null
        // it's not possible for the same frag to be removed
        // twice, so if we have a pending stagger callback,
        // it means this frag is queued for enter but removed
        // before its transition started. Since it is already
        // destroyed, we can just leave it in detached state.
        return
      }
      var staggerAmount = this.getStagger(frag, index, total, 'leave')
      if (inDoc && staggerAmount) {
        var op = frag.staggerCb = _.cancellable(function () {
          frag.staggerCb = null
          frag.remove()
        })
        setTimeout(op, staggerAmount)
      } else {
        frag.remove()
      }
    },
  
    /**
     * Move a fragment to a new position.
     * Force no transition.
     *
     * @param {Fragment} frag
     * @param {Node} prevEl
     */
  
    move: function (frag, prevEl) {
      frag.before(prevEl.nextSibling, false)
    },
  
    /**
     * Cache a fragment using track-by or the object key.
     *
     * @param {*} value
     * @param {Fragment} frag
     * @param {Number} index
     * @param {String} [key]
     */
  
    cacheFrag: function (value, frag, index, key) {
      var trackByKey = this.params.trackBy
      var cache = this.cache
      var primitive = !isObject(value)
      var id
      if (key || trackByKey || primitive) {
        id = trackByKey
          ? trackByKey === '$index'
            ? index
            : value[trackByKey]
          : (key || value)
        if (!cache[id]) {
          cache[id] = frag
        } else if (trackByKey !== '$index') {
          process.env.NODE_ENV !== 'production' &&
          this.warnDuplicate(value)
        }
      } else {
        id = this.id
        if (value.hasOwnProperty(id)) {
          if (value[id] === null) {
            value[id] = frag
          } else {
            process.env.NODE_ENV !== 'production' &&
            this.warnDuplicate(value)
          }
        } else {
          _.define(value, id, frag)
        }
      }
      frag.raw = value
    },
  
    /**
     * Get a cached fragment from the value/index/key
     *
     * @param {*} value
     * @param {Number} index
     * @param {String} key
     * @return {Fragment}
     */
  
    getCachedFrag: function (value, index, key) {
      var trackByKey = this.params.trackBy
      var primitive = !isObject(value)
      var frag
      if (key || trackByKey || primitive) {
        var id = trackByKey
          ? trackByKey === '$index'
            ? index
            : value[trackByKey]
          : (key || value)
        frag = this.cache[id]
      } else {
        frag = value[this.id]
      }
      if (frag && (frag.reused || frag.fresh)) {
        process.env.NODE_ENV !== 'production' &&
        this.warnDuplicate(value)
      }
      return frag
    },
  
    /**
     * Delete a fragment from cache.
     *
     * @param {Fragment} frag
     */
  
    deleteCachedFrag: function (frag) {
      var value = frag.raw
      var trackByKey = this.params.trackBy
      var scope = frag.scope
      var index = scope.$index
      // fix #948: avoid accidentally fall through to
      // a parent repeater which happens to have $key.
      var key = scope.hasOwnProperty('$key') && scope.$key
      var primitive = !isObject(value)
      if (trackByKey || key || primitive) {
        var id = trackByKey
          ? trackByKey === '$index'
            ? index
            : value[trackByKey]
          : (key || value)
        this.cache[id] = null
      } else {
        value[this.id] = null
        frag.raw = null
      }
    },
  
    /**
     * Get the stagger amount for an insertion/removal.
     *
     * @param {Fragment} frag
     * @param {Number} index
     * @param {Number} total
     * @param {String} type
     */
  
    getStagger: function (frag, index, total, type) {
      type = type + 'Stagger'
      var trans = frag.node.__v_trans
      var hooks = trans && trans.hooks
      var hook = hooks && (hooks[type] || hooks.stagger)
      return hook
        ? hook.call(frag, index, total)
        : index * parseInt(this.params[type] || this.params.stagger, 10)
    },
  
    /**
     * Pre-process the value before piping it through the
     * filters. This is passed to and called by the watcher.
     */
  
    _preProcess: function (value) {
      // regardless of type, store the un-filtered raw value.
      this.rawValue = value
      return value
    },
  
    /**
     * Post-process the value after it has been piped through
     * the filters. This is passed to and called by the watcher.
     *
     * It is necessary for this to be called during the
     * wathcer's dependency collection phase because we want
     * the v-for to update when the source Object is mutated.
     */
  
    _postProcess: function (value) {
      if (_.isArray(value)) {
        return value
      } else if (_.isPlainObject(value)) {
        // convert plain object to array.
        var keys = Object.keys(value)
        var i = keys.length
        var res = new Array(i)
        var key
        while (i--) {
          key = keys[i]
          res[i] = {
            $key: key,
            $value: value[key]
          }
        }
        return res
      } else {
        if (typeof value === 'number') {
          value = range(value)
        }
        return value || []
      }
    },
  
    unbind: function () {
      if (this.descriptor.ref) {
        (this._scope || this.vm).$refs[this.descriptor.ref] = null
      }
      if (this.frags) {
        var i = this.frags.length
        var frag
        while (i--) {
          frag = this.frags[i]
          this.deleteCachedFrag(frag)
          frag.destroy()
        }
      }
    }
  }
  
  /**
   * Helper to find the previous element that is a fragment
   * anchor. This is necessary because a destroyed frag's
   * element could still be lingering in the DOM before its
   * leaving transition finishes, but its inserted flag
   * should have been set to false so we can skip them.
   *
   * If this is a block repeat, we want to make sure we only
   * return frag that is bound to this v-for. (see #929)
   *
   * @param {Fragment} frag
   * @param {Comment|Text} anchor
   * @param {String} id
   * @return {Fragment}
   */
  
  function findPrevFrag (frag, anchor, id) {
    var el = frag.node.previousSibling
    /* istanbul ignore if */
    if (!el) return
    frag = el.__vfrag__
    while (
      (!frag || frag.forId !== id || !frag.inserted) &&
      el !== anchor
    ) {
      el = el.previousSibling
      /* istanbul ignore if */
      if (!el) return
      frag = el.__vfrag__
    }
    return frag
  }
  
  /**
   * Find a vm from a fragment.
   *
   * @param {Fragment} frag
   * @return {Vue|undefined}
   */
  
  function findVmFromFrag (frag) {
    return frag.node.__vue__ || frag.node.nextSibling.__vue__
  }
  
  /**
   * Create a range array from given number.
   *
   * @param {Number} n
   * @return {Array}
   */
  
  function range (n) {
    var i = -1
    var ret = new Array(n)
    while (++i < n) {
      ret[i] = i
    }
    return ret
  }
  
  if (process.env.NODE_ENV !== 'production') {
    module.exports.warnDuplicate = function (value) {
      _.warn(
        'Duplicate value found in v-for="' + this.descriptor.raw + '": ' +
        JSON.stringify(value) + '. Use track-by="$index" if ' +
        'you are expecting duplicate values.'
      )
    }
  }
  
  }).call(this,require('_process'))
  },{"../../fragment/factory":60,"../../util":82,"_process":5}],46:[function(require,module,exports){
  var _ = require('../../util')
  var templateParser = require('../../parsers/template')
  
  module.exports = {
  
    bind: function () {
      // a comment node means this is a binding for
      // {{{ inline unescaped html }}}
      if (this.el.nodeType === 8) {
        // hold nodes
        this.nodes = []
        // replace the placeholder with proper anchor
        this.anchor = _.createAnchor('v-html')
        _.replace(this.el, this.anchor)
      }
    },
  
    update: function (value) {
      value = _.toString(value)
      if (this.nodes) {
        this.swap(value)
      } else {
        this.el.innerHTML = value
      }
    },
  
    swap: function (value) {
      // remove old nodes
      var i = this.nodes.length
      while (i--) {
        _.remove(this.nodes[i])
      }
      // convert new value to a fragment
      // do not attempt to retrieve from id selector
      var frag = templateParser.parse(value, true, true)
      // save a reference to these nodes so we can remove later
      this.nodes = _.toArray(frag.childNodes)
      _.before(frag, this.anchor)
    }
  }
  
  },{"../../parsers/template":73,"../../util":82}],47:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  var FragmentFactory = require('../../fragment/factory')
  
  module.exports = {
  
    priority: 2000,
  
    bind: function () {
      var el = this.el
      if (!el.__vue__) {
        // check else block
        var next = el.nextElementSibling
        if (next && _.attr(next, 'v-else') !== null) {
          _.remove(next)
          this.elseFactory = new FragmentFactory(this.vm, next)
        }
        // check main block
        this.anchor = _.createAnchor('v-if')
        _.replace(el, this.anchor)
        this.factory = new FragmentFactory(this.vm, el)
      } else {
        process.env.NODE_ENV !== 'production' && _.warn(
          'v-if="' + this.expression + '" cannot be ' +
          'used on an instance root element.'
        )
        this.invalid = true
      }
    },
  
    update: function (value) {
      if (this.invalid) return
      if (value) {
        if (!this.frag) {
          this.insert()
        }
      } else {
        this.remove()
      }
    },
  
    insert: function () {
      if (this.elseFrag) {
        this.elseFrag.remove()
        this.elseFrag = null
      }
      this.frag = this.factory.create(this._host, this._scope, this._frag)
      this.frag.before(this.anchor)
    },
  
    remove: function () {
      if (this.frag) {
        this.frag.remove()
        this.frag = null
      }
      if (this.elseFactory && !this.elseFrag) {
        this.elseFrag = this.elseFactory.create(this._host, this._scope, this._frag)
        this.elseFrag.before(this.anchor)
      }
    },
  
    unbind: function () {
      if (this.frag) {
        this.frag.destroy()
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../../fragment/factory":60,"../../util":82,"_process":5}],48:[function(require,module,exports){
  // text & html
  exports.text = require('./text')
  exports.html = require('./html')
  
  // logic control
  exports['for'] = require('./for')
  exports['if'] = require('./if')
  exports.show = require('./show')
  
  // two-way binding
  exports.model = require('./model')
  
  // event handling
  exports.on = require('./on')
  
  // attributes
  exports.bind = require('./bind')
  
  // ref & el
  exports.el = require('./el')
  exports.ref = require('./ref')
  
  // cloak
  exports.cloak = require('./cloak')
  
  },{"./bind":42,"./cloak":43,"./el":44,"./for":45,"./html":46,"./if":47,"./model":50,"./on":54,"./ref":55,"./show":56,"./text":57}],49:[function(require,module,exports){
  var _ = require('../../../util')
  
  module.exports = {
  
    bind: function () {
      var self = this
      var el = this.el
  
      this.getValue = function () {
        return el.hasOwnProperty('_value')
          ? el._value
          : self.params.number
            ? _.toNumber(el.value)
            : el.value
      }
  
      function getBooleanValue () {
        var val = el.checked
        if (val && el.hasOwnProperty('_trueValue')) {
          return el._trueValue
        }
        if (!val && el.hasOwnProperty('_falseValue')) {
          return el._falseValue
        }
        return val
      }
  
      this.listener = function () {
        var model = self._watcher.value
        if (_.isArray(model)) {
          var val = self.getValue()
          if (el.checked) {
            if (_.indexOf(model, val) < 0) {
              model.push(val)
            }
          } else {
            model.$remove(val)
          }
        } else {
          self.set(getBooleanValue())
        }
      }
  
      this.on('change', this.listener)
      if (el.checked) {
        this.afterBind = this.listener
      }
    },
  
    update: function (value) {
      var el = this.el
      if (_.isArray(value)) {
        el.checked = _.indexOf(value, this.getValue()) > -1
      } else {
        if (el.hasOwnProperty('_trueValue')) {
          el.checked = _.looseEqual(value, el._trueValue)
        } else {
          el.checked = !!value
        }
      }
    }
  }
  
  },{"../../../util":82}],50:[function(require,module,exports){
  (function (process){
  var _ = require('../../../util')
  
  var handlers = {
    text: require('./text'),
    radio: require('./radio'),
    select: require('./select'),
    checkbox: require('./checkbox')
  }
  
  module.exports = {
  
    priority: 800,
    twoWay: true,
    handlers: handlers,
    params: ['lazy', 'number', 'debounce'],
  
    /**
     * Possible elements:
     *   <select>
     *   <textarea>
     *   <input type="*">
     *     - text
     *     - checkbox
     *     - radio
     *     - number
     */
  
    bind: function () {
      // friendly warning...
      this.checkFilters()
      if (this.hasRead && !this.hasWrite) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'It seems you are using a read-only filter with ' +
          'v-model. You might want to use a two-way filter ' +
          'to ensure correct behavior.'
        )
      }
      var el = this.el
      var tag = el.tagName
      var handler
      if (tag === 'INPUT') {
        handler = handlers[el.type] || handlers.text
      } else if (tag === 'SELECT') {
        handler = handlers.select
      } else if (tag === 'TEXTAREA') {
        handler = handlers.text
      } else {
        process.env.NODE_ENV !== 'production' && _.warn(
          'v-model does not support element type: ' + tag
        )
        return
      }
      el.__v_model = this
      handler.bind.call(this)
      this.update = handler.update
      this._unbind = handler.unbind
    },
  
    /**
     * Check read/write filter stats.
     */
  
    checkFilters: function () {
      var filters = this.filters
      if (!filters) return
      var i = filters.length
      while (i--) {
        var filter = _.resolveAsset(this.vm.$options, 'filters', filters[i].name)
        if (typeof filter === 'function' || filter.read) {
          this.hasRead = true
        }
        if (filter.write) {
          this.hasWrite = true
        }
      }
    },
  
    unbind: function () {
      this.el.__v_model = null
      this._unbind && this._unbind()
    }
  }
  
  }).call(this,require('_process'))
  },{"../../../util":82,"./checkbox":49,"./radio":51,"./select":52,"./text":53,"_process":5}],51:[function(require,module,exports){
  var _ = require('../../../util')
  
  module.exports = {
  
    bind: function () {
      var self = this
      var el = this.el
  
      this.getValue = function () {
        // value overwrite via v-bind:value
        if (el.hasOwnProperty('_value')) {
          return el._value
        }
        var val = el.value
        if (self.params.number) {
          val = _.toNumber(val)
        }
        return val
      }
  
      this.listener = function () {
        self.set(self.getValue())
      }
      this.on('change', this.listener)
  
      if (el.checked) {
        this.afterBind = this.listener
      }
    },
  
    update: function (value) {
      this.el.checked = _.looseEqual(value, this.getValue())
    }
  }
  
  },{"../../../util":82}],52:[function(require,module,exports){
  var _ = require('../../../util')
  
  module.exports = {
  
    bind: function () {
      var self = this
      var el = this.el
  
      // method to force update DOM using latest value.
      this.forceUpdate = function () {
        if (self._watcher) {
          self.update(self._watcher.get())
        }
      }
  
      // check if this is a multiple select
      var multiple = this.multiple = el.hasAttribute('multiple')
  
      // attach listener
      this.listener = function () {
        var value = getValue(el, multiple)
        value = self.params.number
          ? _.isArray(value)
            ? value.map(_.toNumber)
            : _.toNumber(value)
          : value
        self.set(value)
      }
      this.on('change', this.listener)
  
      // if has initial value, set afterBind
      var initValue = getValue(el, multiple, true)
      if ((multiple && initValue.length) ||
          (!multiple && initValue !== null)) {
        this.afterBind = this.listener
      }
  
      // All major browsers except Firefox resets
      // selectedIndex with value -1 to 0 when the element
      // is appended to a new parent, therefore we have to
      // force a DOM update whenever that happens...
      this.vm.$on('hook:attached', this.forceUpdate)
    },
  
    update: function (value) {
      var el = this.el
      el.selectedIndex = -1
      var multi = this.multiple && _.isArray(value)
      var options = el.options
      var i = options.length
      var op, val
      while (i--) {
        op = options[i]
        val = op.hasOwnProperty('_value')
          ? op._value
          : op.value
        /* eslint-disable eqeqeq */
        op.selected = multi
          ? indexOf(value, val) > -1
          : _.looseEqual(value, val)
        /* eslint-enable eqeqeq */
      }
    },
  
    unbind: function () {
      /* istanbul ignore next */
      this.vm.$off('hook:attached', this.forceUpdate)
    }
  }
  
  /**
   * Get select value
   *
   * @param {SelectElement} el
   * @param {Boolean} multi
   * @param {Boolean} init
   * @return {Array|*}
   */
  
  function getValue (el, multi, init) {
    var res = multi ? [] : null
    var op, val, selected
    for (var i = 0, l = el.options.length; i < l; i++) {
      op = el.options[i]
      selected = init
        ? op.hasAttribute('selected')
        : op.selected
      if (selected) {
        val = op.hasOwnProperty('_value')
          ? op._value
          : op.value
        if (multi) {
          res.push(val)
        } else {
          return val
        }
      }
    }
    return res
  }
  
  /**
   * Native Array.indexOf uses strict equal, but in this
   * case we need to match string/numbers with custom equal.
   *
   * @param {Array} arr
   * @param {*} val
   */
  
  function indexOf (arr, val) {
    var i = arr.length
    while (i--) {
      if (_.looseEqual(arr[i], val)) {
        return i
      }
    }
    return -1
  }
  
  },{"../../../util":82}],53:[function(require,module,exports){
  var _ = require('../../../util')
  
  module.exports = {
  
    bind: function () {
      var self = this
      var el = this.el
      var isRange = el.type === 'range'
      var lazy = this.params.lazy
      var number = this.params.number
      var debounce = this.params.debounce
  
      // handle composition events.
      //   http://blog.evanyou.me/2014/01/03/composition-event/
      // skip this for Android because it handles composition
      // events quite differently. Android doesn't trigger
      // composition events for language input methods e.g.
      // Chinese, but instead triggers them for spelling
      // suggestions... (see Discussion/#162)
      var composing = false
      if (!_.isAndroid && !isRange) {
        this.on('compositionstart', function () {
          composing = true
        })
        this.on('compositionend', function () {
          composing = false
          // in IE11 the "compositionend" event fires AFTER
          // the "input" event, so the input handler is blocked
          // at the end... have to call it here.
          //
          // #1327: in lazy mode this is unecessary.
          if (!lazy) {
            self.listener()
          }
        })
      }
  
      // prevent messing with the input when user is typing,
      // and force update on blur.
      this.focused = false
      if (!isRange) {
        this.on('focus', function () {
          self.focused = true
        })
        this.on('blur', function () {
          self.focused = false
          self.listener()
        })
      }
  
      // Now attach the main listener
      this.listener = function () {
        if (composing) return
        var val = number || isRange
          ? _.toNumber(el.value)
          : el.value
        self.set(val)
        // force update on next tick to avoid lock & same value
        // also only update when user is not typing
        _.nextTick(function () {
          if (self._bound && !self.focused) {
            self.update(self._watcher.value)
          }
        })
      }
  
      // apply debounce
      if (debounce) {
        this.listener = _.debounce(this.listener, debounce)
      }
  
      // Support jQuery events, since jQuery.trigger() doesn't
      // trigger native events in some cases and some plugins
      // rely on $.trigger()
      //
      // We want to make sure if a listener is attached using
      // jQuery, it is also removed with jQuery, that's why
      // we do the check for each directive instance and
      // store that check result on itself. This also allows
      // easier test coverage control by unsetting the global
      // jQuery variable in tests.
      this.hasjQuery = typeof jQuery === 'function'
      if (this.hasjQuery) {
        jQuery(el).on('change', this.listener)
        if (!lazy) {
          jQuery(el).on('input', this.listener)
        }
      } else {
        this.on('change', this.listener)
        if (!lazy) {
          this.on('input', this.listener)
        }
      }
  
      // IE9 doesn't fire input event on backspace/del/cut
      if (!lazy && _.isIE9) {
        this.on('cut', function () {
          _.nextTick(self.listener)
        })
        this.on('keyup', function (e) {
          if (e.keyCode === 46 || e.keyCode === 8) {
            self.listener()
          }
        })
      }
  
      // set initial value if present
      if (
        el.hasAttribute('value') ||
        (el.tagName === 'TEXTAREA' && el.value.trim())
      ) {
        this.afterBind = this.listener
      }
    },
  
    update: function (value) {
      this.el.value = _.toString(value)
    },
  
    unbind: function () {
      var el = this.el
      if (this.hasjQuery) {
        jQuery(el).off('change', this.listener)
        jQuery(el).off('input', this.listener)
      }
    }
  }
  
  },{"../../../util":82}],54:[function(require,module,exports){
  (function (process){
  var _ = require('../../util')
  
  // keyCode aliases
  var keyCodes = {
    esc: 27,
    tab: 9,
    enter: 13,
    space: 32,
    'delete': 46,
    up: 38,
    left: 37,
    right: 39,
    down: 40
  }
  
  function keyFilter (handler, keys) {
    var codes = keys.map(function (key) {
      var charCode = key.charCodeAt(0)
      if (charCode > 47 && charCode < 58) {
        return parseInt(key, 10)
      }
      if (key.length === 1) {
        charCode = key.toUpperCase().charCodeAt(0)
        if (charCode > 64 && charCode < 91) {
          return charCode
        }
      }
      return keyCodes[key]
    })
    return function keyHandler (e) {
      if (codes.indexOf(e.keyCode) > -1) {
        return handler.call(this, e)
      }
    }
  }
  
  function stopFilter (handler) {
    return function stopHandler (e) {
      e.stopPropagation()
      return handler.call(this, e)
    }
  }
  
  function preventFilter (handler) {
    return function preventHandler (e) {
      e.preventDefault()
      return handler.call(this, e)
    }
  }
  
  module.exports = {
  
    acceptStatement: true,
    priority: 700,
  
    bind: function () {
      // deal with iframes
      if (
        this.el.tagName === 'IFRAME' &&
        this.arg !== 'load'
      ) {
        var self = this
        this.iframeBind = function () {
          _.on(self.el.contentWindow, self.arg, self.handler)
        }
        this.on('load', this.iframeBind)
      }
    },
  
    update: function (handler) {
      // stub a noop for v-on with no value,
      // e.g. @mousedown.prevent
      if (!this.descriptor.raw) {
        handler = function () {}
      }
  
      if (typeof handler !== 'function') {
        process.env.NODE_ENV !== 'production' && _.warn(
          'v-on:' + this.arg + '="' +
          this.expression + '" expects a function value, ' +
          'got ' + handler
        )
        return
      }
  
      // apply modifiers
      if (this.modifiers.stop) {
        handler = stopFilter(handler)
      }
      if (this.modifiers.prevent) {
        handler = preventFilter(handler)
      }
      // key filter
      var keys = Object.keys(this.modifiers)
        .filter(function (key) {
          return key !== 'stop' && key !== 'prevent'
        })
      if (keys.length) {
        handler = keyFilter(handler, keys)
      }
  
      this.reset()
      this.handler = handler
  
      if (this.iframeBind) {
        this.iframeBind()
      } else {
        _.on(this.el, this.arg, this.handler)
      }
    },
  
    reset: function () {
      var el = this.iframeBind
        ? this.el.contentWindow
        : this.el
      if (this.handler) {
        _.off(el, this.arg, this.handler)
      }
    },
  
    unbind: function () {
      this.reset()
    }
  }
  
  }).call(this,require('_process'))
  },{"../../util":82,"_process":5}],55:[function(require,module,exports){
  (function (process){
  if (process.env.NODE_ENV !== 'production') {
    module.exports = {
      bind: function () {
        require('../../util').warn(
          'v-ref:' + this.arg + ' must be used on a child ' +
          'component. Found on <' + this.el.tagName.toLowerCase() + '>.'
        )
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../../util":82,"_process":5}],56:[function(require,module,exports){
  var _ = require('../../util')
  var transition = require('../../transition')
  
  module.exports = {
  
    bind: function () {
      // check else block
      var next = this.el.nextElementSibling
      if (next && _.attr(next, 'v-else') !== null) {
        this.elseEl = next
      }
    },
  
    update: function (value) {
      this.apply(this.el, value)
      if (this.elseEl) {
        this.apply(this.elseEl, !value)
      }
    },
  
    apply: function (el, value) {
      transition.apply(el, value ? 1 : -1, function () {
        el.style.display = value ? '' : 'none'
      }, this.vm)
    }
  }
  
  },{"../../transition":75,"../../util":82}],57:[function(require,module,exports){
  var _ = require('../../util')
  
  module.exports = {
  
    bind: function () {
      this.attr = this.el.nodeType === 3
        ? 'data'
        : 'textContent'
    },
  
    update: function (value) {
      this.el[this.attr] = _.toString(value)
    }
  }
  
  },{"../../util":82}],58:[function(require,module,exports){
  var _ = require('../util')
  var Path = require('../parsers/path')
  var toArray = require('../directives/public/for')._postProcess
  
  /**
   * Limit filter for arrays
   *
   * @param {Number} n
   * @param {Number} offset (Decimal expected)
   */
  
  exports.limitBy = function (arr, n, offset) {
    offset = offset ? parseInt(offset, 10) : 0
    return typeof n === 'number'
      ? arr.slice(offset, offset + n)
      : arr
  }
  
  /**
   * Filter filter for arrays
   *
   * @param {String} search
   * @param {String} [delimiter]
   * @param {String} ...dataKeys
   */
  
  exports.filterBy = function (arr, search, delimiter) {
    arr = toArray(arr)
    if (search == null) {
      return arr
    }
    if (typeof search === 'function') {
      return arr.filter(search)
    }
    // cast to lowercase string
    search = ('' + search).toLowerCase()
    // allow optional `in` delimiter
    // because why not
    var n = delimiter === 'in' ? 3 : 2
    // extract and flatten keys
    var keys = _.toArray(arguments, n).reduce(function (prev, cur) {
      return prev.concat(cur)
    }, [])
    var res = []
    var item, key, val, j
    for (var i = 0, l = arr.length; i < l; i++) {
      item = arr[i]
      val = (item && item.$value) || item
      j = keys.length
      if (j) {
        while (j--) {
          key = keys[j]
          if ((key === '$key' && contains(item.$key, search)) ||
              contains(Path.get(val, key), search)) {
            res.push(item)
            break
          }
        }
      } else if (contains(item, search)) {
        res.push(item)
      }
    }
    return res
  }
  
  /**
   * Filter filter for arrays
   *
   * @param {String} sortKey
   * @param {String} reverse
   */
  
  exports.orderBy = function (arr, sortKey, reverse) {
    arr = toArray(arr)
    if (!sortKey) {
      return arr
    }
    var order = (reverse && reverse < 0) ? -1 : 1
    // sort on a copy to avoid mutating original array
    return arr.slice().sort(function (a, b) {
      if (sortKey !== '$key') {
        if (_.isObject(a) && '$value' in a) a = a.$value
        if (_.isObject(b) && '$value' in b) b = b.$value
      }
      a = _.isObject(a) ? Path.get(a, sortKey) : a
      b = _.isObject(b) ? Path.get(b, sortKey) : b
      return a === b ? 0 : a > b ? order : -order
    })
  }
  
  /**
   * String contain helper
   *
   * @param {*} val
   * @param {String} search
   */
  
  function contains (val, search) {
    var i
    if (_.isPlainObject(val)) {
      var keys = Object.keys(val)
      i = keys.length
      while (i--) {
        if (contains(val[keys[i]], search)) {
          return true
        }
      }
    } else if (_.isArray(val)) {
      i = val.length
      while (i--) {
        if (contains(val[i], search)) {
          return true
        }
      }
    } else if (val != null) {
      return val.toString().toLowerCase().indexOf(search) > -1
    }
  }
  
  },{"../directives/public/for":45,"../parsers/path":72,"../util":82}],59:[function(require,module,exports){
  var _ = require('../util')
  
  /**
   * Stringify value.
   *
   * @param {Number} indent
   */
  
  exports.json = {
    read: function (value, indent) {
      return typeof value === 'string'
        ? value
        : JSON.stringify(value, null, Number(indent) || 2)
    },
    write: function (value) {
      try {
        return JSON.parse(value)
      } catch (e) {
        return value
      }
    }
  }
  
  /**
   * 'abc' => 'Abc'
   */
  
  exports.capitalize = function (value) {
    if (!value && value !== 0) return ''
    value = value.toString()
    return value.charAt(0).toUpperCase() + value.slice(1)
  }
  
  /**
   * 'abc' => 'ABC'
   */
  
  exports.uppercase = function (value) {
    return (value || value === 0)
      ? value.toString().toUpperCase()
      : ''
  }
  
  /**
   * 'AbC' => 'abc'
   */
  
  exports.lowercase = function (value) {
    return (value || value === 0)
      ? value.toString().toLowerCase()
      : ''
  }
  
  /**
   * 12345 => $12,345.00
   *
   * @param {String} sign
   */
  
  var digitsRE = /(\d{3})(?=\d)/g
  exports.currency = function (value, currency) {
    value = parseFloat(value)
    if (!isFinite(value) || (!value && value !== 0)) return ''
    currency = currency != null ? currency : '$'
    var stringified = Math.abs(value).toFixed(2)
    var _int = stringified.slice(0, -3)
    var i = _int.length % 3
    var head = i > 0
      ? (_int.slice(0, i) + (_int.length > 3 ? ',' : ''))
      : ''
    var _float = stringified.slice(-3)
    var sign = value < 0 ? '-' : ''
    return currency + sign + head +
      _int.slice(i).replace(digitsRE, '$1,') +
      _float
  }
  
  /**
   * 'item' => 'items'
   *
   * @params
   *  an array of strings corresponding to
   *  the single, double, triple ... forms of the word to
   *  be pluralized. When the number to be pluralized
   *  exceeds the length of the args, it will use the last
   *  entry in the array.
   *
   *  e.g. ['single', 'double', 'triple', 'multiple']
   */
  
  exports.pluralize = function (value) {
    var args = _.toArray(arguments, 1)
    return args.length > 1
      ? (args[value % 10 - 1] || args[args.length - 1])
      : (args[0] + (value === 1 ? '' : 's'))
  }
  
  /**
   * Debounce a handler function.
   *
   * @param {Function} handler
   * @param {Number} delay = 300
   * @return {Function}
   */
  
  exports.debounce = function (handler, delay) {
    if (!handler) return
    if (!delay) {
      delay = 300
    }
    return _.debounce(handler, delay)
  }
  
  /**
   * Install special array filters
   */
  
  _.extend(exports, require('./array-filters'))
  
  },{"../util":82,"./array-filters":58}],60:[function(require,module,exports){
  var _ = require('../util')
  var compiler = require('../compiler')
  var templateParser = require('../parsers/template')
  var Fragment = require('./fragment')
  var Cache = require('../cache')
  var linkerCache = new Cache(5000)
  
  /**
   * A factory that can be used to create instances of a
   * fragment. Caches the compiled linker if possible.
   *
   * @param {Vue} vm
   * @param {Element|String} el
   */
  
  function FragmentFactory (vm, el) {
    this.vm = vm
    var template
    var isString = typeof el === 'string'
    if (isString || _.isTemplate(el)) {
      template = templateParser.parse(el, true)
    } else {
      template = document.createDocumentFragment()
      template.appendChild(el)
    }
    this.template = template
    // linker can be cached, but only for components
    var linker
    var cid = vm.constructor.cid
    if (cid > 0) {
      var cacheId = cid + (isString ? el : el.outerHTML)
      linker = linkerCache.get(cacheId)
      if (!linker) {
        linker = compiler.compile(template, vm.$options, true)
        linkerCache.put(cacheId, linker)
      }
    } else {
      linker = compiler.compile(template, vm.$options, true)
    }
    this.linker = linker
  }
  
  /**
   * Create a fragment instance with given host and scope.
   *
   * @param {Vue} host
   * @param {Object} scope
   * @param {Fragment} parentFrag
   */
  
  FragmentFactory.prototype.create = function (host, scope, parentFrag) {
    var frag = templateParser.clone(this.template)
    return new Fragment(this.linker, this.vm, frag, host, scope, parentFrag)
  }
  
  module.exports = FragmentFactory
  
  },{"../cache":26,"../compiler":29,"../parsers/template":73,"../util":82,"./fragment":61}],61:[function(require,module,exports){
  var _ = require('../util')
  var transition = require('../transition')
  
  /**
   * Abstraction for a partially-compiled fragment.
   * Can optionally compile content with a child scope.
   *
   * @param {Function} linker
   * @param {Vue} vm
   * @param {DocumentFragment} frag
   * @param {Vue} [host]
   * @param {Object} [scope]
   */
  
  function Fragment (linker, vm, frag, host, scope, parentFrag) {
    this.children = []
    this.childFrags = []
    this.vm = vm
    this.scope = scope
    this.inserted = false
    this.parentFrag = parentFrag
    if (parentFrag) {
      parentFrag.childFrags.push(this)
    }
    this.unlink = linker(vm, frag, host, scope, this)
    var single = this.single =
      frag.childNodes.length === 1 &&
      // do not go single mode if the only node is an anchor
      !(frag.childNodes[0].__vue_anchor)
    if (single) {
      this.node = frag.childNodes[0]
      this.before = singleBefore
      this.remove = singleRemove
    } else {
      this.node = _.createAnchor('fragment-start')
      this.end = _.createAnchor('fragment-end')
      this.frag = frag
      _.prepend(this.node, frag)
      frag.appendChild(this.end)
      this.before = multiBefore
      this.remove = multiRemove
    }
    this.node.__vfrag__ = this
  }
  
  /**
   * Call attach/detach for all components contained within
   * this fragment. Also do so recursively for all child
   * fragments.
   *
   * @param {Function} hook
   */
  
  Fragment.prototype.callHook = function (hook) {
    var i, l
    for (i = 0, l = this.children.length; i < l; i++) {
      hook(this.children[i])
    }
    for (i = 0, l = this.childFrags.length; i < l; i++) {
      this.childFrags[i].callHook(hook)
    }
  }
  
  /**
   * Destroy the fragment.
   */
  
  Fragment.prototype.destroy = function () {
    if (this.parentFrag) {
      this.parentFrag.childFrags.$remove(this)
    }
    this.unlink()
  }
  
  /**
   * Insert fragment before target, single node version
   *
   * @param {Node} target
   * @param {Boolean} withTransition
   */
  
  function singleBefore (target, withTransition) {
    this.inserted = true
    var method = withTransition !== false
      ? transition.before
      : _.before
    method(this.node, target, this.vm)
    if (_.inDoc(this.node)) {
      this.callHook(attach)
    }
  }
  
  /**
   * Remove fragment, single node version
   */
  
  function singleRemove () {
    this.inserted = false
    var shouldCallRemove = _.inDoc(this.node)
    var self = this
    self.callHook(destroyChild)
    transition.remove(this.node, this.vm, function () {
      if (shouldCallRemove) {
        self.callHook(detach)
      }
      self.destroy()
    })
  }
  
  /**
   * Insert fragment before target, multi-nodes version
   *
   * @param {Node} target
   * @param {Boolean} withTransition
   */
  
  function multiBefore (target, withTransition) {
    this.inserted = true
    var vm = this.vm
    var method = withTransition !== false
      ? transition.before
      : _.before
    _.mapNodeRange(this.node, this.end, function (node) {
      method(node, target, vm)
    })
    if (_.inDoc(this.node)) {
      this.callHook(attach)
    }
  }
  
  /**
   * Remove fragment, multi-nodes version
   */
  
  function multiRemove () {
    this.inserted = false
    var self = this
    var shouldCallRemove = _.inDoc(this.node)
    self.callHook(destroyChild)
    _.removeNodeRange(this.node, this.end, this.vm, this.frag, function () {
      if (shouldCallRemove) {
        self.callHook(detach)
      }
      self.destroy()
    })
  }
  
  /**
   * Call attach hook for a Vue instance.
   *
   * @param {Vue} child
   */
  
  function attach (child) {
    if (!child._isAttached) {
      child._callHook('attached')
    }
  }
  
  /**
   * Call destroy for all contained instances,
   * with remove:false and defer:true.
   * Defer is necessary because we need to
   * keep the children to call detach hooks
   * on them.
   *
   * @param {Vue} child
   */
  
  function destroyChild (child) {
    child.$destroy(false, true)
  }
  
  /**
   * Call detach hook for a Vue instance.
   *
   * @param {Vue} child
   */
  
  function detach (child) {
    if (child._isAttached) {
      child._callHook('detached')
    }
  }
  
  module.exports = Fragment
  
  },{"../transition":75,"../util":82}],62:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var inDoc = _.inDoc
  var eventRE = /^v-on:|^@/
  
  /**
   * Setup the instance's option events & watchers.
   * If the value is a string, we pull it from the
   * instance's methods by name.
   */
  
  exports._initEvents = function () {
    var options = this.$options
    if (options._asComponent) {
      registerComponentEvents(this, options.el)
    }
    registerCallbacks(this, '$on', options.events)
    registerCallbacks(this, '$watch', options.watch)
  }
  
  /**
   * Register v-on events on a child component
   *
   * @param {Vue} vm
   * @param {Element} el
   */
  
  function registerComponentEvents (vm, el) {
    var attrs = el.attributes
    var name, handler
    for (var i = 0, l = attrs.length; i < l; i++) {
      name = attrs[i].name
      if (eventRE.test(name)) {
        name = name.replace(eventRE, '')
        handler = (vm._scope || vm._context).$eval(attrs[i].value, true)
        vm.$on(name.replace(eventRE), handler)
      }
    }
  }
  
  /**
   * Register callbacks for option events and watchers.
   *
   * @param {Vue} vm
   * @param {String} action
   * @param {Object} hash
   */
  
  function registerCallbacks (vm, action, hash) {
    if (!hash) return
    var handlers, key, i, j
    for (key in hash) {
      handlers = hash[key]
      if (_.isArray(handlers)) {
        for (i = 0, j = handlers.length; i < j; i++) {
          register(vm, action, key, handlers[i])
        }
      } else {
        register(vm, action, key, handlers)
      }
    }
  }
  
  /**
   * Helper to register an event/watch callback.
   *
   * @param {Vue} vm
   * @param {String} action
   * @param {String} key
   * @param {Function|String|Object} handler
   * @param {Object} [options]
   */
  
  function register (vm, action, key, handler, options) {
    var type = typeof handler
    if (type === 'function') {
      vm[action](key, handler, options)
    } else if (type === 'string') {
      var methods = vm.$options.methods
      var method = methods && methods[handler]
      if (method) {
        vm[action](key, method, options)
      } else {
        process.env.NODE_ENV !== 'production' && _.warn(
          'Unknown method: "' + handler + '" when ' +
          'registering callback for ' + action +
          ': "' + key + '".'
        )
      }
    } else if (handler && type === 'object') {
      register(vm, action, key, handler.handler, handler)
    }
  }
  
  /**
   * Setup recursive attached/detached calls
   */
  
  exports._initDOMHooks = function () {
    this.$on('hook:attached', onAttached)
    this.$on('hook:detached', onDetached)
  }
  
  /**
   * Callback to recursively call attached hook on children
   */
  
  function onAttached () {
    if (!this._isAttached) {
      this._isAttached = true
      this.$children.forEach(callAttach)
    }
  }
  
  /**
   * Iterator to call attached hook
   *
   * @param {Vue} child
   */
  
  function callAttach (child) {
    if (!child._isAttached && inDoc(child.$el)) {
      child._callHook('attached')
    }
  }
  
  /**
   * Callback to recursively call detached hook on children
   */
  
  function onDetached () {
    if (this._isAttached) {
      this._isAttached = false
      this.$children.forEach(callDetach)
    }
  }
  
  /**
   * Iterator to call detached hook
   *
   * @param {Vue} child
   */
  
  function callDetach (child) {
    if (child._isAttached && !inDoc(child.$el)) {
      child._callHook('detached')
    }
  }
  
  /**
   * Trigger all handlers for a hook
   *
   * @param {String} hook
   */
  
  exports._callHook = function (hook) {
    var handlers = this.$options[hook]
    if (handlers) {
      for (var i = 0, j = handlers.length; i < j; i++) {
        handlers[i].call(this)
      }
    }
    this.$emit('hook:' + hook)
  }
  
  }).call(this,require('_process'))
  },{"../util":82,"_process":5}],63:[function(require,module,exports){
  var mergeOptions = require('../util').mergeOptions
  var uid = 0
  
  /**
   * The main init sequence. This is called for every
   * instance, including ones that are created from extended
   * constructors.
   *
   * @param {Object} options - this options object should be
   *                           the result of merging class
   *                           options and the options passed
   *                           in to the constructor.
   */
  
  exports._init = function (options) {
  
    options = options || {}
  
    this.$el = null
    this.$parent = options.parent
    this.$root = this.$parent
      ? this.$parent.$root
      : this
    this.$children = []
    this.$refs = {}       // child vm references
    this.$els = {}        // element references
    this._watchers = []   // all watchers as an array
    this._directives = [] // all directives
  
    // a uid
    this._uid = uid++
  
    // a flag to avoid this being observed
    this._isVue = true
  
    // events bookkeeping
    this._events = {}            // registered callbacks
    this._eventsCount = {}       // for $broadcast optimization
    this._shouldPropagate = false // for event propagation
  
    // fragment instance properties
    this._isFragment = false
    this._fragment =         // @type {DocumentFragment}
    this._fragmentStart =    // @type {Text|Comment}
    this._fragmentEnd = null // @type {Text|Comment}
  
    // lifecycle state
    this._isCompiled =
    this._isDestroyed =
    this._isReady =
    this._isAttached =
    this._isBeingDestroyed = false
    this._unlinkFn = null
  
    // context:
    // if this is a transcluded component, context
    // will be the common parent vm of this instance
    // and its host.
    this._context = options._context || this.$parent
  
    // scope:
    // if this is inside an inline v-for, the scope
    // will be the intermediate scope created for this
    // repeat fragment. this is used for linking props
    // and container directives.
    this._scope = options._scope
  
    // fragment:
    // if this instance is compiled inside a Fragment, it
    // needs to reigster itself as a child of that fragment
    // for attach/detach to work properly.
    this._frag = options._frag
    if (this._frag) {
      this._frag.children.push(this)
    }
  
    // push self into parent / transclusion host
    if (this.$parent) {
      this.$parent.$children.push(this)
    }
  
    // merge options.
    options = this.$options = mergeOptions(
      this.constructor.options,
      options,
      this
    )
  
    // set ref
    this._updateRef()
  
    // initialize data as empty object.
    // it will be filled up in _initScope().
    this._data = {}
  
    // call init hook
    this._callHook('init')
  
    // initialize data observation and scope inheritance.
    this._initState()
  
    // setup event system and option events.
    this._initEvents()
  
    // call created hook
    this._callHook('created')
  
    // if `el` option is passed, start compilation.
    if (options.el) {
      this.$mount(options.el)
    }
  }
  
  },{"../util":82}],64:[function(require,module,exports){
  var _ = require('../util')
  var Directive = require('../directive')
  var compiler = require('../compiler')
  
  /**
   * Update v-ref for component.
   *
   * @param {Boolean} remove
   */
  
  exports._updateRef = function (remove) {
    var ref = this.$options._ref
    if (ref) {
      var refs = (this._scope || this._context).$refs
      if (remove) {
        if (refs[ref] === this) {
          refs[ref] = null
        }
      } else {
        refs[ref] = this
      }
    }
  }
  
  /**
   * Transclude, compile and link element.
   *
   * If a pre-compiled linker is available, that means the
   * passed in element will be pre-transcluded and compiled
   * as well - all we need to do is to call the linker.
   *
   * Otherwise we need to call transclude/compile/link here.
   *
   * @param {Element} el
   * @return {Element}
   */
  
  exports._compile = function (el) {
    var options = this.$options
  
    // transclude and init element
    // transclude can potentially replace original
    // so we need to keep reference; this step also injects
    // the template and caches the original attributes
    // on the container node and replacer node.
    var original = el
    el = compiler.transclude(el, options)
    this._initElement(el)
  
    // root is always compiled per-instance, because
    // container attrs and props can be different every time.
    var contextOptions = this._context && this._context.$options
    var rootLinker = compiler.compileRoot(el, options, contextOptions)
  
    // compile and link the rest
    var contentLinkFn
    var ctor = this.constructor
    // component compilation can be cached
    // as long as it's not using inline-template
    if (options._linkerCachable) {
      contentLinkFn = ctor.linker
      if (!contentLinkFn) {
        contentLinkFn = ctor.linker = compiler.compile(el, options)
      }
    }
  
    // link phase
    // make sure to link root with prop scope!
    var rootUnlinkFn = rootLinker(this, el, this._scope)
    var contentUnlinkFn = contentLinkFn
      ? contentLinkFn(this, el)
      : compiler.compile(el, options)(this, el)
  
    // register composite unlink function
    // to be called during instance destruction
    this._unlinkFn = function () {
      rootUnlinkFn()
      // passing destroying: true to avoid searching and
      // splicing the directives
      contentUnlinkFn(true)
    }
  
    // finally replace original
    if (options.replace) {
      _.replace(original, el)
    }
  
    this._isCompiled = true
    this._callHook('compiled')
    return el
  }
  
  /**
   * Initialize instance element. Called in the public
   * $mount() method.
   *
   * @param {Element} el
   */
  
  exports._initElement = function (el) {
    if (el instanceof DocumentFragment) {
      this._isFragment = true
      this.$el = this._fragmentStart = el.firstChild
      this._fragmentEnd = el.lastChild
      // set persisted text anchors to empty
      if (this._fragmentStart.nodeType === 3) {
        this._fragmentStart.data = this._fragmentEnd.data = ''
      }
      this._fragment = el
    } else {
      this.$el = el
    }
    this.$el.__vue__ = this
    this._callHook('beforeCompile')
  }
  
  /**
   * Create and bind a directive to an element.
   *
   * @param {String} name - directive name
   * @param {Node} node   - target node
   * @param {Object} desc - parsed directive descriptor
   * @param {Object} def  - directive definition object
   * @param {Vue} [host] - transclusion host component
   * @param {Object} [scope] - v-for scope
   * @param {Fragment} [frag] - owner fragment
   */
  
  exports._bindDir = function (descriptor, node, host, scope, frag) {
    this._directives.push(
      new Directive(descriptor, this, node, host, scope, frag)
    )
  }
  
  /**
   * Teardown an instance, unobserves the data, unbind all the
   * directives, turn off all the event listeners, etc.
   *
   * @param {Boolean} remove - whether to remove the DOM node.
   * @param {Boolean} deferCleanup - if true, defer cleanup to
   *                                 be called later
   */
  
  exports._destroy = function (remove, deferCleanup) {
    if (this._isBeingDestroyed) {
      if (!deferCleanup) {
        this._cleanup()
      }
      return
    }
    this._callHook('beforeDestroy')
    this._isBeingDestroyed = true
    var i
    // remove self from parent. only necessary
    // if parent is not being destroyed as well.
    var parent = this.$parent
    if (parent && !parent._isBeingDestroyed) {
      parent.$children.$remove(this)
      // unregister ref (remove: true)
      this._updateRef(true)
    }
    // destroy all children.
    i = this.$children.length
    while (i--) {
      this.$children[i].$destroy()
    }
    // teardown props
    if (this._propsUnlinkFn) {
      this._propsUnlinkFn()
    }
    // teardown all directives. this also tearsdown all
    // directive-owned watchers.
    if (this._unlinkFn) {
      this._unlinkFn()
    }
    i = this._watchers.length
    while (i--) {
      this._watchers[i].teardown()
    }
    // remove reference to self on $el
    if (this.$el) {
      this.$el.__vue__ = null
    }
    // remove DOM element
    var self = this
    if (remove && this.$el) {
      this.$remove(function () {
        self._cleanup()
      })
    } else if (!deferCleanup) {
      this._cleanup()
    }
  }
  
  /**
   * Clean up to ensure garbage collection.
   * This is called after the leave transition if there
   * is any.
   */
  
  exports._cleanup = function () {
    if (this._isDestroyed) {
      return
    }
    // remove self from owner fragment
    // do it in cleanup so that we can call $destroy with
    // defer right when a fragment is about to be removed.
    if (this._frag) {
      this._frag.children.$remove(this)
    }
    // remove reference from data ob
    // frozen object may not have observer.
    if (this._data.__ob__) {
      this._data.__ob__.removeVm(this)
    }
    // Clean up references to private properties and other
    // instances. preserve reference to _data so that proxy
    // accessors still work. The only potential side effect
    // here is that mutating the instance after it's destroyed
    // may affect the state of other components that are still
    // observing the same object, but that seems to be a
    // reasonable responsibility for the user rather than
    // always throwing an error on them.
    this.$el =
    this.$parent =
    this.$root =
    this.$children =
    this._watchers =
    this._context =
    this._scope =
    this._directives = null
    // call the last hook...
    this._isDestroyed = true
    this._callHook('destroyed')
    // turn off all instance listeners.
    this.$off()
  }
  
  },{"../compiler":29,"../directive":32,"../util":82}],65:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  
  /**
   * Apply a list of filter (descriptors) to a value.
   * Using plain for loops here because this will be called in
   * the getter of any watcher with filters so it is very
   * performance sensitive.
   *
   * @param {*} value
   * @param {*} [oldValue]
   * @param {Array} filters
   * @param {Boolean} write
   * @return {*}
   */
  
  exports._applyFilters = function (value, oldValue, filters, write) {
    var filter, fn, args, arg, offset, i, l, j, k
    for (i = 0, l = filters.length; i < l; i++) {
      filter = filters[i]
      fn = _.resolveAsset(this.$options, 'filters', filter.name)
      if (process.env.NODE_ENV !== 'production') {
        _.assertAsset(fn, 'filter', filter.name)
      }
      if (!fn) continue
      fn = write ? fn.write : (fn.read || fn)
      if (typeof fn !== 'function') continue
      args = write ? [value, oldValue] : [value]
      offset = write ? 2 : 1
      if (filter.args) {
        for (j = 0, k = filter.args.length; j < k; j++) {
          arg = filter.args[j]
          args[j + offset] = arg.dynamic
            ? this.$get(arg.value)
            : arg.value
        }
      }
      value = fn.apply(this, args)
    }
    return value
  }
  
  /**
   * Resolve a component, depending on whether the component
   * is defined normally or using an async factory function.
   * Resolves synchronously if already resolved, otherwise
   * resolves asynchronously and caches the resolved
   * constructor on the factory.
   *
   * @param {String} id
   * @param {Function} cb
   */
  
  exports._resolveComponent = function (id, cb) {
    var factory = _.resolveAsset(this.$options, 'components', id)
    if (process.env.NODE_ENV !== 'production') {
      _.assertAsset(factory, 'component', id)
    }
    if (!factory) {
      return
    }
    // async component factory
    if (!factory.options) {
      if (factory.resolved) {
        // cached
        cb(factory.resolved)
      } else if (factory.requested) {
        // pool callbacks
        factory.pendingCallbacks.push(cb)
      } else {
        factory.requested = true
        var cbs = factory.pendingCallbacks = [cb]
        factory(function resolve (res) {
          if (_.isPlainObject(res)) {
            res = _.Vue.extend(res)
          }
          // cache resolved
          factory.resolved = res
          // invoke callbacks
          for (var i = 0, l = cbs.length; i < l; i++) {
            cbs[i](res)
          }
        }, function reject (reason) {
          process.env.NODE_ENV !== 'production' && _.warn(
            'Failed to resolve async component: ' + id + '. ' +
            (reason ? '\nReason: ' + reason : '')
          )
        })
      }
    } else {
      // normal component
      cb(factory)
    }
  }
  
  }).call(this,require('_process'))
  },{"../util":82,"_process":5}],66:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var compiler = require('../compiler')
  var Observer = require('../observer')
  var Dep = require('../observer/dep')
  var Watcher = require('../watcher')
  
  /**
   * Setup the scope of an instance, which contains:
   * - observed data
   * - computed properties
   * - user methods
   * - meta properties
   */
  
  exports._initState = function () {
    this._initProps()
    this._initMeta()
    this._initMethods()
    this._initData()
    this._initComputed()
  }
  
  /**
   * Initialize props.
   */
  
  exports._initProps = function () {
    var options = this.$options
    var el = options.el
    var props = options.props
    if (props && !el) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Props will not be compiled if no `el` option is ' +
        'provided at instantiation.'
      )
    }
    // make sure to convert string selectors into element now
    el = options.el = _.query(el)
    this._propsUnlinkFn = el && el.nodeType === 1 && props
      // props must be linked in proper scope if inside v-for
      ? compiler.compileAndLinkProps(this, el, props, this._scope)
      : null
  }
  
  /**
   * Initialize the data.
   */
  
  exports._initData = function () {
    var propsData = this._data
    var optionsDataFn = this.$options.data
    var optionsData = optionsDataFn && optionsDataFn()
    if (optionsData) {
      this._data = optionsData
      for (var prop in propsData) {
        if (process.env.NODE_ENV !== 'production' &&
            optionsData.hasOwnProperty(prop)) {
          _.warn(
            'Data field "' + prop + '" is already defined ' +
            'as a prop. Use prop default value instead.'
          )
        }
        if (this._props[prop].raw !== null ||
            !optionsData.hasOwnProperty(prop)) {
          _.set(optionsData, prop, propsData[prop])
        }
      }
    }
    var data = this._data
    // proxy data on instance
    var keys = Object.keys(data)
    var i, key
    i = keys.length
    while (i--) {
      key = keys[i]
      this._proxy(key)
    }
    // observe data
    Observer.create(data, this)
  }
  
  /**
   * Swap the instance's $data. Called in $data's setter.
   *
   * @param {Object} newData
   */
  
  exports._setData = function (newData) {
    newData = newData || {}
    var oldData = this._data
    this._data = newData
    var keys, key, i
    // unproxy keys not present in new data
    keys = Object.keys(oldData)
    i = keys.length
    while (i--) {
      key = keys[i]
      if (!(key in newData)) {
        this._unproxy(key)
      }
    }
    // proxy keys not already proxied,
    // and trigger change for changed values
    keys = Object.keys(newData)
    i = keys.length
    while (i--) {
      key = keys[i]
      if (!this.hasOwnProperty(key)) {
        // new property
        this._proxy(key)
      }
    }
    oldData.__ob__.removeVm(this)
    Observer.create(newData, this)
    this._digest()
  }
  
  /**
   * Proxy a property, so that
   * vm.prop === vm._data.prop
   *
   * @param {String} key
   */
  
  exports._proxy = function (key) {
    if (!_.isReserved(key)) {
      // need to store ref to self here
      // because these getter/setters might
      // be called by child scopes via
      // prototype inheritance.
      var self = this
      Object.defineProperty(self, key, {
        configurable: true,
        enumerable: true,
        get: function proxyGetter () {
          return self._data[key]
        },
        set: function proxySetter (val) {
          self._data[key] = val
        }
      })
    }
  }
  
  /**
   * Unproxy a property.
   *
   * @param {String} key
   */
  
  exports._unproxy = function (key) {
    if (!_.isReserved(key)) {
      delete this[key]
    }
  }
  
  /**
   * Force update on every watcher in scope.
   */
  
  exports._digest = function () {
    for (var i = 0, l = this._watchers.length; i < l; i++) {
      this._watchers[i].update(true) // shallow updates
    }
  }
  
  /**
   * Setup computed properties. They are essentially
   * special getter/setters
   */
  
  function noop () {}
  exports._initComputed = function () {
    var computed = this.$options.computed
    if (computed) {
      for (var key in computed) {
        var userDef = computed[key]
        var def = {
          enumerable: true,
          configurable: true
        }
        if (typeof userDef === 'function') {
          def.get = makeComputedGetter(userDef, this)
          def.set = noop
        } else {
          def.get = userDef.get
            ? userDef.cache !== false
              ? makeComputedGetter(userDef.get, this)
              : _.bind(userDef.get, this)
            : noop
          def.set = userDef.set
            ? _.bind(userDef.set, this)
            : noop
        }
        Object.defineProperty(this, key, def)
      }
    }
  }
  
  function makeComputedGetter (getter, owner) {
    var watcher = new Watcher(owner, getter, null, {
      lazy: true
    })
    return function computedGetter () {
      if (watcher.dirty) {
        watcher.evaluate()
      }
      if (Dep.target) {
        watcher.depend()
      }
      return watcher.value
    }
  }
  
  /**
   * Setup instance methods. Methods must be bound to the
   * instance since they might be passed down as a prop to
   * child components.
   */
  
  exports._initMethods = function () {
    var methods = this.$options.methods
    if (methods) {
      for (var key in methods) {
        this[key] = _.bind(methods[key], this)
      }
    }
  }
  
  /**
   * Initialize meta information like $index, $key & $value.
   */
  
  exports._initMeta = function () {
    var metas = this.$options._meta
    if (metas) {
      for (var key in metas) {
        _.defineReactive(this, key, metas[key])
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../compiler":29,"../observer":69,"../observer/dep":68,"../util":82,"../watcher":86,"_process":5}],67:[function(require,module,exports){
  var _ = require('../util')
  var arrayProto = Array.prototype
  var arrayMethods = Object.create(arrayProto)
  
  /**
   * Intercept mutating methods and emit events
   */
  
  ;[
    'push',
    'pop',
    'shift',
    'unshift',
    'splice',
    'sort',
    'reverse'
  ]
  .forEach(function (method) {
    // cache original method
    var original = arrayProto[method]
    _.define(arrayMethods, method, function mutator () {
      // avoid leaking arguments:
      // http://jsperf.com/closure-with-arguments
      var i = arguments.length
      var args = new Array(i)
      while (i--) {
        args[i] = arguments[i]
      }
      var result = original.apply(this, args)
      var ob = this.__ob__
      var inserted
      switch (method) {
        case 'push':
          inserted = args
          break
        case 'unshift':
          inserted = args
          break
        case 'splice':
          inserted = args.slice(2)
          break
      }
      if (inserted) ob.observeArray(inserted)
      // notify change
      ob.dep.notify()
      return result
    })
  })
  
  /**
   * Swap the element at the given index with a new value
   * and emits corresponding event.
   *
   * @param {Number} index
   * @param {*} val
   * @return {*} - replaced element
   */
  
  _.define(
    arrayProto,
    '$set',
    function $set (index, val) {
      if (index >= this.length) {
        this.length = index + 1
      }
      return this.splice(index, 1, val)[0]
    }
  )
  
  /**
   * Convenience method to remove the element at given index.
   *
   * @param {Number} index
   * @param {*} val
   */
  
  _.define(
    arrayProto,
    '$remove',
    function $remove (item) {
      /* istanbul ignore if */
      if (!this.length) return
      var index = _.indexOf(this, item)
      if (index > -1) {
        return this.splice(index, 1)
      }
    }
  )
  
  module.exports = arrayMethods
  
  },{"../util":82}],68:[function(require,module,exports){
  var _ = require('../util')
  var uid = 0
  
  /**
   * A dep is an observable that can have multiple
   * directives subscribing to it.
   *
   * @constructor
   */
  
  function Dep () {
    this.id = uid++
    this.subs = []
  }
  
  // the current target watcher being evaluated.
  // this is globally unique because there could be only one
  // watcher being evaluated at any time.
  Dep.target = null
  
  /**
   * Add a directive subscriber.
   *
   * @param {Directive} sub
   */
  
  Dep.prototype.addSub = function (sub) {
    this.subs.push(sub)
  }
  
  /**
   * Remove a directive subscriber.
   *
   * @param {Directive} sub
   */
  
  Dep.prototype.removeSub = function (sub) {
    this.subs.$remove(sub)
  }
  
  /**
   * Add self as a dependency to the target watcher.
   */
  
  Dep.prototype.depend = function () {
    Dep.target.addDep(this)
  }
  
  /**
   * Notify all subscribers of a new value.
   */
  
  Dep.prototype.notify = function () {
    // stablize the subscriber list first
    var subs = _.toArray(this.subs)
    for (var i = 0, l = subs.length; i < l; i++) {
      subs[i].update()
    }
  }
  
  module.exports = Dep
  
  },{"../util":82}],69:[function(require,module,exports){
  var _ = require('../util')
  var config = require('../config')
  var Dep = require('./dep')
  var arrayMethods = require('./array')
  var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
  
  /**
   * Observer class that are attached to each observed
   * object. Once attached, the observer converts target
   * object's property keys into getter/setters that
   * collect dependencies and dispatches updates.
   *
   * @param {Array|Object} value
   * @constructor
   */
  
  function Observer (value) {
    this.value = value
    this.dep = new Dep()
    _.define(value, '__ob__', this)
    if (_.isArray(value)) {
      var augment = _.hasProto
        ? protoAugment
        : copyAugment
      augment(value, arrayMethods, arrayKeys)
      this.observeArray(value)
    } else {
      this.walk(value)
    }
  }
  
  // Static methods
  
  /**
   * Attempt to create an observer instance for a value,
   * returns the new observer if successfully observed,
   * or the existing observer if the value already has one.
   *
   * @param {*} value
   * @param {Vue} [vm]
   * @return {Observer|undefined}
   * @static
   */
  
  Observer.create = function (value, vm) {
    if (!value || typeof value !== 'object') {
      return
    }
    var ob
    if (
      Object.prototype.hasOwnProperty.call(value, '__ob__') &&
      value.__ob__ instanceof Observer
    ) {
      ob = value.__ob__
    } else if (
      (_.isArray(value) || _.isPlainObject(value)) &&
      !Object.isFrozen(value) &&
      !value._isVue
    ) {
      ob = new Observer(value)
    }
    if (ob && vm) {
      ob.addVm(vm)
    }
    return ob
  }
  
  // Instance methods
  
  /**
   * Walk through each property and convert them into
   * getter/setters. This method should only be called when
   * value type is Object.
   *
   * @param {Object} obj
   */
  
  Observer.prototype.walk = function (obj) {
    var keys = Object.keys(obj)
    var i = keys.length
    while (i--) {
      this.convert(keys[i], obj[keys[i]])
    }
  }
  
  /**
   * Observe a list of Array items.
   *
   * @param {Array} items
   */
  
  Observer.prototype.observeArray = function (items) {
    var i = items.length
    while (i--) {
      Observer.create(items[i])
    }
  }
  
  /**
   * Convert a property into getter/setter so we can emit
   * the events when the property is accessed/changed.
   *
   * @param {String} key
   * @param {*} val
   */
  
  Observer.prototype.convert = function (key, val) {
    defineReactive(this.value, key, val)
  }
  
  /**
   * Add an owner vm, so that when $set/$delete mutations
   * happen we can notify owner vms to proxy the keys and
   * digest the watchers. This is only called when the object
   * is observed as an instance's root $data.
   *
   * @param {Vue} vm
   */
  
  Observer.prototype.addVm = function (vm) {
    (this.vms || (this.vms = [])).push(vm)
  }
  
  /**
   * Remove an owner vm. This is called when the object is
   * swapped out as an instance's $data object.
   *
   * @param {Vue} vm
   */
  
  Observer.prototype.removeVm = function (vm) {
    this.vms.$remove(vm)
  }
  
  // helpers
  
  /**
   * Augment an target Object or Array by intercepting
   * the prototype chain using __proto__
   *
   * @param {Object|Array} target
   * @param {Object} proto
   */
  
  function protoAugment (target, src) {
    target.__proto__ = src
  }
  
  /**
   * Augment an target Object or Array by defining
   * hidden properties.
   *
   * @param {Object|Array} target
   * @param {Object} proto
   */
  
  function copyAugment (target, src, keys) {
    var i = keys.length
    var key
    while (i--) {
      key = keys[i]
      _.define(target, key, src[key])
    }
  }
  
  /**
   * Define a reactive property on an Object.
   *
   * @param {Object} obj
   * @param {String} key
   * @param {*} val
   */
  
  function defineReactive (obj, key, val) {
    var dep = new Dep()
  
    // cater for pre-defined getter/setters
    var getter, setter
    if (config.convertAllProperties) {
      var property = Object.getOwnPropertyDescriptor(obj, key)
      if (property && property.configurable === false) {
        return
      }
      getter = property && property.get
      setter = property && property.set
    }
  
    var childOb = Observer.create(val)
    Object.defineProperty(obj, key, {
      enumerable: true,
      configurable: true,
      get: function reactiveGetter () {
        var value = getter ? getter.call(obj) : val
        if (Dep.target) {
          dep.depend()
          if (childOb) {
            childOb.dep.depend()
          }
          if (_.isArray(value)) {
            for (var e, i = 0, l = value.length; i < l; i++) {
              e = value[i]
              e && e.__ob__ && e.__ob__.dep.depend()
            }
          }
        }
        return value
      },
      set: function reactiveSetter (newVal) {
        var value = getter ? getter.call(obj) : val
        if (newVal === value) {
          return
        }
        if (setter) {
          setter.call(obj, newVal)
        } else {
          val = newVal
        }
        childOb = Observer.create(newVal)
        dep.notify()
      }
    })
  }
  
  // Attach to the util object so it can be used elsewhere.
  _.defineReactive = defineReactive
  
  module.exports = Observer
  
  },{"../config":31,"../util":82,"./array":67,"./dep":68}],70:[function(require,module,exports){
  var _ = require('../util')
  var Cache = require('../cache')
  var cache = new Cache(1000)
  var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g
  var reservedArgRE = /^in$|^-?\d+/
  
  /**
   * Parser state
   */
  
  var str, dir
  var c, i, l, lastFilterIndex
  var inSingle, inDouble, curly, square, paren
  
  /**
   * Push a filter to the current directive object
   */
  
  function pushFilter () {
    var exp = str.slice(lastFilterIndex, i).trim()
    var filter
    if (exp) {
      filter = {}
      var tokens = exp.match(filterTokenRE)
      filter.name = tokens[0]
      if (tokens.length > 1) {
        filter.args = tokens.slice(1).map(processFilterArg)
      }
    }
    if (filter) {
      (dir.filters = dir.filters || []).push(filter)
    }
    lastFilterIndex = i + 1
  }
  
  /**
   * Check if an argument is dynamic and strip quotes.
   *
   * @param {String} arg
   * @return {Object}
   */
  
  function processFilterArg (arg) {
    if (reservedArgRE.test(arg)) {
      return {
        value: _.toNumber(arg),
        dynamic: false
      }
    } else {
      var stripped = _.stripQuotes(arg)
      var dynamic = stripped === arg
      return {
        value: dynamic ? arg : stripped,
        dynamic: dynamic
      }
    }
  }
  
  /**
   * Parse a directive value and extract the expression
   * and its filters into a descriptor.
   *
   * Example:
   *
   * "a + 1 | uppercase" will yield:
   * {
   *   expression: 'a + 1',
   *   filters: [
   *     { name: 'uppercase', args: null }
   *   ]
   * }
   *
   * @param {String} str
   * @return {Object}
   */
  
  exports.parse = function (s) {
  
    var hit = cache.get(s)
    if (hit) {
      return hit
    }
  
    // reset parser state
    str = s
    inSingle = inDouble = false
    curly = square = paren = 0
    lastFilterIndex = 0
    dir = {}
  
    for (i = 0, l = str.length; i < l; i++) {
      c = str.charCodeAt(i)
      if (inSingle) {
        // check single quote
        if (c === 0x27) inSingle = !inSingle
      } else if (inDouble) {
        // check double quote
        if (c === 0x22) inDouble = !inDouble
      } else if (
        c === 0x7C && // pipe
        str.charCodeAt(i + 1) !== 0x7C &&
        str.charCodeAt(i - 1) !== 0x7C
      ) {
        if (dir.expression == null) {
          // first filter, end of expression
          lastFilterIndex = i + 1
          dir.expression = str.slice(0, i).trim()
        } else {
          // already has filter
          pushFilter()
        }
      } else {
        switch (c) {
          case 0x22: inDouble = true; break // "
          case 0x27: inSingle = true; break // '
          case 0x28: paren++; break         // (
          case 0x29: paren--; break         // )
          case 0x5B: square++; break        // [
          case 0x5D: square--; break        // ]
          case 0x7B: curly++; break         // {
          case 0x7D: curly--; break         // }
        }
      }
    }
  
    if (dir.expression == null) {
      dir.expression = str.slice(0, i).trim()
    } else if (lastFilterIndex !== 0) {
      pushFilter()
    }
  
    cache.put(s, dir)
    return dir
  }
  
  },{"../cache":26,"../util":82}],71:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var Path = require('./path')
  var Cache = require('../cache')
  var expressionCache = new Cache(1000)
  
  var allowedKeywords =
    'Math,Date,this,true,false,null,undefined,Infinity,NaN,' +
    'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' +
    'encodeURIComponent,parseInt,parseFloat'
  var allowedKeywordsRE =
    new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)')
  
  // keywords that don't make sense inside expressions
  var improperKeywords =
    'break,case,class,catch,const,continue,debugger,default,' +
    'delete,do,else,export,extends,finally,for,function,if,' +
    'import,in,instanceof,let,return,super,switch,throw,try,' +
    'var,while,with,yield,enum,await,implements,package,' +
    'proctected,static,interface,private,public'
  var improperKeywordsRE =
    new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)')
  
  var wsRE = /\s/g
  var newlineRE = /\n/g
  var saveRE = /[\{,]\s*[\w\$_]+\s*:|('[^']*'|"[^"]*")|new |typeof |void /g
  var restoreRE = /"(\d+)"/g
  var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/
  var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
  var booleanLiteralRE = /^(true|false)$/
  
  /**
   * Save / Rewrite / Restore
   *
   * When rewriting paths found in an expression, it is
   * possible for the same letter sequences to be found in
   * strings and Object literal property keys. Therefore we
   * remove and store these parts in a temporary array, and
   * restore them after the path rewrite.
   */
  
  var saved = []
  
  /**
   * Save replacer
   *
   * The save regex can match two possible cases:
   * 1. An opening object literal
   * 2. A string
   * If matched as a plain string, we need to escape its
   * newlines, since the string needs to be preserved when
   * generating the function body.
   *
   * @param {String} str
   * @param {String} isString - str if matched as a string
   * @return {String} - placeholder with index
   */
  
  function save (str, isString) {
    var i = saved.length
    saved[i] = isString
      ? str.replace(newlineRE, '\\n')
      : str
    return '"' + i + '"'
  }
  
  /**
   * Path rewrite replacer
   *
   * @param {String} raw
   * @return {String}
   */
  
  function rewrite (raw) {
    var c = raw.charAt(0)
    var path = raw.slice(1)
    if (allowedKeywordsRE.test(path)) {
      return raw
    } else {
      path = path.indexOf('"') > -1
        ? path.replace(restoreRE, restore)
        : path
      return c + 'scope.' + path
    }
  }
  
  /**
   * Restore replacer
   *
   * @param {String} str
   * @param {String} i - matched save index
   * @return {String}
   */
  
  function restore (str, i) {
    return saved[i]
  }
  
  /**
   * Rewrite an expression, prefixing all path accessors with
   * `scope.` and generate getter/setter functions.
   *
   * @param {String} exp
   * @param {Boolean} needSet
   * @return {Function}
   */
  
  function compileExpFns (exp, needSet) {
    if (improperKeywordsRE.test(exp)) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Avoid using reserved keywords in expression: ' + exp
      )
    }
    // reset state
    saved.length = 0
    // save strings and object literal keys
    var body = exp
      .replace(saveRE, save)
      .replace(wsRE, '')
    // rewrite all paths
    // pad 1 space here becaue the regex matches 1 extra char
    body = (' ' + body)
      .replace(pathReplaceRE, rewrite)
      .replace(restoreRE, restore)
    var getter = makeGetter(body)
    if (getter) {
      return {
        get: getter,
        body: body,
        set: needSet
          ? makeSetter(body)
          : null
      }
    }
  }
  
  /**
   * Compile getter setters for a simple path.
   *
   * @param {String} exp
   * @return {Function}
   */
  
  function compilePathFns (exp) {
    var getter, path
    if (exp.indexOf('[') < 0) {
      // really simple path
      path = exp.split('.')
      path.raw = exp
      getter = Path.compileGetter(path)
    } else {
      // do the real parsing
      path = Path.parse(exp)
      getter = path.get
    }
    return {
      get: getter,
      // always generate setter for simple paths
      set: function (obj, val) {
        Path.set(obj, path, val)
      }
    }
  }
  
  /**
   * Build a getter function. Requires eval.
   *
   * We isolate the try/catch so it doesn't affect the
   * optimization of the parse function when it is not called.
   *
   * @param {String} body
   * @return {Function|undefined}
   */
  
  function makeGetter (body) {
    try {
      return new Function('scope', 'return ' + body + ';')
    } catch (e) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Invalid expression. ' +
        'Generated function body: ' + body
      )
    }
  }
  
  /**
   * Build a setter function.
   *
   * This is only needed in rare situations like "a[b]" where
   * a settable path requires dynamic evaluation.
   *
   * This setter function may throw error when called if the
   * expression body is not a valid left-hand expression in
   * assignment.
   *
   * @param {String} body
   * @return {Function|undefined}
   */
  
  function makeSetter (body) {
    try {
      return new Function('scope', 'value', body + '=value;')
    } catch (e) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Invalid setter function body: ' + body
      )
    }
  }
  
  /**
   * Check for setter existence on a cache hit.
   *
   * @param {Function} hit
   */
  
  function checkSetter (hit) {
    if (!hit.set) {
      hit.set = makeSetter(hit.body)
    }
  }
  
  /**
   * Parse an expression into re-written getter/setters.
   *
   * @param {String} exp
   * @param {Boolean} needSet
   * @return {Function}
   */
  
  exports.parse = function (exp, needSet) {
    exp = exp.trim()
    // try cache
    var hit = expressionCache.get(exp)
    if (hit) {
      if (needSet) {
        checkSetter(hit)
      }
      return hit
    }
    // we do a simple path check to optimize for them.
    // the check fails valid paths with unusal whitespaces,
    // but that's too rare and we don't care.
    // also skip boolean literals and paths that start with
    // global "Math"
    var res = exports.isSimplePath(exp)
      ? compilePathFns(exp)
      : compileExpFns(exp, needSet)
    expressionCache.put(exp, res)
    return res
  }
  
  /**
   * Check if an expression is a simple path.
   *
   * @param {String} exp
   * @return {Boolean}
   */
  
  exports.isSimplePath = function (exp) {
    return pathTestRE.test(exp) &&
      // don't treat true/false as paths
      !booleanLiteralRE.test(exp) &&
      // Math constants e.g. Math.PI, Math.E etc.
      exp.slice(0, 5) !== 'Math.'
  }
  
  }).call(this,require('_process'))
  },{"../cache":26,"../util":82,"./path":72,"_process":5}],72:[function(require,module,exports){
  (function (process){
  var _ = require('../util')
  var Cache = require('../cache')
  var pathCache = new Cache(1000)
  var identRE = exports.identRE = /^[$_a-zA-Z]+[\w$]*$/
  
  // actions
  var APPEND = 0
  var PUSH = 1
  
  // states
  var BEFORE_PATH = 0
  var IN_PATH = 1
  var BEFORE_IDENT = 2
  var IN_IDENT = 3
  var BEFORE_ELEMENT = 4
  var AFTER_ZERO = 5
  var IN_INDEX = 6
  var IN_SINGLE_QUOTE = 7
  var IN_DOUBLE_QUOTE = 8
  var IN_SUB_PATH = 9
  var AFTER_ELEMENT = 10
  var AFTER_PATH = 11
  var ERROR = 12
  
  var pathStateMachine = []
  
  pathStateMachine[BEFORE_PATH] = {
    'ws': [BEFORE_PATH],
    'ident': [IN_IDENT, APPEND],
    '[': [BEFORE_ELEMENT],
    'eof': [AFTER_PATH]
  }
  
  pathStateMachine[IN_PATH] = {
    'ws': [IN_PATH],
    '.': [BEFORE_IDENT],
    '[': [BEFORE_ELEMENT],
    'eof': [AFTER_PATH]
  }
  
  pathStateMachine[BEFORE_IDENT] = {
    'ws': [BEFORE_IDENT],
    'ident': [IN_IDENT, APPEND]
  }
  
  pathStateMachine[IN_IDENT] = {
    'ident': [IN_IDENT, APPEND],
    '0': [IN_IDENT, APPEND],
    'number': [IN_IDENT, APPEND],
    'ws': [IN_PATH, PUSH],
    '.': [BEFORE_IDENT, PUSH],
    '[': [BEFORE_ELEMENT, PUSH],
    'eof': [AFTER_PATH, PUSH]
  }
  
  pathStateMachine[BEFORE_ELEMENT] = {
    'ws': [BEFORE_ELEMENT],
    '0': [AFTER_ZERO, APPEND],
    'number': [IN_INDEX, APPEND],
    "'": [IN_SINGLE_QUOTE, APPEND, ''],
    '"': [IN_DOUBLE_QUOTE, APPEND, ''],
    'ident': [IN_SUB_PATH, APPEND, '*']
  }
  
  pathStateMachine[AFTER_ZERO] = {
    'ws': [AFTER_ELEMENT, PUSH],
    ']': [IN_PATH, PUSH]
  }
  
  pathStateMachine[IN_INDEX] = {
    '0': [IN_INDEX, APPEND],
    'number': [IN_INDEX, APPEND],
    'ws': [AFTER_ELEMENT],
    ']': [IN_PATH, PUSH]
  }
  
  pathStateMachine[IN_SINGLE_QUOTE] = {
    "'": [AFTER_ELEMENT],
    'eof': ERROR,
    'else': [IN_SINGLE_QUOTE, APPEND]
  }
  
  pathStateMachine[IN_DOUBLE_QUOTE] = {
    '"': [AFTER_ELEMENT],
    'eof': ERROR,
    'else': [IN_DOUBLE_QUOTE, APPEND]
  }
  
  pathStateMachine[IN_SUB_PATH] = {
    'ident': [IN_SUB_PATH, APPEND],
    '0': [IN_SUB_PATH, APPEND],
    'number': [IN_SUB_PATH, APPEND],
    'ws': [AFTER_ELEMENT],
    ']': [IN_PATH, PUSH]
  }
  
  pathStateMachine[AFTER_ELEMENT] = {
    'ws': [AFTER_ELEMENT],
    ']': [IN_PATH, PUSH]
  }
  
  /**
   * Determine the type of a character in a keypath.
   *
   * @param {Char} ch
   * @return {String} type
   */
  
  function getPathCharType (ch) {
    if (ch === undefined) {
      return 'eof'
    }
  
    var code = ch.charCodeAt(0)
  
    switch (code) {
      case 0x5B: // [
      case 0x5D: // ]
      case 0x2E: // .
      case 0x22: // "
      case 0x27: // '
      case 0x30: // 0
        return ch
  
      case 0x5F: // _
      case 0x24: // $
        return 'ident'
  
      case 0x20: // Space
      case 0x09: // Tab
      case 0x0A: // Newline
      case 0x0D: // Return
      case 0xA0:  // No-break space
      case 0xFEFF:  // Byte Order Mark
      case 0x2028:  // Line Separator
      case 0x2029:  // Paragraph Separator
        return 'ws'
    }
  
    // a-z, A-Z
    if (
      (code >= 0x61 && code <= 0x7A) ||
      (code >= 0x41 && code <= 0x5A)
    ) {
      return 'ident'
    }
  
    // 1-9
    if (code >= 0x31 && code <= 0x39) {
      return 'number'
    }
  
    return 'else'
  }
  
  /**
   * Parse a string path into an array of segments
   *
   * @param {String} path
   * @return {Array|undefined}
   */
  
  function parsePath (path) {
    var keys = []
    var index = -1
    var mode = BEFORE_PATH
    var c, newChar, key, type, transition, action, typeMap
  
    var actions = []
    actions[PUSH] = function () {
      if (key === undefined) {
        return
      }
      keys.push(key)
      key = undefined
    }
    actions[APPEND] = function () {
      if (key === undefined) {
        key = newChar
      } else {
        key += newChar
      }
    }
  
    function maybeUnescapeQuote () {
      var nextChar = path[index + 1]
      if ((mode === IN_SINGLE_QUOTE && nextChar === "'") ||
          (mode === IN_DOUBLE_QUOTE && nextChar === '"')) {
        index++
        newChar = nextChar
        actions[APPEND]()
        return true
      }
    }
  
    while (mode != null) {
      index++
      c = path[index]
  
      if (c === '\\' && maybeUnescapeQuote()) {
        continue
      }
  
      type = getPathCharType(c)
      typeMap = pathStateMachine[mode]
      transition = typeMap[type] || typeMap['else'] || ERROR
  
      if (transition === ERROR) {
        return // parse error
      }
  
      mode = transition[0]
      action = actions[transition[1]]
      if (action) {
        newChar = transition[2]
        newChar = newChar === undefined
          ? c
          : newChar === '*'
            ? newChar + c
            : newChar
        action()
      }
  
      if (mode === AFTER_PATH) {
        keys.raw = path
        return keys
      }
    }
  }
  
  /**
   * Format a accessor segment based on its type.
   *
   * @param {String} key
   * @return {Boolean}
   */
  
  function formatAccessor (key) {
    if (identRE.test(key)) { // identifier
      return '.' + key
    } else if (+key === key >>> 0) { // bracket index
      return '[' + key + ']'
    } else if (key.charAt(0) === '*') {
      return '[o' + formatAccessor(key.slice(1)) + ']'
    } else { // bracket string
      return '["' + key.replace(/"/g, '\\"') + '"]'
    }
  }
  
  /**
   * Compiles a getter function with a fixed path.
   * The fixed path getter supresses errors.
   *
   * @param {Array} path
   * @return {Function}
   */
  
  exports.compileGetter = function (path) {
    var body = 'return o' + path.map(formatAccessor).join('')
    return new Function('o', body)
  }
  
  /**
   * External parse that check for a cache hit first
   *
   * @param {String} path
   * @return {Array|undefined}
   */
  
  exports.parse = function (path) {
    var hit = pathCache.get(path)
    if (!hit) {
      hit = parsePath(path)
      if (hit) {
        hit.get = exports.compileGetter(hit)
        pathCache.put(path, hit)
      }
    }
    return hit
  }
  
  /**
   * Get from an object from a path string
   *
   * @param {Object} obj
   * @param {String} path
   */
  
  exports.get = function (obj, path) {
    path = exports.parse(path)
    if (path) {
      return path.get(obj)
    }
  }
  
  /**
   * Warn against setting non-existent root path on a vm.
   */
  
  var warnNonExistent
  if (process.env.NODE_ENV !== 'production') {
    warnNonExistent = function (path) {
      _.warn(
        'You are setting a non-existent path "' + path.raw + '" ' +
        'on a vm instance. Consider pre-initializing the property ' +
        'with the "data" option for more reliable reactivity ' +
        'and better performance.'
      )
    }
  }
  
  /**
   * Set on an object from a path
   *
   * @param {Object} obj
   * @param {String | Array} path
   * @param {*} val
   */
  
  exports.set = function (obj, path, val) {
    var original = obj
    if (typeof path === 'string') {
      path = exports.parse(path)
    }
    if (!path || !_.isObject(obj)) {
      return false
    }
    var last, key
    for (var i = 0, l = path.length; i < l; i++) {
      last = obj
      key = path[i]
      if (key.charAt(0) === '*') {
        key = original[key.slice(1)]
      }
      if (i < l - 1) {
        obj = obj[key]
        if (!_.isObject(obj)) {
          obj = {}
          if (process.env.NODE_ENV !== 'production' && last._isVue) {
            warnNonExistent(path)
          }
          _.set(last, key, obj)
        }
      } else {
        if (_.isArray(obj)) {
          obj.$set(key, val)
        } else if (key in obj) {
          obj[key] = val
        } else {
          if (process.env.NODE_ENV !== 'production' && obj._isVue) {
            warnNonExistent(path)
          }
          _.set(obj, key, val)
        }
      }
    }
    return true
  }
  
  }).call(this,require('_process'))
  },{"../cache":26,"../util":82,"_process":5}],73:[function(require,module,exports){
  var _ = require('../util')
  var Cache = require('../cache')
  var templateCache = new Cache(1000)
  var idSelectorCache = new Cache(1000)
  
  var map = {
    _default: [0, '', ''],
    legend: [1, '<fieldset>', '</fieldset>'],
    tr: [2, '<table><tbody>', '</tbody></table>'],
    col: [
      2,
      '<table><tbody></tbody><colgroup>',
      '</colgroup></table>'
    ]
  }
  
  map.td =
  map.th = [
    3,
    '<table><tbody><tr>',
    '</tr></tbody></table>'
  ]
  
  map.option =
  map.optgroup = [
    1,
    '<select multiple="multiple">',
    '</select>'
  ]
  
  map.thead =
  map.tbody =
  map.colgroup =
  map.caption =
  map.tfoot = [1, '<table>', '</table>']
  
  map.g =
  map.defs =
  map.symbol =
  map.use =
  map.image =
  map.text =
  map.circle =
  map.ellipse =
  map.line =
  map.path =
  map.polygon =
  map.polyline =
  map.rect = [
    1,
    '<svg ' +
      'xmlns="http://www.w3.org/2000/svg" ' +
      'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
      'xmlns:ev="http://www.w3.org/2001/xml-events"' +
      'version="1.1">',
    '</svg>'
  ]
  
  /**
   * Check if a node is a supported template node with a
   * DocumentFragment content.
   *
   * @param {Node} node
   * @return {Boolean}
   */
  
  function isRealTemplate (node) {
    return _.isTemplate(node) &&
      node.content instanceof DocumentFragment
  }
  
  var tagRE = /<([\w:]+)/
  var entityRE = /&\w+;|&#\d+;|&#x[\dA-F]+;/
  
  /**
   * Convert a string template to a DocumentFragment.
   * Determines correct wrapping by tag types. Wrapping
   * strategy found in jQuery & component/domify.
   *
   * @param {String} templateString
   * @return {DocumentFragment}
   */
  
  function stringToFragment (templateString) {
    // try a cache hit first
    var hit = templateCache.get(templateString)
    if (hit) {
      return hit
    }
  
    var frag = document.createDocumentFragment()
    var tagMatch = templateString.match(tagRE)
    var entityMatch = entityRE.test(templateString)
  
    if (!tagMatch && !entityMatch) {
      // text only, return a single text node.
      frag.appendChild(
        document.createTextNode(templateString)
      )
    } else {
  
      var tag = tagMatch && tagMatch[1]
      var wrap = map[tag] || map._default
      var depth = wrap[0]
      var prefix = wrap[1]
      var suffix = wrap[2]
      var node = document.createElement('div')
  
      node.innerHTML = prefix + templateString.trim() + suffix
      while (depth--) {
        node = node.lastChild
      }
  
      var child
      /* eslint-disable no-cond-assign */
      while (child = node.firstChild) {
      /* eslint-enable no-cond-assign */
        frag.appendChild(child)
      }
    }
  
    templateCache.put(templateString, frag)
    return frag
  }
  
  /**
   * Convert a template node to a DocumentFragment.
   *
   * @param {Node} node
   * @return {DocumentFragment}
   */
  
  function nodeToFragment (node) {
    // if its a template tag and the browser supports it,
    // its content is already a document fragment.
    if (isRealTemplate(node)) {
      _.trimNode(node.content)
      return node.content
    }
    // script template
    if (node.tagName === 'SCRIPT') {
      return stringToFragment(node.textContent)
    }
    // normal node, clone it to avoid mutating the original
    var clone = exports.clone(node)
    var frag = document.createDocumentFragment()
    var child
    /* eslint-disable no-cond-assign */
    while (child = clone.firstChild) {
    /* eslint-enable no-cond-assign */
      frag.appendChild(child)
    }
    _.trimNode(frag)
    return frag
  }
  
  // Test for the presence of the Safari template cloning bug
  // https://bugs.webkit.org/show_bug.cgi?id=137755
  var hasBrokenTemplate = (function () {
    /* istanbul ignore else */
    if (_.inBrowser) {
      var a = document.createElement('div')
      a.innerHTML = '<template>1</template>'
      return !a.cloneNode(true).firstChild.innerHTML
    } else {
      return false
    }
  })()
  
  // Test for IE10/11 textarea placeholder clone bug
  var hasTextareaCloneBug = (function () {
    /* istanbul ignore else */
    if (_.inBrowser) {
      var t = document.createElement('textarea')
      t.placeholder = 't'
      return t.cloneNode(true).value === 't'
    } else {
      return false
    }
  })()
  
  /**
   * 1. Deal with Safari cloning nested <template> bug by
   *    manually cloning all template instances.
   * 2. Deal with IE10/11 textarea placeholder bug by setting
   *    the correct value after cloning.
   *
   * @param {Element|DocumentFragment} node
   * @return {Element|DocumentFragment}
   */
  
  exports.clone = function (node) {
    if (!node.querySelectorAll) {
      return node.cloneNode()
    }
    var res = node.cloneNode(true)
    var i, original, cloned
    /* istanbul ignore if */
    if (hasBrokenTemplate) {
      var clone = res
      if (isRealTemplate(node)) {
        node = node.content
        clone = res.content
      }
      original = node.querySelectorAll('template')
      if (original.length) {
        cloned = clone.querySelectorAll('template')
        i = cloned.length
        while (i--) {
          cloned[i].parentNode.replaceChild(
            exports.clone(original[i]),
            cloned[i]
          )
        }
      }
    }
    /* istanbul ignore if */
    if (hasTextareaCloneBug) {
      if (node.tagName === 'TEXTAREA') {
        res.value = node.value
      } else {
        original = node.querySelectorAll('textarea')
        if (original.length) {
          cloned = res.querySelectorAll('textarea')
          i = cloned.length
          while (i--) {
            cloned[i].value = original[i].value
          }
        }
      }
    }
    return res
  }
  
  /**
   * Process the template option and normalizes it into a
   * a DocumentFragment that can be used as a partial or a
   * instance template.
   *
   * @param {*} template
   *    Possible values include:
   *    - DocumentFragment object
   *    - Node object of type Template
   *    - id selector: '#some-template-id'
   *    - template string: '<div><span>{{msg}}</span></div>'
   * @param {Boolean} clone
   * @param {Boolean} noSelector
   * @return {DocumentFragment|undefined}
   */
  
  exports.parse = function (template, clone, noSelector) {
    var node, frag
  
    // if the template is already a document fragment,
    // do nothing
    if (template instanceof DocumentFragment) {
      _.trimNode(template)
      return clone
        ? exports.clone(template)
        : template
    }
  
    if (typeof template === 'string') {
      // id selector
      if (!noSelector && template.charAt(0) === '#') {
        // id selector can be cached too
        frag = idSelectorCache.get(template)
        if (!frag) {
          node = document.getElementById(template.slice(1))
          if (node) {
            frag = nodeToFragment(node)
            // save selector to cache
            idSelectorCache.put(template, frag)
          }
        }
      } else {
        // normal string template
        frag = stringToFragment(template)
      }
    } else if (template.nodeType) {
      // a direct node
      frag = nodeToFragment(template)
    }
  
    return frag && clone
      ? exports.clone(frag)
      : frag
  }
  
  },{"../cache":26,"../util":82}],74:[function(require,module,exports){
  var Cache = require('../cache')
  var config = require('../config')
  var dirParser = require('./directive')
  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
  var cache, tagRE, htmlRE
  
  /**
   * Escape a string so it can be used in a RegExp
   * constructor.
   *
   * @param {String} str
   */
  
  function escapeRegex (str) {
    return str.replace(regexEscapeRE, '\\$&')
  }
  
  exports.compileRegex = function () {
    var open = escapeRegex(config.delimiters[0])
    var close = escapeRegex(config.delimiters[1])
    var unsafeOpen = escapeRegex(config.unsafeDelimiters[0])
    var unsafeClose = escapeRegex(config.unsafeDelimiters[1])
    tagRE = new RegExp(
      unsafeOpen + '(.+?)' + unsafeClose + '|' +
      open + '(.+?)' + close,
      'g'
    )
    htmlRE = new RegExp(
      '^' + unsafeOpen + '.*' + unsafeClose + '$'
    )
    // reset cache
    cache = new Cache(1000)
  }
  
  /**
   * Parse a template text string into an array of tokens.
   *
   * @param {String} text
   * @return {Array<Object> | null}
   *               - {String} type
   *               - {String} value
   *               - {Boolean} [html]
   *               - {Boolean} [oneTime]
   */
  
  exports.parse = function (text) {
    if (!cache) {
      exports.compileRegex()
    }
    var hit = cache.get(text)
    if (hit) {
      return hit
    }
    text = text.replace(/\n/g, '')
    if (!tagRE.test(text)) {
      return null
    }
    var tokens = []
    var lastIndex = tagRE.lastIndex = 0
    var match, index, html, value, first, oneTime
    /* eslint-disable no-cond-assign */
    while (match = tagRE.exec(text)) {
    /* eslint-enable no-cond-assign */
      index = match.index
      // push text token
      if (index > lastIndex) {
        tokens.push({
          value: text.slice(lastIndex, index)
        })
      }
      // tag token
      html = htmlRE.test(match[0])
      value = html ? match[1] : match[2]
      first = value.charCodeAt(0)
      oneTime = first === 42 // *
      value = oneTime
        ? value.slice(1)
        : value
      tokens.push({
        tag: true,
        value: value.trim(),
        html: html,
        oneTime: oneTime
      })
      lastIndex = index + match[0].length
    }
    if (lastIndex < text.length) {
      tokens.push({
        value: text.slice(lastIndex)
      })
    }
    cache.put(text, tokens)
    return tokens
  }
  
  /**
   * Format a list of tokens into an expression.
   * e.g. tokens parsed from 'a {{b}} c' can be serialized
   * into one single expression as '"a " + b + " c"'.
   *
   * @param {Array} tokens
   * @return {String}
   */
  
  exports.tokensToExp = function (tokens) {
    if (tokens.length > 1) {
      return tokens.map(function (token) {
        return formatToken(token)
      }).join('+')
    } else {
      return formatToken(tokens[0], true)
    }
  }
  
  /**
   * Format a single token.
   *
   * @param {Object} token
   * @param {Boolean} single
   * @return {String}
   */
  
  function formatToken (token, single) {
    return token.tag
      ? inlineFilters(token.value, single)
      : '"' + token.value + '"'
  }
  
  /**
   * For an attribute with multiple interpolation tags,
   * e.g. attr="some-{{thing | filter}}", in order to combine
   * the whole thing into a single watchable expression, we
   * have to inline those filters. This function does exactly
   * that. This is a bit hacky but it avoids heavy changes
   * to directive parser and watcher mechanism.
   *
   * @param {String} exp
   * @param {Boolean} single
   * @return {String}
   */
  
  var filterRE = /[^|]\|[^|]/
  function inlineFilters (exp, single) {
    if (!filterRE.test(exp)) {
      return single
        ? exp
        : '(' + exp + ')'
    } else {
      var dir = dirParser.parse(exp)
      if (!dir.filters) {
        return '(' + exp + ')'
      } else {
        return 'this._applyFilters(' +
          dir.expression + // value
          ',null,' +       // oldValue (null for read)
          JSON.stringify(dir.filters) + // filter descriptors
          ',false)'        // write?
      }
    }
  }
  
  },{"../cache":26,"../config":31,"./directive":70}],75:[function(require,module,exports){
  var _ = require('../util')
  
  /**
   * Append with transition.
   *
   * @param {Element} el
   * @param {Element} target
   * @param {Vue} vm
   * @param {Function} [cb]
   */
  
  exports.append = function (el, target, vm, cb) {
    apply(el, 1, function () {
      target.appendChild(el)
    }, vm, cb)
  }
  
  /**
   * InsertBefore with transition.
   *
   * @param {Element} el
   * @param {Element} target
   * @param {Vue} vm
   * @param {Function} [cb]
   */
  
  exports.before = function (el, target, vm, cb) {
    apply(el, 1, function () {
      _.before(el, target)
    }, vm, cb)
  }
  
  /**
   * Remove with transition.
   *
   * @param {Element} el
   * @param {Vue} vm
   * @param {Function} [cb]
   */
  
  exports.remove = function (el, vm, cb) {
    apply(el, -1, function () {
      _.remove(el)
    }, vm, cb)
  }
  
  /**
   * Apply transitions with an operation callback.
   *
   * @param {Element} el
   * @param {Number} direction
   *                  1: enter
   *                 -1: leave
   * @param {Function} op - the actual DOM operation
   * @param {Vue} vm
   * @param {Function} [cb]
   */
  
  var apply = exports.apply = function (el, direction, op, vm, cb) {
    var transition = el.__v_trans
    if (
      !transition ||
      // skip if there are no js hooks and CSS transition is
      // not supported
      (!transition.hooks && !_.transitionEndEvent) ||
      // skip transitions for initial compile
      !vm._isCompiled ||
      // if the vm is being manipulated by a parent directive
      // during the parent's compilation phase, skip the
      // animation.
      (vm.$parent && !vm.$parent._isCompiled)
    ) {
      op()
      if (cb) cb()
      return
    }
    var action = direction > 0 ? 'enter' : 'leave'
    transition[action](op, cb)
  }
  
  },{"../util":82}],76:[function(require,module,exports){
  var _ = require('../util')
  var queue = []
  var queued = false
  
  /**
   * Push a job into the queue.
   *
   * @param {Function} job
   */
  
  exports.push = function (job) {
    queue.push(job)
    if (!queued) {
      queued = true
      _.nextTick(flush)
    }
  }
  
  /**
   * Flush the queue, and do one forced reflow before
   * triggering transitions.
   */
  
  function flush () {
    // Force layout
    var f = document.documentElement.offsetHeight
    for (var i = 0; i < queue.length; i++) {
      queue[i]()
    }
    queue = []
    queued = false
    // dummy return, so js linters don't complain about
    // unused variable f
    return f
  }
  
  },{"../util":82}],77:[function(require,module,exports){
  var _ = require('../util')
  var queue = require('./queue')
  var addClass = _.addClass
  var removeClass = _.removeClass
  var transitionEndEvent = _.transitionEndEvent
  var animationEndEvent = _.animationEndEvent
  var transDurationProp = _.transitionProp + 'Duration'
  var animDurationProp = _.animationProp + 'Duration'
  
  var TYPE_TRANSITION = 1
  var TYPE_ANIMATION = 2
  
  /**
   * A Transition object that encapsulates the state and logic
   * of the transition.
   *
   * @param {Element} el
   * @param {String} id
   * @param {Object} hooks
   * @param {Vue} vm
   */
  
  function Transition (el, id, hooks, vm) {
    this.id = id
    this.el = el
    this.enterClass = id + '-enter'
    this.leaveClass = id + '-leave'
    this.hooks = hooks
    this.vm = vm
    // async state
    this.pendingCssEvent =
    this.pendingCssCb =
    this.cancel =
    this.pendingJsCb =
    this.op =
    this.cb = null
    this.justEntered = false
    this.entered = this.left = false
    this.typeCache = {}
    // bind
    var self = this
    ;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone']
      .forEach(function (m) {
        self[m] = _.bind(self[m], self)
      })
  }
  
  var p = Transition.prototype
  
  /**
   * Start an entering transition.
   *
   * 1. enter transition triggered
   * 2. call beforeEnter hook
   * 3. add enter class
   * 4. insert/show element
   * 5. call enter hook (with possible explicit js callback)
   * 6. reflow
   * 7. based on transition type:
   *    - transition:
   *        remove class now, wait for transitionend,
   *        then done if there's no explicit js callback.
   *    - animation:
   *        wait for animationend, remove class,
   *        then done if there's no explicit js callback.
   *    - no css transition:
   *        done now if there's no explicit js callback.
   * 8. wait for either done or js callback, then call
   *    afterEnter hook.
   *
   * @param {Function} op - insert/show the element
   * @param {Function} [cb]
   */
  
  p.enter = function (op, cb) {
    this.cancelPending()
    this.callHook('beforeEnter')
    this.cb = cb
    addClass(this.el, this.enterClass)
    op()
    this.entered = false
    this.callHookWithCb('enter')
    if (this.entered) {
      return // user called done synchronously.
    }
    this.cancel = this.hooks && this.hooks.enterCancelled
    queue.push(this.enterNextTick)
  }
  
  /**
   * The "nextTick" phase of an entering transition, which is
   * to be pushed into a queue and executed after a reflow so
   * that removing the class can trigger a CSS transition.
   */
  
  p.enterNextTick = function () {
  
    // Important hack:
    // in Chrome, if a just-entered element is applied the
    // leave class while its interpolated property still has
    // a very small value (within one frame), Chrome will
    // skip the leave transition entirely and not firing the
    // transtionend event. Therefore we need to protected
    // against such cases using a one-frame timeout.
    this.justEntered = true
    var self = this
    setTimeout(function () {
      self.justEntered = false
    }, 17)
  
    var enterDone = this.enterDone
    var type = this.getCssTransitionType(this.enterClass)
    if (!this.pendingJsCb) {
      if (type === TYPE_TRANSITION) {
        // trigger transition by removing enter class now
        removeClass(this.el, this.enterClass)
        this.setupCssCb(transitionEndEvent, enterDone)
      } else if (type === TYPE_ANIMATION) {
        this.setupCssCb(animationEndEvent, enterDone)
      } else {
        enterDone()
      }
    } else if (type === TYPE_TRANSITION) {
      removeClass(this.el, this.enterClass)
    }
  }
  
  /**
   * The "cleanup" phase of an entering transition.
   */
  
  p.enterDone = function () {
    this.entered = true
    this.cancel = this.pendingJsCb = null
    removeClass(this.el, this.enterClass)
    this.callHook('afterEnter')
    if (this.cb) this.cb()
  }
  
  /**
   * Start a leaving transition.
   *
   * 1. leave transition triggered.
   * 2. call beforeLeave hook
   * 3. add leave class (trigger css transition)
   * 4. call leave hook (with possible explicit js callback)
   * 5. reflow if no explicit js callback is provided
   * 6. based on transition type:
   *    - transition or animation:
   *        wait for end event, remove class, then done if
   *        there's no explicit js callback.
   *    - no css transition:
   *        done if there's no explicit js callback.
   * 7. wait for either done or js callback, then call
   *    afterLeave hook.
   *
   * @param {Function} op - remove/hide the element
   * @param {Function} [cb]
   */
  
  p.leave = function (op, cb) {
    this.cancelPending()
    this.callHook('beforeLeave')
    this.op = op
    this.cb = cb
    addClass(this.el, this.leaveClass)
    this.left = false
    this.callHookWithCb('leave')
    if (this.left) {
      return // user called done synchronously.
    }
    this.cancel = this.hooks && this.hooks.leaveCancelled
    // only need to handle leaveDone if
    // 1. the transition is already done (synchronously called
    //    by the user, which causes this.op set to null)
    // 2. there's no explicit js callback
    if (this.op && !this.pendingJsCb) {
      // if a CSS transition leaves immediately after enter,
      // the transitionend event never fires. therefore we
      // detect such cases and end the leave immediately.
      if (this.justEntered) {
        this.leaveDone()
      } else {
        queue.push(this.leaveNextTick)
      }
    }
  }
  
  /**
   * The "nextTick" phase of a leaving transition.
   */
  
  p.leaveNextTick = function () {
    var type = this.getCssTransitionType(this.leaveClass)
    if (type) {
      var event = type === TYPE_TRANSITION
        ? transitionEndEvent
        : animationEndEvent
      this.setupCssCb(event, this.leaveDone)
    } else {
      this.leaveDone()
    }
  }
  
  /**
   * The "cleanup" phase of a leaving transition.
   */
  
  p.leaveDone = function () {
    this.left = true
    this.cancel = this.pendingJsCb = null
    this.op()
    removeClass(this.el, this.leaveClass)
    this.callHook('afterLeave')
    if (this.cb) this.cb()
    this.op = null
  }
  
  /**
   * Cancel any pending callbacks from a previously running
   * but not finished transition.
   */
  
  p.cancelPending = function () {
    this.op = this.cb = null
    var hasPending = false
    if (this.pendingCssCb) {
      hasPending = true
      _.off(this.el, this.pendingCssEvent, this.pendingCssCb)
      this.pendingCssEvent = this.pendingCssCb = null
    }
    if (this.pendingJsCb) {
      hasPending = true
      this.pendingJsCb.cancel()
      this.pendingJsCb = null
    }
    if (hasPending) {
      removeClass(this.el, this.enterClass)
      removeClass(this.el, this.leaveClass)
    }
    if (this.cancel) {
      this.cancel.call(this.vm, this.el)
      this.cancel = null
    }
  }
  
  /**
   * Call a user-provided synchronous hook function.
   *
   * @param {String} type
   */
  
  p.callHook = function (type) {
    if (this.hooks && this.hooks[type]) {
      this.hooks[type].call(this.vm, this.el)
    }
  }
  
  /**
   * Call a user-provided, potentially-async hook function.
   * We check for the length of arguments to see if the hook
   * expects a `done` callback. If true, the transition's end
   * will be determined by when the user calls that callback;
   * otherwise, the end is determined by the CSS transition or
   * animation.
   *
   * @param {String} type
   */
  
  p.callHookWithCb = function (type) {
    var hook = this.hooks && this.hooks[type]
    if (hook) {
      if (hook.length > 1) {
        this.pendingJsCb = _.cancellable(this[type + 'Done'])
      }
      hook.call(this.vm, this.el, this.pendingJsCb)
    }
  }
  
  /**
   * Get an element's transition type based on the
   * calculated styles.
   *
   * @param {String} className
   * @return {Number}
   */
  
  p.getCssTransitionType = function (className) {
    /* istanbul ignore if */
    if (
      !transitionEndEvent ||
      // skip CSS transitions if page is not visible -
      // this solves the issue of transitionend events not
      // firing until the page is visible again.
      // pageVisibility API is supported in IE10+, same as
      // CSS transitions.
      document.hidden ||
      // explicit js-only transition
      (this.hooks && this.hooks.css === false) ||
      // element is hidden
      isHidden(this.el)
    ) {
      return
    }
    var type = this.typeCache[className]
    if (type) return type
    var inlineStyles = this.el.style
    var computedStyles = window.getComputedStyle(this.el)
    var transDuration =
      inlineStyles[transDurationProp] ||
      computedStyles[transDurationProp]
    if (transDuration && transDuration !== '0s') {
      type = TYPE_TRANSITION
    } else {
      var animDuration =
        inlineStyles[animDurationProp] ||
        computedStyles[animDurationProp]
      if (animDuration && animDuration !== '0s') {
        type = TYPE_ANIMATION
      }
    }
    if (type) {
      this.typeCache[className] = type
    }
    return type
  }
  
  /**
   * Setup a CSS transitionend/animationend callback.
   *
   * @param {String} event
   * @param {Function} cb
   */
  
  p.setupCssCb = function (event, cb) {
    this.pendingCssEvent = event
    var self = this
    var el = this.el
    var onEnd = this.pendingCssCb = function (e) {
      if (e.target === el) {
        _.off(el, event, onEnd)
        self.pendingCssEvent = self.pendingCssCb = null
        if (!self.pendingJsCb && cb) {
          cb()
        }
      }
    }
    _.on(el, event, onEnd)
  }
  
  /**
   * Check if an element is hidden - in that case we can just
   * skip the transition alltogether.
   *
   * @param {Element} el
   * @return {Boolean}
   */
  
  function isHidden (el) {
    return !(
      el.offsetWidth ||
      el.offsetHeight ||
      el.getClientRects().length
    )
  }
  
  module.exports = Transition
  
  },{"../util":82,"./queue":76}],78:[function(require,module,exports){
  (function (process){
  var _ = require('./index')
  
  /**
   * Check if an element is a component, if yes return its
   * component id.
   *
   * @param {Element} el
   * @param {Object} options
   * @return {Object|undefined}
   */
  
  exports.commonTagRE = /^(div|p|span|img|a|b|i|br|ul|ol|li|h1|h2|h3|h4|h5|h6|code|pre|table|th|td|tr|form|label|input|select|option|nav|article|section|header|footer)$/
  exports.checkComponent = function (el, options) {
    var tag = el.tagName.toLowerCase()
    var hasAttrs = el.hasAttributes()
    if (!exports.commonTagRE.test(tag) && tag !== 'component') {
      if (_.resolveAsset(options, 'components', tag)) {
        return { id: tag }
      } else {
        var is = hasAttrs && getIsBinding(el)
        if (is) {
          return is
        } else if (process.env.NODE_ENV !== 'production') {
          if (
            tag.indexOf('-') > -1 ||
            (
              /HTMLUnknownElement/.test(el.toString()) &&
              // Chrome returns unknown for several HTML5 elements.
              // https://code.google.com/p/chromium/issues/detail?id=540526
              !/^(data|time|rtc|rb)$/.test(tag)
            )
          ) {
            _.warn(
              'Unknown custom element: <' + tag + '> - did you ' +
              'register the component correctly?'
            )
          }
        }
      }
    } else if (hasAttrs) {
      return getIsBinding(el)
    }
  }
  
  /**
   * Get "is" binding from an element.
   *
   * @param {Element} el
   * @return {Object|undefined}
   */
  
  function getIsBinding (el) {
    // dynamic syntax
    var exp = _.attr(el, 'is')
    if (exp != null) {
      return { id: exp }
    } else {
      exp = _.getBindAttr(el, 'is')
      if (exp != null) {
        return { id: exp, dynamic: true }
      }
    }
  }
  
  /**
   * Set a prop's initial value on a vm and its data object.
   *
   * @param {Vue} vm
   * @param {Object} prop
   * @param {*} value
   */
  
  exports.initProp = function (vm, prop, value) {
    if (exports.assertProp(prop, value)) {
      var key = prop.path
      vm[key] = vm._data[key] = value
    }
  }
  
  /**
   * Assert whether a prop is valid.
   *
   * @param {Object} prop
   * @param {*} value
   */
  
  exports.assertProp = function (prop, value) {
    // if a prop is not provided and is not required,
    // skip the check.
    if (prop.raw === null && !prop.required) {
      return true
    }
    var options = prop.options
    var type = options.type
    var valid = true
    var expectedType
    if (type) {
      if (type === String) {
        expectedType = 'string'
        valid = typeof value === expectedType
      } else if (type === Number) {
        expectedType = 'number'
        valid = typeof value === 'number'
      } else if (type === Boolean) {
        expectedType = 'boolean'
        valid = typeof value === 'boolean'
      } else if (type === Function) {
        expectedType = 'function'
        valid = typeof value === 'function'
      } else if (type === Object) {
        expectedType = 'object'
        valid = _.isPlainObject(value)
      } else if (type === Array) {
        expectedType = 'array'
        valid = _.isArray(value)
      } else {
        valid = value instanceof type
      }
    }
    if (!valid) {
      process.env.NODE_ENV !== 'production' && _.warn(
        'Invalid prop: type check failed for ' +
        prop.path + '="' + prop.raw + '".' +
        ' Expected ' + formatType(expectedType) +
        ', got ' + formatValue(value) + '.'
      )
      return false
    }
    var validator = options.validator
    if (validator) {
      if (!validator.call(null, value)) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'Invalid prop: custom validator check failed for ' +
          prop.path + '="' + prop.raw + '"'
        )
        return false
      }
    }
    return true
  }
  
  function formatType (val) {
    return val
      ? val.charAt(0).toUpperCase() + val.slice(1)
      : 'custom type'
  }
  
  function formatValue (val) {
    return Object.prototype.toString.call(val).slice(8, -1)
  }
  
  }).call(this,require('_process'))
  },{"./index":82,"_process":5}],79:[function(require,module,exports){
  (function (process){
  /**
   * Enable debug utilities.
   */
  
  if (process.env.NODE_ENV !== 'production') {
  
    var config = require('../config')
    var hasConsole = typeof console !== 'undefined'
  
    /**
     * Log a message.
     *
     * @param {String} msg
     */
  
    exports.log = function (msg) {
      if (hasConsole && config.debug) {
        console.log('[Vue info]: ' + msg)
      }
    }
  
    /**
     * We've got a problem here.
     *
     * @param {String} msg
     */
  
    exports.warn = function (msg, e) {
      if (hasConsole && (!config.silent || config.debug)) {
        console.warn('[Vue warn]: ' + msg)
        /* istanbul ignore if */
        if (config.debug) {
          console.warn((e || new Error('Warning Stack Trace')).stack)
        }
      }
    }
  
    /**
     * Assert asset exists
     */
  
    exports.assertAsset = function (val, type, id) {
      if (!val) {
        exports.warn('Failed to resolve ' + type + ': ' + id)
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../config":31,"_process":5}],80:[function(require,module,exports){
  (function (process){
  var _ = require('./index')
  var config = require('../config')
  var transition = require('../transition')
  
  /**
   * Query an element selector if it's not an element already.
   *
   * @param {String|Element} el
   * @return {Element}
   */
  
  exports.query = function (el) {
    if (typeof el === 'string') {
      var selector = el
      el = document.querySelector(el)
      if (!el) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'Cannot find element: ' + selector
        )
      }
    }
    return el
  }
  
  /**
   * Check if a node is in the document.
   * Note: document.documentElement.contains should work here
   * but always returns false for comment nodes in phantomjs,
   * making unit tests difficult. This is fixed by doing the
   * contains() check on the node's parentNode instead of
   * the node itself.
   *
   * @param {Node} node
   * @return {Boolean}
   */
  
  exports.inDoc = function (node) {
    var doc = document.documentElement
    var parent = node && node.parentNode
    return doc === node ||
      doc === parent ||
      !!(parent && parent.nodeType === 1 && (doc.contains(parent)))
  }
  
  /**
   * Get and remove an attribute from a node.
   *
   * @param {Node} node
   * @param {String} attr
   */
  
  exports.attr = function (node, attr) {
    var val = node.getAttribute(attr)
    if (val !== null) {
      node.removeAttribute(attr)
    }
    return val
  }
  
  /**
   * Get an attribute with colon or v-bind: prefix.
   *
   * @param {Node} node
   * @param {String} name
   * @return {String|null}
   */
  
  exports.getBindAttr = function (node, name) {
    var val = exports.attr(node, ':' + name)
    if (val === null) {
      val = exports.attr(node, 'v-bind:' + name)
    }
    return val
  }
  
  /**
   * Insert el before target
   *
   * @param {Element} el
   * @param {Element} target
   */
  
  exports.before = function (el, target) {
    target.parentNode.insertBefore(el, target)
  }
  
  /**
   * Insert el after target
   *
   * @param {Element} el
   * @param {Element} target
   */
  
  exports.after = function (el, target) {
    if (target.nextSibling) {
      exports.before(el, target.nextSibling)
    } else {
      target.parentNode.appendChild(el)
    }
  }
  
  /**
   * Remove el from DOM
   *
   * @param {Element} el
   */
  
  exports.remove = function (el) {
    el.parentNode.removeChild(el)
  }
  
  /**
   * Prepend el to target
   *
   * @param {Element} el
   * @param {Element} target
   */
  
  exports.prepend = function (el, target) {
    if (target.firstChild) {
      exports.before(el, target.firstChild)
    } else {
      target.appendChild(el)
    }
  }
  
  /**
   * Replace target with el
   *
   * @param {Element} target
   * @param {Element} el
   */
  
  exports.replace = function (target, el) {
    var parent = target.parentNode
    if (parent) {
      parent.replaceChild(el, target)
    }
  }
  
  /**
   * Add event listener shorthand.
   *
   * @param {Element} el
   * @param {String} event
   * @param {Function} cb
   */
  
  exports.on = function (el, event, cb) {
    el.addEventListener(event, cb)
  }
  
  /**
   * Remove event listener shorthand.
   *
   * @param {Element} el
   * @param {String} event
   * @param {Function} cb
   */
  
  exports.off = function (el, event, cb) {
    el.removeEventListener(event, cb)
  }
  
  /**
   * Add class with compatibility for IE & SVG
   *
   * @param {Element} el
   * @param {Strong} cls
   */
  
  exports.addClass = function (el, cls) {
    if (el.classList) {
      el.classList.add(cls)
    } else {
      var cur = ' ' + (el.getAttribute('class') || '') + ' '
      if (cur.indexOf(' ' + cls + ' ') < 0) {
        el.setAttribute('class', (cur + cls).trim())
      }
    }
  }
  
  /**
   * Remove class with compatibility for IE & SVG
   *
   * @param {Element} el
   * @param {Strong} cls
   */
  
  exports.removeClass = function (el, cls) {
    if (el.classList) {
      el.classList.remove(cls)
    } else {
      var cur = ' ' + (el.getAttribute('class') || '') + ' '
      var tar = ' ' + cls + ' '
      while (cur.indexOf(tar) >= 0) {
        cur = cur.replace(tar, ' ')
      }
      el.setAttribute('class', cur.trim())
    }
    if (!el.className) {
      el.removeAttribute('class')
    }
  }
  
  /**
   * Extract raw content inside an element into a temporary
   * container div
   *
   * @param {Element} el
   * @param {Boolean} asFragment
   * @return {Element}
   */
  
  exports.extractContent = function (el, asFragment) {
    var child
    var rawContent
    /* istanbul ignore if */
    if (
      exports.isTemplate(el) &&
      el.content instanceof DocumentFragment
    ) {
      el = el.content
    }
    if (el.hasChildNodes()) {
      exports.trimNode(el)
      rawContent = asFragment
        ? document.createDocumentFragment()
        : document.createElement('div')
      /* eslint-disable no-cond-assign */
      while (child = el.firstChild) {
      /* eslint-enable no-cond-assign */
        rawContent.appendChild(child)
      }
    }
    return rawContent
  }
  
  /**
   * Trim possible empty head/tail textNodes inside a parent.
   *
   * @param {Node} node
   */
  
  exports.trimNode = function (node) {
    trim(node, node.firstChild)
    trim(node, node.lastChild)
  }
  
  function trim (parent, node) {
    if (node && node.nodeType === 3 && !node.data.trim()) {
      parent.removeChild(node)
    }
  }
  
  /**
   * Check if an element is a template tag.
   * Note if the template appears inside an SVG its tagName
   * will be in lowercase.
   *
   * @param {Element} el
   */
  
  exports.isTemplate = function (el) {
    return el.tagName &&
      el.tagName.toLowerCase() === 'template'
  }
  
  /**
   * Create an "anchor" for performing dom insertion/removals.
   * This is used in a number of scenarios:
   * - fragment instance
   * - v-html
   * - v-if
   * - v-for
   * - component
   *
   * @param {String} content
   * @param {Boolean} persist - IE trashes empty textNodes on
   *                            cloneNode(true), so in certain
   *                            cases the anchor needs to be
   *                            non-empty to be persisted in
   *                            templates.
   * @return {Comment|Text}
   */
  
  exports.createAnchor = function (content, persist) {
    var anchor = config.debug
      ? document.createComment(content)
      : document.createTextNode(persist ? ' ' : '')
    anchor.__vue_anchor = true
    return anchor
  }
  
  /**
   * Find a component ref attribute that starts with $.
   *
   * @param {Element} node
   * @return {String|undefined}
   */
  
  var refRE = /^v-ref:/
  exports.findRef = function (node) {
    if (node.hasAttributes()) {
      var attrs = node.attributes
      for (var i = 0, l = attrs.length; i < l; i++) {
        var name = attrs[i].name
        if (refRE.test(name)) {
          return _.camelize(name.replace(refRE, ''))
        }
      }
    }
  }
  
  /**
   * Map a function to a range of nodes .
   *
   * @param {Node} node
   * @param {Node} end
   * @param {Function} op
   */
  
  exports.mapNodeRange = function (node, end, op) {
    var next
    while (node !== end) {
      next = node.nextSibling
      op(node)
      node = next
    }
    op(end)
  }
  
  /**
   * Remove a range of nodes with transition, store
   * the nodes in a fragment with correct ordering,
   * and call callback when done.
   *
   * @param {Node} start
   * @param {Node} end
   * @param {Vue} vm
   * @param {DocumentFragment} frag
   * @param {Function} cb
   */
  
  exports.removeNodeRange = function (start, end, vm, frag, cb) {
    var done = false
    var removed = 0
    var nodes = []
    exports.mapNodeRange(start, end, function (node) {
      if (node === end) done = true
      nodes.push(node)
      transition.remove(node, vm, onRemoved)
    })
    function onRemoved () {
      removed++
      if (done && removed >= nodes.length) {
        for (var i = 0; i < nodes.length; i++) {
          frag.appendChild(nodes[i])
        }
        cb && cb()
      }
    }
  }
  
  }).call(this,require('_process'))
  },{"../config":31,"../transition":75,"./index":82,"_process":5}],81:[function(require,module,exports){
  // can we use __proto__?
  exports.hasProto = '__proto__' in {}
  
  // Browser environment sniffing
  var inBrowser = exports.inBrowser =
    typeof window !== 'undefined' &&
    Object.prototype.toString.call(window) !== '[object Object]'
  
  exports.isIE9 =
    inBrowser &&
    navigator.userAgent.toLowerCase().indexOf('msie 9.0') > 0
  
  exports.isAndroid =
    inBrowser &&
    navigator.userAgent.toLowerCase().indexOf('android') > 0
  
  // Transition property/event sniffing
  if (inBrowser && !exports.isIE9) {
    var isWebkitTrans =
      window.ontransitionend === undefined &&
      window.onwebkittransitionend !== undefined
    var isWebkitAnim =
      window.onanimationend === undefined &&
      window.onwebkitanimationend !== undefined
    exports.transitionProp = isWebkitTrans
      ? 'WebkitTransition'
      : 'transition'
    exports.transitionEndEvent = isWebkitTrans
      ? 'webkitTransitionEnd'
      : 'transitionend'
    exports.animationProp = isWebkitAnim
      ? 'WebkitAnimation'
      : 'animation'
    exports.animationEndEvent = isWebkitAnim
      ? 'webkitAnimationEnd'
      : 'animationend'
  }
  
  /**
   * Defer a task to execute it asynchronously. Ideally this
   * should be executed as a microtask, so we leverage
   * MutationObserver if it's available, and fallback to
   * setTimeout(0).
   *
   * @param {Function} cb
   * @param {Object} ctx
   */
  
  exports.nextTick = (function () {
    var callbacks = []
    var pending = false
    var timerFunc
    function nextTickHandler () {
      pending = false
      var copies = callbacks.slice(0)
      callbacks = []
      for (var i = 0; i < copies.length; i++) {
        copies[i]()
      }
    }
    /* istanbul ignore if */
    if (typeof MutationObserver !== 'undefined') {
      var counter = 1
      var observer = new MutationObserver(nextTickHandler)
      var textNode = document.createTextNode(counter)
      observer.observe(textNode, {
        characterData: true
      })
      timerFunc = function () {
        counter = (counter + 1) % 2
        textNode.data = counter
      }
    } else {
      timerFunc = setTimeout
    }
    return function (cb, ctx) {
      var func = ctx
        ? function () { cb.call(ctx) }
        : cb
      callbacks.push(func)
      if (pending) return
      pending = true
      timerFunc(nextTickHandler, 0)
    }
  })()
  
  },{}],82:[function(require,module,exports){
  var lang = require('./lang')
  var extend = lang.extend
  
  extend(exports, lang)
  extend(exports, require('./env'))
  extend(exports, require('./dom'))
  extend(exports, require('./options'))
  extend(exports, require('./component'))
  extend(exports, require('./debug'))
  
  },{"./component":78,"./debug":79,"./dom":80,"./env":81,"./lang":83,"./options":84}],83:[function(require,module,exports){
  /**
   * Set a property on an object. Adds the new property and
   * triggers change notification if the property doesn't
   * already exist.
   *
   * @param {Object} obj
   * @param {String} key
   * @param {*} val
   * @public
   */
  
  exports.set = function set (obj, key, val) {
    if (obj.hasOwnProperty(key)) {
      obj[key] = val
      return
    }
    if (obj._isVue) {
      set(obj._data, key, val)
      return
    }
    var ob = obj.__ob__
    if (!ob) {
      obj[key] = val
      return
    }
    ob.convert(key, val)
    ob.dep.notify()
    if (ob.vms) {
      var i = ob.vms.length
      while (i--) {
        var vm = ob.vms[i]
        vm._proxy(key)
        vm._digest()
      }
    }
  }
  
  /**
   * Delete a property and trigger change if necessary.
   *
   * @param {Object} obj
   * @param {String} key
   */
  
  exports.delete = function (obj, key) {
    if (!obj.hasOwnProperty(key)) {
      return
    }
    delete obj[key]
    var ob = obj.__ob__
    if (!ob) {
      return
    }
    ob.dep.notify()
    if (ob.vms) {
      var i = ob.vms.length
      while (i--) {
        var vm = ob.vms[i]
        vm._unproxy(key)
        vm._digest()
      }
    }
  }
  
  /**
   * Check if an expression is a literal value.
   *
   * @param {String} exp
   * @return {Boolean}
   */
  
  var literalValueRE = /^\s?(true|false|[\d\.]+|'[^']*'|"[^"]*")\s?$/
  exports.isLiteral = function (exp) {
    return literalValueRE.test(exp)
  }
  
  /**
   * Check if a string starts with $ or _
   *
   * @param {String} str
   * @return {Boolean}
   */
  
  exports.isReserved = function (str) {
    var c = (str + '').charCodeAt(0)
    return c === 0x24 || c === 0x5F
  }
  
  /**
   * Guard text output, make sure undefined outputs
   * empty string
   *
   * @param {*} value
   * @return {String}
   */
  
  exports.toString = function (value) {
    return value == null
      ? ''
      : value.toString()
  }
  
  /**
   * Check and convert possible numeric strings to numbers
   * before setting back to data
   *
   * @param {*} value
   * @return {*|Number}
   */
  
  exports.toNumber = function (value) {
    if (typeof value !== 'string') {
      return value
    } else {
      var parsed = Number(value)
      return isNaN(parsed)
        ? value
        : parsed
    }
  }
  
  /**
   * Convert string boolean literals into real booleans.
   *
   * @param {*} value
   * @return {*|Boolean}
   */
  
  exports.toBoolean = function (value) {
    return value === 'true'
      ? true
      : value === 'false'
        ? false
        : value
  }
  
  /**
   * Strip quotes from a string
   *
   * @param {String} str
   * @return {String | false}
   */
  
  exports.stripQuotes = function (str) {
    var a = str.charCodeAt(0)
    var b = str.charCodeAt(str.length - 1)
    return a === b && (a === 0x22 || a === 0x27)
      ? str.slice(1, -1)
      : str
  }
  
  /**
   * Camelize a hyphen-delmited string.
   *
   * @param {String} str
   * @return {String}
   */
  
  var camelizeRE = /-(\w)/g
  exports.camelize = function (str) {
    return str.replace(camelizeRE, toUpper)
  }
  
  function toUpper (_, c) {
    return c ? c.toUpperCase() : ''
  }
  
  /**
   * Hyphenate a camelCase string.
   *
   * @param {String} str
   * @return {String}
   */
  
  var hyphenateRE = /([a-z\d])([A-Z])/g
  exports.hyphenate = function (str) {
    return str
      .replace(hyphenateRE, '$1-$2')
      .toLowerCase()
  }
  
  /**
   * Converts hyphen/underscore/slash delimitered names into
   * camelized classNames.
   *
   * e.g. my-component => MyComponent
   *      some_else    => SomeElse
   *      some/comp    => SomeComp
   *
   * @param {String} str
   * @return {String}
   */
  
  var classifyRE = /(?:^|[-_\/])(\w)/g
  exports.classify = function (str) {
    return str.replace(classifyRE, toUpper)
  }
  
  /**
   * Simple bind, faster than native
   *
   * @param {Function} fn
   * @param {Object} ctx
   * @return {Function}
   */
  
  exports.bind = function (fn, ctx) {
    return function (a) {
      var l = arguments.length
      return l
        ? l > 1
          ? fn.apply(ctx, arguments)
          : fn.call(ctx, a)
        : fn.call(ctx)
    }
  }
  
  /**
   * Convert an Array-like object to a real Array.
   *
   * @param {Array-like} list
   * @param {Number} [start] - start index
   * @return {Array}
   */
  
  exports.toArray = function (list, start) {
    start = start || 0
    var i = list.length - start
    var ret = new Array(i)
    while (i--) {
      ret[i] = list[i + start]
    }
    return ret
  }
  
  /**
   * Mix properties into target object.
   *
   * @param {Object} to
   * @param {Object} from
   */
  
  exports.extend = function (to, from) {
    var keys = Object.keys(from)
    var i = keys.length
    while (i--) {
      to[keys[i]] = from[keys[i]]
    }
    return to
  }
  
  /**
   * Quick object check - this is primarily used to tell
   * Objects from primitive values when we know the value
   * is a JSON-compliant type.
   *
   * @param {*} obj
   * @return {Boolean}
   */
  
  exports.isObject = function (obj) {
    return obj !== null && typeof obj === 'object'
  }
  
  /**
   * Strict object type check. Only returns true
   * for plain JavaScript objects.
   *
   * @param {*} obj
   * @return {Boolean}
   */
  
  var toString = Object.prototype.toString
  var OBJECT_STRING = '[object Object]'
  exports.isPlainObject = function (obj) {
    return toString.call(obj) === OBJECT_STRING
  }
  
  /**
   * Array type check.
   *
   * @param {*} obj
   * @return {Boolean}
   */
  
  exports.isArray = Array.isArray
  
  /**
   * Define a non-enumerable property
   *
   * @param {Object} obj
   * @param {String} key
   * @param {*} val
   * @param {Boolean} [enumerable]
   */
  
  exports.define = function (obj, key, val, enumerable) {
    Object.defineProperty(obj, key, {
      value: val,
      enumerable: !!enumerable,
      writable: true,
      configurable: true
    })
  }
  
  /**
   * Debounce a function so it only gets called after the
   * input stops arriving after the given wait period.
   *
   * @param {Function} func
   * @param {Number} wait
   * @return {Function} - the debounced function
   */
  
  exports.debounce = function (func, wait) {
    var timeout, args, context, timestamp, result
    var later = function () {
      var last = Date.now() - timestamp
      if (last < wait && last >= 0) {
        timeout = setTimeout(later, wait - last)
      } else {
        timeout = null
        result = func.apply(context, args)
        if (!timeout) context = args = null
      }
    }
    return function () {
      context = this
      args = arguments
      timestamp = Date.now()
      if (!timeout) {
        timeout = setTimeout(later, wait)
      }
      return result
    }
  }
  
  /**
   * Manual indexOf because it's slightly faster than
   * native.
   *
   * @param {Array} arr
   * @param {*} obj
   */
  
  exports.indexOf = function (arr, obj) {
    var i = arr.length
    while (i--) {
      if (arr[i] === obj) return i
    }
    return -1
  }
  
  /**
   * Make a cancellable version of an async callback.
   *
   * @param {Function} fn
   * @return {Function}
   */
  
  exports.cancellable = function (fn) {
    var cb = function () {
      if (!cb.cancelled) {
        return fn.apply(this, arguments)
      }
    }
    cb.cancel = function () {
      cb.cancelled = true
    }
    return cb
  }
  
  /**
   * Check if two values are loosely equal - that is,
   * if they are plain objects, do they have the same shape?
   *
   * @param {*} a
   * @param {*} b
   * @return {Boolean}
   */
  
  exports.looseEqual = function (a, b) {
    /* eslint-disable eqeqeq */
    return a == b || (
      exports.isObject(a) && exports.isObject(b)
        ? JSON.stringify(a) === JSON.stringify(b)
        : false
    )
    /* eslint-enable eqeqeq */
  }
  
  },{}],84:[function(require,module,exports){
  (function (process){
  var _ = require('./index')
  var config = require('../config')
  var extend = _.extend
  
  /**
   * Option overwriting strategies are functions that handle
   * how to merge a parent option value and a child option
   * value into the final value.
   *
   * All strategy functions follow the same signature:
   *
   * @param {*} parentVal
   * @param {*} childVal
   * @param {Vue} [vm]
   */
  
  var strats = config.optionMergeStrategies = Object.create(null)
  
  /**
   * Helper that recursively merges two data objects together.
   */
  
  function mergeData (to, from) {
    var key, toVal, fromVal
    for (key in from) {
      toVal = to[key]
      fromVal = from[key]
      if (!to.hasOwnProperty(key)) {
        _.set(to, key, fromVal)
      } else if (_.isObject(toVal) && _.isObject(fromVal)) {
        mergeData(toVal, fromVal)
      }
    }
    return to
  }
  
  /**
   * Data
   */
  
  strats.data = function (parentVal, childVal, vm) {
    if (!vm) {
      // in a Vue.extend merge, both should be functions
      if (!childVal) {
        return parentVal
      }
      if (typeof childVal !== 'function') {
        process.env.NODE_ENV !== 'production' && _.warn(
          'The "data" option should be a function ' +
          'that returns a per-instance value in component ' +
          'definitions.'
        )
        return parentVal
      }
      if (!parentVal) {
        return childVal
      }
      // when parentVal & childVal are both present,
      // we need to return a function that returns the
      // merged result of both functions... no need to
      // check if parentVal is a function here because
      // it has to be a function to pass previous merges.
      return function mergedDataFn () {
        return mergeData(
          childVal.call(this),
          parentVal.call(this)
        )
      }
    } else if (parentVal || childVal) {
      return function mergedInstanceDataFn () {
        // instance merge
        var instanceData = typeof childVal === 'function'
          ? childVal.call(vm)
          : childVal
        var defaultData = typeof parentVal === 'function'
          ? parentVal.call(vm)
          : undefined
        if (instanceData) {
          return mergeData(instanceData, defaultData)
        } else {
          return defaultData
        }
      }
    }
  }
  
  /**
   * El
   */
  
  strats.el = function (parentVal, childVal, vm) {
    if (!vm && childVal && typeof childVal !== 'function') {
      process.env.NODE_ENV !== 'production' && _.warn(
        'The "el" option should be a function ' +
        'that returns a per-instance value in component ' +
        'definitions.'
      )
      return
    }
    var ret = childVal || parentVal
    // invoke the element factory if this is instance merge
    return vm && typeof ret === 'function'
      ? ret.call(vm)
      : ret
  }
  
  /**
   * Hooks and param attributes are merged as arrays.
   */
  
  strats.init =
  strats.created =
  strats.ready =
  strats.attached =
  strats.detached =
  strats.beforeCompile =
  strats.compiled =
  strats.beforeDestroy =
  strats.destroyed = function (parentVal, childVal) {
    return childVal
      ? parentVal
        ? parentVal.concat(childVal)
        : _.isArray(childVal)
          ? childVal
          : [childVal]
      : parentVal
  }
  
  /**
   * 0.11 deprecation warning
   */
  
  strats.paramAttributes = function () {
    /* istanbul ignore next */
    process.env.NODE_ENV !== 'production' && _.warn(
      '"paramAttributes" option has been deprecated in 0.12. ' +
      'Use "props" instead.'
    )
  }
  
  /**
   * Assets
   *
   * When a vm is present (instance creation), we need to do
   * a three-way merge between constructor options, instance
   * options and parent options.
   */
  
  function mergeAssets (parentVal, childVal) {
    var res = Object.create(parentVal)
    return childVal
      ? extend(res, guardArrayAssets(childVal))
      : res
  }
  
  config._assetTypes.forEach(function (type) {
    strats[type + 's'] = mergeAssets
  })
  
  /**
   * Events & Watchers.
   *
   * Events & watchers hashes should not overwrite one
   * another, so we merge them as arrays.
   */
  
  strats.watch =
  strats.events = function (parentVal, childVal) {
    if (!childVal) return parentVal
    if (!parentVal) return childVal
    var ret = {}
    extend(ret, parentVal)
    for (var key in childVal) {
      var parent = ret[key]
      var child = childVal[key]
      if (parent && !_.isArray(parent)) {
        parent = [parent]
      }
      ret[key] = parent
        ? parent.concat(child)
        : [child]
    }
    return ret
  }
  
  /**
   * Other object hashes.
   */
  
  strats.props =
  strats.methods =
  strats.computed = function (parentVal, childVal) {
    if (!childVal) return parentVal
    if (!parentVal) return childVal
    var ret = Object.create(null)
    extend(ret, parentVal)
    extend(ret, childVal)
    return ret
  }
  
  /**
   * Default strategy.
   */
  
  var defaultStrat = function (parentVal, childVal) {
    return childVal === undefined
      ? parentVal
      : childVal
  }
  
  /**
   * Make sure component options get converted to actual
   * constructors.
   *
   * @param {Object} options
   */
  
  function guardComponents (options) {
    if (options.components) {
      var components = options.components =
        guardArrayAssets(options.components)
      var def
      var ids = Object.keys(components)
      for (var i = 0, l = ids.length; i < l; i++) {
        var key = ids[i]
        if (_.commonTagRE.test(key)) {
          process.env.NODE_ENV !== 'production' && _.warn(
            'Do not use built-in HTML elements as component ' +
            'id: ' + key
          )
          continue
        }
        def = components[key]
        if (_.isPlainObject(def)) {
          components[key] = _.Vue.extend(def)
        }
      }
    }
  }
  
  /**
   * Ensure all props option syntax are normalized into the
   * Object-based format.
   *
   * @param {Object} options
   */
  
  function guardProps (options) {
    var props = options.props
    var i, val
    if (_.isArray(props)) {
      options.props = {}
      i = props.length
      while (i--) {
        val = props[i]
        if (typeof val === 'string') {
          options.props[val] = null
        } else if (val.name) {
          options.props[val.name] = val
        }
      }
    } else if (_.isPlainObject(props)) {
      var keys = Object.keys(props)
      i = keys.length
      while (i--) {
        val = props[keys[i]]
        if (typeof val === 'function') {
          props[keys[i]] = { type: val }
        }
      }
    }
  }
  
  /**
   * Guard an Array-format assets option and converted it
   * into the key-value Object format.
   *
   * @param {Object|Array} assets
   * @return {Object}
   */
  
  function guardArrayAssets (assets) {
    if (_.isArray(assets)) {
      var res = {}
      var i = assets.length
      var asset
      while (i--) {
        asset = assets[i]
        var id = typeof asset === 'function'
          ? ((asset.options && asset.options.name) || asset.id)
          : (asset.name || asset.id)
        if (!id) {
          process.env.NODE_ENV !== 'production' && _.warn(
            'Array-syntax assets must provide a "name" or "id" field.'
          )
        } else {
          res[id] = asset
        }
      }
      return res
    }
    return assets
  }
  
  /**
   * Merge two option objects into a new one.
   * Core utility used in both instantiation and inheritance.
   *
   * @param {Object} parent
   * @param {Object} child
   * @param {Vue} [vm] - if vm is present, indicates this is
   *                     an instantiation merge.
   */
  
  exports.mergeOptions = function merge (parent, child, vm) {
    guardComponents(child)
    guardProps(child)
    var options = {}
    var key
    if (child.mixins) {
      for (var i = 0, l = child.mixins.length; i < l; i++) {
        parent = merge(parent, child.mixins[i], vm)
      }
    }
    for (key in parent) {
      mergeField(key)
    }
    for (key in child) {
      if (!(parent.hasOwnProperty(key))) {
        mergeField(key)
      }
    }
    function mergeField (key) {
      var strat = strats[key] || defaultStrat
      options[key] = strat(parent[key], child[key], vm, key)
    }
    return options
  }
  
  /**
   * Resolve an asset.
   * This function is used because child instances need access
   * to assets defined in its ancestor chain.
   *
   * @param {Object} options
   * @param {String} type
   * @param {String} id
   * @return {Object|Function}
   */
  
  exports.resolveAsset = function resolve (options, type, id) {
    var assets = options[type]
    var camelizedId
    return assets[id] ||
      // camelCase ID
      assets[camelizedId = _.camelize(id)] ||
      // Pascal Case ID
      assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)]
  }
  
  }).call(this,require('_process'))
  },{"../config":31,"./index":82,"_process":5}],85:[function(require,module,exports){
  (function (process){
  var _ = require('./util')
  var extend = _.extend
  
  /**
   * The exposed Vue constructor.
   *
   * API conventions:
   * - public API methods/properties are prefiexed with `$`
   * - internal methods/properties are prefixed with `_`
   * - non-prefixed properties are assumed to be proxied user
   *   data.
   *
   * @constructor
   * @param {Object} [options]
   * @public
   */
  
  function Vue (options) {
    this._init(options)
  }
  
  /**
   * Mixin global API
   */
  
  extend(Vue, require('./api/global'))
  
  /**
   * Vue and every constructor that extends Vue has an
   * associated options object, which can be accessed during
   * compilation steps as `this.constructor.options`.
   *
   * These can be seen as the default options of every
   * Vue instance.
   */
  
  Vue.options = {
    replace: true,
    directives: require('./directives/public'),
    elementDirectives: require('./directives/element'),
    filters: require('./filters'),
    transitions: {},
    components: {},
    partials: {}
  }
  
  /**
   * Build up the prototype
   */
  
  var p = Vue.prototype
  
  /**
   * $data has a setter which does a bunch of
   * teardown/setup work
   */
  
  Object.defineProperty(p, '$data', {
    get: function () {
      return this._data
    },
    set: function (newData) {
      if (newData !== this._data) {
        this._setData(newData)
      }
    }
  })
  
  /**
   * Mixin internal instance methods
   */
  
  extend(p, require('./instance/init'))
  extend(p, require('./instance/events'))
  extend(p, require('./instance/state'))
  extend(p, require('./instance/lifecycle'))
  extend(p, require('./instance/misc'))
  
  /**
   * Mixin public API methods
   */
  
  extend(p, require('./api/data'))
  extend(p, require('./api/dom'))
  extend(p, require('./api/events'))
  extend(p, require('./api/lifecycle'))
  
  Vue.version = '1.0.8'
  module.exports = _.Vue = Vue
  
  /* istanbul ignore if */
  if (process.env.NODE_ENV !== 'production') {
    if (_.inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
      window.__VUE_DEVTOOLS_GLOBAL_HOOK__.emit('init', Vue)
    }
  }
  
  }).call(this,require('_process'))
  },{"./api/data":20,"./api/dom":21,"./api/events":22,"./api/global":23,"./api/lifecycle":24,"./directives/element":33,"./directives/public":48,"./filters":59,"./instance/events":62,"./instance/init":63,"./instance/lifecycle":64,"./instance/misc":65,"./instance/state":66,"./util":82,"_process":5}],86:[function(require,module,exports){
  (function (process){
  var _ = require('./util')
  var config = require('./config')
  var Dep = require('./observer/dep')
  var expParser = require('./parsers/expression')
  var batcher = require('./batcher')
  var uid = 0
  
  /**
   * A watcher parses an expression, collects dependencies,
   * and fires callback when the expression value changes.
   * This is used for both the $watch() api and directives.
   *
   * @param {Vue} vm
   * @param {String} expression
   * @param {Function} cb
   * @param {Object} options
   *                 - {Array} filters
   *                 - {Boolean} twoWay
   *                 - {Boolean} deep
   *                 - {Boolean} user
   *                 - {Boolean} sync
   *                 - {Boolean} lazy
   *                 - {Function} [preProcess]
   *                 - {Function} [postProcess]
   * @constructor
   */
  
  function Watcher (vm, expOrFn, cb, options) {
    // mix in options
    if (options) {
      _.extend(this, options)
    }
    var isFn = typeof expOrFn === 'function'
    this.vm = vm
    vm._watchers.push(this)
    this.expression = isFn ? expOrFn.toString() : expOrFn
    this.cb = cb
    this.id = ++uid // uid for batching
    this.active = true
    this.dirty = this.lazy // for lazy watchers
    this.deps = Object.create(null)
    this.newDeps = null
    this.prevError = null // for async error stacks
    // parse expression for getter/setter
    if (isFn) {
      this.getter = expOrFn
      this.setter = undefined
    } else {
      var res = expParser.parse(expOrFn, this.twoWay)
      this.getter = res.get
      this.setter = res.set
    }
    this.value = this.lazy
      ? undefined
      : this.get()
    // state for avoiding false triggers for deep and Array
    // watchers during vm._digest()
    this.queued = this.shallow = false
  }
  
  /**
   * Add a dependency to this directive.
   *
   * @param {Dep} dep
   */
  
  Watcher.prototype.addDep = function (dep) {
    var id = dep.id
    if (!this.newDeps[id]) {
      this.newDeps[id] = dep
      if (!this.deps[id]) {
        this.deps[id] = dep
        dep.addSub(this)
      }
    }
  }
  
  /**
   * Evaluate the getter, and re-collect dependencies.
   */
  
  Watcher.prototype.get = function () {
    this.beforeGet()
    var scope = this.scope || this.vm
    var value
    try {
      value = this.getter.call(scope, scope)
    } catch (e) {
      if (
        process.env.NODE_ENV !== 'production' &&
        config.warnExpressionErrors
      ) {
        _.warn(
          'Error when evaluating expression "' +
          this.expression + '". ' +
          (config.debug
            ? ''
            : 'Turn on debug mode to see stack trace.'
          ), e
        )
      }
    }
    // "touch" every property so they are all tracked as
    // dependencies for deep watching
    if (this.deep) {
      traverse(value)
    }
    if (this.preProcess) {
      value = this.preProcess(value)
    }
    if (this.filters) {
      value = scope._applyFilters(value, null, this.filters, false)
    }
    if (this.postProcess) {
      value = this.postProcess(value)
    }
    this.afterGet()
    return value
  }
  
  /**
   * Set the corresponding value with the setter.
   *
   * @param {*} value
   */
  
  Watcher.prototype.set = function (value) {
    var scope = this.scope || this.vm
    if (this.filters) {
      value = scope._applyFilters(
        value, this.value, this.filters, true)
    }
    try {
      this.setter.call(scope, scope, value)
    } catch (e) {
      if (
        process.env.NODE_ENV !== 'production' &&
        config.warnExpressionErrors
      ) {
        _.warn(
          'Error when evaluating setter "' +
          this.expression + '"', e
        )
      }
    }
    // two-way sync for v-for alias
    var forContext = scope.$forContext
    if (forContext && forContext.alias === this.expression) {
      if (forContext.filters) {
        process.env.NODE_ENV !== 'production' && _.warn(
          'It seems you are using two-way binding on ' +
          'a v-for alias (' + this.expression + '), and the ' +
          'v-for has filters. This will not work properly. ' +
          'Either remove the filters or use an array of ' +
          'objects and bind to object properties instead.'
        )
        return
      }
      forContext._withLock(function () {
        if (scope.$key) { // original is an object
          forContext.rawValue[scope.$key] = value
        } else {
          forContext.rawValue.$set(scope.$index, value)
        }
      })
    }
  }
  
  /**
   * Prepare for dependency collection.
   */
  
  Watcher.prototype.beforeGet = function () {
    Dep.target = this
    this.newDeps = Object.create(null)
  }
  
  /**
   * Clean up for dependency collection.
   */
  
  Watcher.prototype.afterGet = function () {
    Dep.target = null
    var ids = Object.keys(this.deps)
    var i = ids.length
    while (i--) {
      var id = ids[i]
      if (!this.newDeps[id]) {
        this.deps[id].removeSub(this)
      }
    }
    this.deps = this.newDeps
  }
  
  /**
   * Subscriber interface.
   * Will be called when a dependency changes.
   *
   * @param {Boolean} shallow
   */
  
  Watcher.prototype.update = function (shallow) {
    if (this.lazy) {
      this.dirty = true
    } else if (this.sync || !config.async) {
      this.run()
    } else {
      // if queued, only overwrite shallow with non-shallow,
      // but not the other way around.
      this.shallow = this.queued
        ? shallow
          ? this.shallow
          : false
        : !!shallow
      this.queued = true
      // record before-push error stack in debug mode
      /* istanbul ignore if */
      if (process.env.NODE_ENV !== 'production' && config.debug) {
        this.prevError = new Error('[vue] async stack trace')
      }
      batcher.push(this)
    }
  }
  
  /**
   * Batcher job interface.
   * Will be called by the batcher.
   */
  
  Watcher.prototype.run = function () {
    if (this.active) {
      var value = this.get()
      if (
        value !== this.value ||
        // Deep watchers and Array watchers should fire even
        // when the value is the same, because the value may
        // have mutated; but only do so if this is a
        // non-shallow update (caused by a vm digest).
        ((_.isArray(value) || this.deep) && !this.shallow)
      ) {
        // set new value
        var oldValue = this.value
        this.value = value
        // in debug + async mode, when a watcher callbacks
        // throws, we also throw the saved before-push error
        // so the full cross-tick stack trace is available.
        var prevError = this.prevError
        /* istanbul ignore if */
        if (process.env.NODE_ENV !== 'production' &&
            config.debug && prevError) {
          this.prevError = null
          try {
            this.cb.call(this.vm, value, oldValue)
          } catch (e) {
            _.nextTick(function () {
              throw prevError
            }, 0)
            throw e
          }
        } else {
          this.cb.call(this.vm, value, oldValue)
        }
      }
      this.queued = this.shallow = false
    }
  }
  
  /**
   * Evaluate the value of the watcher.
   * This only gets called for lazy watchers.
   */
  
  Watcher.prototype.evaluate = function () {
    // avoid overwriting another watcher that is being
    // collected.
    var current = Dep.target
    this.value = this.get()
    this.dirty = false
    Dep.target = current
  }
  
  /**
   * Depend on all deps collected by this watcher.
   */
  
  Watcher.prototype.depend = function () {
    var depIds = Object.keys(this.deps)
    var i = depIds.length
    while (i--) {
      this.deps[depIds[i]].depend()
    }
  }
  
  /**
   * Remove self from all dependencies' subcriber list.
   */
  
  Watcher.prototype.teardown = function () {
    if (this.active) {
      // remove self from vm's watcher list
      // we can skip this if the vm if being destroyed
      // which can improve teardown performance.
      if (!this.vm._isBeingDestroyed) {
        this.vm._watchers.$remove(this)
      }
      var depIds = Object.keys(this.deps)
      var i = depIds.length
      while (i--) {
        this.deps[depIds[i]].removeSub(this)
      }
      this.active = false
      this.vm = this.cb = this.value = null
    }
  }
  
  /**
   * Recrusively traverse an object to evoke all converted
   * getters, so that every nested property inside the object
   * is collected as a "deep" dependency.
   *
   * @param {*} val
   */
  
  function traverse (val) {
    var i, keys
    if (_.isArray(val)) {
      i = val.length
      while (i--) traverse(val[i])
    } else if (_.isObject(val)) {
      keys = Object.keys(val)
      i = keys.length
      while (i--) traverse(val[keys[i]])
    }
  }
  
  module.exports = Watcher
  
  }).call(this,require('_process'))
  },{"./batcher":25,"./config":31,"./observer/dep":68,"./parsers/expression":71,"./util":82,"_process":5}],87:[function(require,module,exports){
  
  /*
   |--------------------------------------------------------------------------
   | Laravel Spark - Creating Amazing Experiences.
   |--------------------------------------------------------------------------
   |
   | First, we will load all of the "core" dependencies for Spark which are
   | libraries such as Vue and jQuery. Then, we will load the components
   | which manage the Spark screens such as the user settings screens.
   |
   | Next, we will create the root Vue application for Spark. This'll start
   | the entire application and attach it to the DOM. Of course, you may
   | customize this script as you desire and load your own components.
   |
   */
  
  'use strict';
  
  require('./spark/core/dependencies.js');
  
  require('./spark/components.js');
  
  new Vue(require('./spark/spark.js'));
  
  },{"./spark/components.js":95,"./spark/core/dependencies.js":97,"./spark/spark.js":111}],88:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, '__esModule', {
      value: true
  });
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
  
  var _notesNotes = require('./notes/notes');
  
  var _notesNotes2 = _interopRequireDefault(_notesNotes);
  
  var _videosVideos = require('./videos/videos');
  
  var _videosVideos2 = _interopRequireDefault(_videosVideos);
  
  //import alert from 'vue-strap/src/Alert.vue'
  //import carousel from 'vue-strap/src/Carousel.vue'
  //import slider from 'vue-strap/src/Slider.vue'
  //import accordion from 'vue-strap/src/Accordion.vue'
  //import affix from 'vue-strap/src/Affix.vue'
  //import aside from 'vue-strap/src/Aside.vue'
  //import checkboxGroup from 'vue-strap/src/checkboxGroup.vue'
  //import checkboxBtn from 'vue-strap/src/checkboxBtn.vue'
  //import datepicker from 'vue-strap/src/Datepicker.vue'
  //import dropdown from 'vue-strap/src/Dropdown.vue'
  //import modal from 'vue-strap/src/Modal.vue'
  //import option from 'vue-strap/src/Option.vue'
  //import panel from 'vue-strap/src/Panel.vue'
  //import popover from 'vue-strap/src/Popover.vue'
  //import progressbar from 'vue-strap/src/Progressbar.vue'
  //import radioBtn from 'vue-strap/src/radioBtn.vue'
  //import radioGroup from 'vue-strap/src/radioGroup.vue'
  //import select from 'vue-strap/src/Select.vue'
  //import tab from 'vue-strap/src/Tab.vue'
  //import tabset from 'vue-strap/src/Tabset.vue'
  //import tooltip from 'vue-strap/src/Tooltip.vue'
  //import typeahead from 'vue-strap/src/Typeahead.vue'
  
  exports['default'] = {
      notes: _notesNotes2['default'],
      vueVideos: _videosVideos2['default']
  
  };
  module.exports = exports['default'];
  
  },{"./notes/notes":90,"./videos/videos":91}],89:[function(require,module,exports){
  module.exports = '<form v-on:submit="addNote">\n    <div class="form-group">\n        <textarea v-model="newNote"\n                  class="form-control"\n                  rows="3" >\n\n        </textarea>\n    </div>\n\n    <button class="btn btn-primary">\n        Add Note\n    </button>\n</form>\n\n<!--<div v-show="notes.length">-->\n    <h1>Notes ({{ notes.length }})</h1>\n\n    <ol class="list-group">\n        <li v-for="note in notes"\n            class="list-group-item">\n            <a v-on:click=" removeNote(note)" class="glyphicon glyphicon-remove btn btn-danger btn-xs pull-right"></a>\n            <span v-on:dblclick=" editNote(note)">{{ note.body }}</span>\n\n        </li>\n    </ol>\n</div>\n';
  },{}],90:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, '__esModule', {
      value: true
  });
  exports['default'] = {
  
      template: require('./notes.html'),
  
      data: function data() {
          return {
              notes: [],
              newNote: ''
          };
      },
  
      props: ['lesson_id'],
  
      ready: function ready() {
          var that = this;
  
          this.$http.get("/api/notes?lesson_id=" + this.lesson_id, function (data) {
              var notes_data = data.data;
              for (var i = 0; i < notes_data.length; i++) {
                  that.notes.push({
                      body: notes_data[i].body
                  });
              }
          });
      },
  
      methods: {
  
          addNote: function addNote(e) {
              e.preventDefault();
  
              if (!this.newNote) return;
  
              this.notes.push({
                  body: this.newNote
              });
  
              this.$http.post('/api/notes', {
                  body: this.newNote,
                  lesson_id: this.lesson_id,
                  _token: token
              }).success(function (data) {
                  console.log(data);
              });
  
              this.newNote = '';
          },
          removeNote: function removeNote(note) {
              this.notes.$remove(note);
          }
      }
  };
  module.exports = exports['default'];
  
  },{"./notes.html":89}],91:[function(require,module,exports){
  'use strict';
  
  Object.defineProperty(exports, '__esModule', {
      value: true
  });
  exports['default'] = {
  
      data: {
          zoom: 4
      },
      methods: {
          changeZoom: function changeZoom() {
              that = this;
              $('iframe').each(function () {
                  var height = that.zoom * 315 / 3;
                  var width = that.zoom * 560 / 3;
                  $(this).css('height', height);
                  $(this).css('width', width);
              });
          }
      }
  
  };
  module.exports = exports['default'];
  
  },{}],92:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-simple-registration-screen', {
      mixins: [Spark.helpers],
  
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          $(function () {
              $('.spark-first-field').filter(':visible:first').focus();
          });
  
          var queryString = URI(document.URL).query(true);
  
          if (queryString.invitation) {
              this.getInvitation(queryString.invitation);
          }
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              invitation: null,
              failedToLoadInvitation: false,
  
              registerForm: new SparkForm({
                  team_name: '', name: '', email: '', password: '', password_confirmation: '',
                  plan: '', terms: false, invitation: null
              })
          };
      },
  
      methods: {
          /**
           * Get the specified invitation.
           */
          getInvitation: function getInvitation(invitation) {
              this.$http.get('/spark/api/teams/invitation/' + invitation).success(function (invitation) {
                  this.invitation = invitation;
                  this.registerForm.invitation = invitation.token;
  
                  setTimeout(function () {
                      $(function () {
                          $('.spark-first-field').filter(':visible:first').focus();
                      });
                  }, 250);
              }).error(function (errors) {
                  this.failedToLoadInvitation = true;
  
                  console.error('Unable to load invitation for given code.');
              });
          },
  
          /*
           * Initialize the registration process.
           */
          register: function register() {
              Spark.post('/register', this.registerForm).then(function (response) {
                  window.location = response.path;
              });
          }
      }
  });
  
  },{}],93:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-subscription-register-screen', {
      mixins: [Spark.helpers],
  
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          this.getPlans();
  
          Stripe.setPublishableKey(STRIPE_KEY);
  
          var queryString = URI(document.URL).query(true);
  
          if (queryString.coupon) {
              this.getCoupon(queryString.coupon);
          }
  
          if (queryString.invitation) {
              this.getInvitation(queryString.invitation);
          }
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              plans: [],
              selectedPlan: null,
              planTypeState: false,
              currentCoupon: null,
              invitation: null,
              failedToLoadInvitation: false,
  
              registerForm: new SparkForm({
                  team_name: '', name: '', email: '', password: '', password_confirmation: '',
                  plan: '', terms: false, coupon: null, invitation: null, stripe_token: null
              }),
  
              cardForm: new SparkForm({
                  number: '', cvc: '', month: '', year: '', zip: ''
              })
          };
      },
  
      computed: {
          /*
           * Determine if the plans have been loaded from the API.
           */
          plansAreLoaded: function plansAreLoaded() {
              return this.plans.length > 0;
          },
  
          /*
           * Get all of the "default" available plans. Typically this is monthly.
           */
          defaultPlans: function defaultPlans() {
              if (this.monthlyPlans.length > 0) {
                  return this.monthlyPlans;
              }
  
              if (this.yearlyPlans.length > 0) {
                  return this.yearlyPlans;
              }
          },
  
          /*
           * Get all of the plans that have a mnthly interval.
           */
          monthlyPlans: function monthlyPlans() {
              return _.filter(this.plans, function (plan) {
                  return plan.interval == 'monthly' && plan.active;
              });
          },
  
          /*
           * Get all of the plans that have a yearly interval.
           */
          yearlyPlans: function yearlyPlans() {
              return _.filter(this.plans, function (plan) {
                  return plan.interval == 'yearly' && plan.active;
              });
          },
  
          /*
           * Determine if a free plan is currently selected during registration.
           */
          freePlanIsSelected: function freePlanIsSelected() {
              return this.selectedPlan && this.selectedPlan.price === 0;
          },
  
          /*
           * Determine if the plan type selector is set to "monthly".
           */
          shouldShowDefaultPlans: function shouldShowDefaultPlans() {
              return !this.planTypeState;
          },
  
          /*
           * Determine if the plan type selector is set to "yearly".
           */
          shouldShowYearlyPlans: function shouldShowYearlyPlans() {
              return this.planTypeState;
          },
  
          /*
           * Get the full selected plan price with currency symbol.
           */
          selectedPlanPrice: function selectedPlanPrice() {
              if (this.selectedPlan) {
                  return this.selectedPlan.currencySymbol + this.selectedPlan.price;
              }
          },
  
          /*
           * Get the displayable discount for the current coupon.
           */
          currentCouponDisplayDiscount: function currentCouponDisplayDiscount() {
              if (this.currentCoupon) {
                  if (this.currentCoupon.amountOff) {
                      return '$' + this.currentCoupon.amountOff + ' Off';
                  }
  
                  if (this.currentCoupon.percentOff) {
                      return this.currentCoupon.percentOff + '% Off';
                  }
              }
          }
      },
  
      methods: {
          /*
           * Get all of the Spark plans from the API.
           */
          getPlans: function getPlans() {
              this.$http.get('spark/api/subscriptions/plans').success(function (plans) {
                  var self = this;
  
                  this.plans = _.filter(plans, function (plan) {
                      return plan.active;
                  });
  
                  var queryString = URI(document.URL).query(true);
  
                  // If there is only one plan, automatically select it...
                  if (this.plans.length == 1) {
                      this.setSelectedPlan(this.plans[0]);
  
                      setTimeout(function () {
                          $('.spark-first-field').filter(':visible:first').focus();
                      }, 100);
                  } else if (queryString.invitation) {
                      // If an invitation was sent and there is a free plan, select it...
                      _.each(this.plans, function (p) {
                          if (p.price === 0) {
                              return self.selectPlan(p);
                          }
                      });
                  }
              });
          },
  
          /*
           * Get the specified coupon for registration.
           */
          getCoupon: function getCoupon(coupon) {
              this.$http.get('spark/api/subscriptions/coupon/' + coupon).success(function (coupon) {
                  this.currentCoupon = coupon;
              }).error(function (errors) {
                  console.error('Unable to load coupon for given code.');
              });
          },
  
          /**
           * Get the specified invitation.
           */
          getInvitation: function getInvitation(invitation) {
              this.$http.get('/spark/api/teams/invitation/' + invitation).success(function (invitation) {
                  this.invitation = invitation;
  
                  setTimeout(function () {
                      $(function () {
                          $('.spark-first-field').filter(':visible:first').focus();
                      });
                  }, 250);
              }).error(function (errors) {
                  this.failedToLoadInvitation = true;
  
                  console.error('Unable to load invitation for given code.');
              });
          },
  
          /*
           * Calculate the discounted price for plan based on current coupon.
           */
          getDiscountPlanPrice: function getDiscountPlanPrice(price) {
              if (this.currentCoupon) {
                  if (this.currentCoupon.amountOff) {
                      price = price - this.currentCoupon.amountOff;
                  }
  
                  if (this.currentCoupon.percentOff) {
                      price = price - price * (this.currentCoupon.percentOff / 100);
                  }
  
                  if (price < 0) {
                      return 0;
                  }
  
                  return price.toFixed(2);
              }
          },
  
          /*
           * Get the displayable discount duration for the current coupon.
           */
          getCouponDisplayDuration: function getCouponDisplayDuration(plan) {
              if (this.currentCoupon) {
                  if (this.currentCoupon.lastsOnce) {
                      if (plan.interval == 'monthly') {
                          return 'For The First Month';
                      } else {
                          return 'For The First Year';
                      }
                  }
  
                  if (this.currentCoupon.lastsForever) {
                      if (plan.interval == 'monthly') {
                          return 'Monthly For Life';
                      } else {
                          return 'Yearly For Life';
                      }
                  }
  
                  if (this.currentCoupon.months) {
                      if (plan.interval == 'monthly') {
                          return 'Monthly For The First ' + this.currentCoupon.months + ' Months';
                      } else {
                          return 'For The First Year';
                      }
                  }
              }
          },
  
          /*
           * Select a plan from the list. Initialize registration form.
           */
          selectPlan: function selectPlan(plan) {
              this.setSelectedPlan(plan);
  
              setTimeout(function () {
                  $('.spark-first-field').filter(':visible:first').focus();
              }, 100);
          },
  
          /*
           * Set the selected plan.
           */
          setSelectedPlan: function setSelectedPlan(plan) {
              this.selectedPlan = plan;
              this.registerForm.plan = plan.id;
          },
  
          /*
           * Clear the selected plan from the component state.
           */
          selectAnotherPlan: function selectAnotherPlan() {
              this.selectedPlan = null;
              this.registerForm.plan = '';
          },
  
          /*
           * Initialize the registration process.
           */
          register: function register() {
              var self = this;
  
              this.cardForm.fullErrors = {};
              this.cardForm.errors = [];
  
              this.registerForm.fullErrors = {};
              this.registerForm.errors = [];
  
              this.registerForm.busy = true;
  
              if (this.freePlanIsSelected) {
                  return this.sendRegistration();
              }
  
              /*
                  Here we will build the payload to send to Stripe, which will
                  return a token. This token can be used to make charges on
                  the user's credit cards instead of storing the numbers.
              */
              var payload = {
                  name: this.registerForm.name,
                  number: this.cardForm.number,
                  cvc: this.cardForm.cvc,
                  exp_month: this.cardForm.month,
                  exp_year: this.cardForm.year,
                  address_zip: this.cardForm.zip
              };
  
              Stripe.card.createToken(payload, function (status, response) {
                  if (response.error) {
                      self.cardForm.fullErrors = { number: [response.error.message] };
                      self.cardForm.errors.push(response.error.message);
  
                      self.registerForm.busy = false;
                  } else {
                      self.registerForm.stripe_token = response.id;
                      self.sendRegistration();
                  }
              });
          },
  
          /*
           * After obtaining the Stripe token, send the registration to Spark.
           */
          sendRegistration: function sendRegistration() {
              if (this.currentCoupon && !this.freePlanIsSelected) {
                  this.registerForm.coupon = this.currentCoupon.id;
              }
  
              if (this.invitation) {
                  this.registerForm.invitation = this.invitation.token;
              }
  
              this.$http.post('/register', this.registerForm).success(function (response) {
                  window.location = '/home';
              }).error(function (errors) {
                  this.registerForm.busy = false;
  
                  this.registerForm.fullErrors = errors;
                  Spark.setErrorsOnForm(this.registerForm, errors);
              });
          },
  
          /*
           * Get the proper column width based on the number of plans.
           */
          getPlanColumnWidth: function getPlanColumnWidth(count) {
              switch (count) {
                  case 1:
                      return 'col-md-4 col-md-offset-4';
                  case 2:
                      return 'col-md-6';
                  case 3:
                      return 'col-md-4';
                  case 4:
                      return 'col-md-3';
                  default:
                      console.error("Spark only supports up to 4 plans per interval.");
              }
          }
      }
  });
  
  },{}],94:[function(require,module,exports){
  /*
   * Common Error Display Component.
   */
  'use strict';
  
  Vue.component('spark-errors', {
      props: ['form'],
  
      template: "<div><div class='alert alert-danger' v-if='form.errors && form.errors.length > 0'>\
                  <strong>Whoops!</strong> There were some problems with your input.<br><br>\
                  <ul>\
                      <li v-for='error in form.errors'>\
                          {{ error }}\
                      </li>\
                  </ul>\
              </div></div>"
  });
  
  Vue.component('spark-error-alert', {
      props: ['form'],
  
      template: "<div><div class='alert alert-danger' v-if='form.errors && form.errors.length > 0'>\
                  <strong>Whoops!</strong> There were some problems with your input.\
              </div></div>"
  });
  
  },{}],95:[function(require,module,exports){
  
  /*
   |--------------------------------------------------------------------------
   | Spark Page Components
   |--------------------------------------------------------------------------
   |
   | These components control the user settings screens for Spark. You will
   | change these paths to your own custom components if you need to use
   | your own component to provide custom logic for your applications.
   |
   | In addition, the components which control the team settings and member
   | management are also included. Again, you may change these paths and
   | require your own custom-built components to manage these screens.
   */
  
  'use strict';
  
  require('./settings/dashboard/profile');
  require('./settings/dashboard/security/password');
  require('./settings/dashboard/security/two-factor');
  
  require('./settings/team/owner');
  require('./settings/team/membership/edit-team-member');
  
  },{"./settings/dashboard/profile":102,"./settings/dashboard/security/password":103,"./settings/dashboard/security/two-factor":104,"./settings/team/membership/edit-team-member":109,"./settings/team/owner":110}],96:[function(require,module,exports){
  'use strict';
  
  require('./../common/errors');
  require('./../nav');
  require('./../auth/registration/simple');
  require('./../auth/registration/subscription');
  require('./../settings/dashboard');
  require('./../settings/dashboard/subscription');
  require('./../settings/dashboard/teams');
  require('./../settings/team');
  require('./../settings/team/membership');
  
  },{"./../auth/registration/simple":92,"./../auth/registration/subscription":93,"./../common/errors":94,"./../nav":100,"./../settings/dashboard":101,"./../settings/dashboard/subscription":105,"./../settings/dashboard/teams":106,"./../settings/team":107,"./../settings/team/membership":108}],97:[function(require,module,exports){
  /*
   * Load Vue & Vue-Resource.
   *
   * Vue is the JavaScript framework used by Spark.
   */
  'use strict';
  
  if (window.Vue === undefined) window.Vue = require('vue');
  
  require('vue-resource');
  Vue.http.headers.common['X-CSRF-TOKEN'] = Spark.csrfToken;
  
  /**
   * Load Promises library.
   */
  window.Promise = require('promise');
  
  /*
   * Load Underscore.js, used for map / reduce on arrays.
   */
  if (window._ === undefined) window._ = require('underscore');
  
  /*
   * Load Moment.js, used for date formatting and presentation.
   */
  if (window.moment === undefined) window.moment = require('moment');
  
  /*
   * Load jQuery and Bootstrap jQuery, used for front-end interaction.
   */
  if (window.$ === undefined || window.jQuery === undefined) window.$ = window.jQuery = require('jquery');
  require('bootstrap-sass/assets/javascripts/bootstrap');
  
  },{"bootstrap-sass/assets/javascripts/bootstrap":2,"jquery":3,"moment":4,"promise":6,"underscore":11,"vue":85,"vue-resource":13}],98:[function(require,module,exports){
  /**
   * Text field input component for Bootstrap.
   */
  'use strict';
  
  Vue.component('spark-text', {
      props: ['display', 'form', 'name', 'input'],
  
      /**
       * Include the helper methods in the component.
       */
      mixins: [Spark.helpers],
  
      template: '<div class="form-group" :class="{\'has-error\': hasError(form, name)}">\
      <label class="col-md-4 control-label">{{ display }}</label>\
      <div class="col-md-6">\
          <input type="text" class="form-control" v-model="input">\
          <span class="help-block" v-show="hasError(form, name)">\
              <strong>{{ getError(form, name) }}</strong>\
          </span>\
      </div>\
  </div>'
  });
  
  /**
   * E-mail field input component for Bootstrap.
   */
  Vue.component('spark-email', {
      props: ['display', 'form', 'name', 'input'],
  
      /**
       * Include the helper methods in the component.
       */
      mixins: [Spark.helpers],
  
      template: '<div class="form-group" :class="{\'has-error\': hasError(form, name)}">\
      <label class="col-md-4 control-label">{{ display }}</label>\
      <div class="col-md-6">\
          <input type="email" class="form-control" v-model="input">\
          <span class="help-block" v-show="hasError(form, name)">\
              <strong>{{ getError(form, name) }}</strong>\
          </span>\
      </div>\
  </div>'
  });
  
  /**
   * Password field input component for Bootstrap.
   */
  Vue.component('spark-password', {
      props: ['display', 'form', 'name', 'input'],
  
      /**
       * Include the helper methods in the component.
       */
      mixins: [Spark.helpers],
  
      template: '<div class="form-group" :class="{\'has-error\': hasError(form, name)}">\
      <label class="col-md-4 control-label">{{ display }}</label>\
      <div class="col-md-6">\
          <input type="password" class="form-control" v-model="input">\
          <span class="help-block" v-show="hasError(form, name)">\
              <strong>{{ getError(form, name) }}</strong>\
          </span>\
      </div>\
  </div>'
  });
  
  /**
   * Password field input component for Bootstrap.
   */
  Vue.component('spark-select', {
      props: ['display', 'form', 'name', 'items', 'input'],
  
      /**
       * Include the helper methods in the component.
       */
      mixins: [Spark.helpers],
  
      template: '<div class="form-group" :class="{\'has-error\': hasError(form, name)}">\
      <label class="col-md-4 control-label">{{ display }}</label>\
      <div class="col-md-8">\
          <select class="form-control" v-model="input">\
              <option v-for="item in items" :value="item.value">\
                  {{ item.text }}\
              </option>\
          </select>\
          <span class="help-block" v-show="hasError(form, name)">\
              <strong>{{ getError(form, name) }}</strong>\
          </span>\
      </div>\
  </div>'
  });
  
  },{}],99:[function(require,module,exports){
  
  /**
   * SparkForm helper class. Used to set common properties.
   */
  'use strict';
  
  window.SparkForm = function (data) {
      var form = this;
  
      _.extend(this, data);
  
      this.fullErrors = {};
      this.errors = [];
      this.busy = false;
      this.successful = false;
  
      this.startProcessing = function () {
          form.fullErrors = {};
          form.errors = [];
          form.busy = true;
          form.successful = false;
      };
  
      this.finishProcessing = function () {
          form.busy = false;
          form.successful = true;
      };
  };
  
  /**
   * Extend Spark with helpful form helpers.
   */
  _.extend(Spark, {
      post: function post(uri, form) {
          return Spark.sendForm('post', uri, form);
      },
  
      put: function put(uri, form) {
          return Spark.sendForm('put', uri, form);
      },
  
      'delete': function _delete(uri, form) {
          return Spark.sendForm('delete', uri, form);
      },
  
      /**
       * Send the form to the back-end server. Perform common form tasks.
       *
       * This function will automatically clear old errors, update "busy" status, etc.
       */
      sendForm: function sendForm(method, uri, form) {
          return new Promise(function (resolve, reject) {
              form.startProcessing();
  
              Vue.http[method](uri, form).success(function (response) {
                  form.finishProcessing();
  
                  resolve(response);
              }).error(function (errors) {
                  form.fullErrors = errors;
                  Spark.setErrorsOnForm(form, errors);
                  form.busy = false;
  
                  reject(errors);
              });
          });
      },
  
      /**
       * Set errors on the form. Flatten the errors if necessary.
       */
      setErrorsOnForm: function setErrorsOnForm(form, errors) {
          if (typeof errors === 'object') {
              form.errors = _.flatten(_.toArray(errors));
          } else {
              form.errors.push('Something went wrong. Please try again.');
          }
      },
  
      helpers: {
          methods: {
              /**
               * Determine if the form has an error for the field.
               */
              hasError: function hasError(form, field) {
                  return _.indexOf(_.keys(form.fullErrors), field) > -1;
              },
  
              /**
               * Get the first error for the given field if it exists.
               */
              getError: function getError(form, field) {
                  if (this.hasError(form, field)) {
                      return form.fullErrors[field][0];
                  }
              }
          }
      }
  });
  
  },{}],100:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-nav-bar-dropdown', {
  	/*
    * Initial state of the component's data.
    */
  	data: function data() {
  		return {
  			user: null,
  			teams: []
  		};
  	},
  
  	events: {
  		/**
     * Handle the "userRetrieved" event.
     */
  		userRetrieved: function userRetrieved(user) {
  			this.user = user;
  
  			return true;
  		},
  
  		/**
     * Handle the "teamsRetrieved" event.
     */
  		teamsRetrieved: function teamsRetrieved(teams) {
  			this.teams = teams;
  
  			return true;
  		}
  	}
  });
  
  },{}],101:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-settings-screen', {
    /*
     * Bootstrap the component. Load the initial data.
     */
    ready: function ready() {
      //
    }
  });
  
  },{}],102:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-settings-profile-screen', {
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          //
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
  
              updateProfileForm: new SparkForm({
                  name: '',
                  email: ''
              })
          };
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              this.updateProfileFormForNewUser(user);
  
              return true;
          }
      },
  
      methods: {
          /**
           * Update the user profile form with new user information.
           */
          updateProfileFormForNewUser: function updateProfileFormForNewUser(user) {
              this.updateProfileForm.name = user.name;
              this.updateProfileForm.email = user.email;
          },
  
          /**
           * Update the user's profile information.
           */
          updateProfile: function updateProfile() {
              var self = this;
  
              Spark.put('/settings/user', this.updateProfileForm).then(function () {
                  self.$dispatch('updateUser');
              });
          }
      }
  });
  
  },{}],103:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-settings-security-password-screen', {
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          //
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
  
              updatePasswordForm: new SparkForm({
                  current_password: '',
                  password: '',
                  password_confirmation: ''
              })
          };
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              return true;
          }
      },
  
      methods: {
          /**
           * Update the user's password.
           */
          updatePassword: function updatePassword() {
              var self = this;
  
              Spark.put('/settings/user/password', this.updatePasswordForm).then(function () {
                  self.updatePasswordForm.current_password = '';
                  self.updatePasswordForm.password = '';
                  self.updatePasswordForm.password_confirmation = '';
              });
          }
      }
  });
  
  },{}],104:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-settings-security-two-factor-screen', {
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          //
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
  
              twoFactorForm: new SparkForm({
                  country_code: '',
                  phone_number: '',
                  enabled: false
              }),
  
              disableTwoFactorForm: new SparkForm({})
          };
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              this.twoFactorForm.country_code = this.user.phone_country_code;
              this.twoFactorForm.phone_number = this.user.phone_number;
  
              return true;
          }
      },
  
      methods: {
          /**
           * Enable two-factor authentication for the user.
           */
          enableTwoFactorAuth: function enableTwoFactorAuth() {
              var self = this;
  
              Spark.post('/settings/user/two-factor', this.twoFactorForm).then(function () {
                  self.$dispatch('updateUser');
  
                  self.twoFactorForm.enabled = true;
              });
          },
  
          /**
           * Disable two-factor authentication for the user.
           */
          disableTwoFactorAuth: function disableTwoFactorAuth() {
              var self = this;
  
              this.twoFactorForm.enabled = false;
  
              Spark['delete']('/settings/user/two-factor', this.disableTwoFactorForm).then(function () {
                  self.$dispatch('updateUser');
              });
          }
      }
  });
  
  },{}],105:[function(require,module,exports){
  'use strict';
  
  var settingsSubscriptionScreenForms = {
      updateCard: function updateCard() {
          return {
              number: '', cvc: '', month: '', year: '', zip: '',
              fullErrors: {}, errors: [], updating: false, updated: false
          };
      }
  };
  
  Vue.component('spark-settings-subscription-screen', {
      mixins: [Spark.helpers],
  
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          Stripe.setPublishableKey(STRIPE_KEY);
  
          this.getPlans();
  
          this.initializeTooltips();
      },
  
      /*
       * Configure watched data listeners.
       */
      watch: {
          'subscribeForm.plan': function subscribeFormPlan(value, oldValue) {
              if (value.length > 0) {
                  setTimeout(function () {
                      $('.spark-first-field').filter(':visible:first').focus();
                  }, 250);
              } else {
                  this.initializeTooltips();
              }
          }
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
              currentCoupon: null,
  
              plans: [],
  
              subscribeForm: new SparkForm({
                  plan: '', terms: false, stripe_token: null
              }),
  
              cardForm: new SparkForm({
                  number: '', cvc: '', month: '', year: '', zip: ''
              }),
  
              changePlanForm: new SparkForm({
                  plan: ''
              }),
  
              updateCardForm: settingsSubscriptionScreenForms.updateCard(),
  
              extraBillingInfoForm: new SparkForm({
                  text: ''
              }),
  
              resumeSubscriptionForm: new SparkForm({}),
              cancelSubscriptionForm: new SparkForm({})
          };
      },
  
      computed: {
          /*
           * Determine if the user has been loaded from the database.
           */
          userIsLoaded: function userIsLoaded() {
              if (this.user) {
                  return true;
              }
  
              return false;
          },
  
          /*
           * Determine if the user is currently on the "grace period".
           */
          userIsOnGracePeriod: function userIsOnGracePeriod() {
              if (this.user.subscription_ends_at) {
                  return moment().isBefore(this.user.subscription_ends_at);
              }
  
              return false;
          },
  
          /*
           * Determine the date that the user's grace period is over.
           */
          subscriptionEndsAt: function subscriptionEndsAt() {
              if (this.user.subscription_ends_at) {
                  return moment(this.user.subscription_ends_at).format('MMMM Do');
              }
          },
  
          /*
           * Determine if the plans have been loaded from the database.
           */
          plansAreLoaded: function plansAreLoaded() {
              return this.plans.length > 0;
          },
  
          /*
           * This method is used to determine if we need to display both a
           * monthly and yearly plans column, or if we will just show a
           * single column of available plans for the user to choose.
           */
          includesBothPlanIntervals: function includesBothPlanIntervals() {
              return this.plansAreLoaded && this.monthlyPlans.length > 0 && this.yearlyPlans.length > 0;
          },
  
          /*
           * Retrieve the plan that the user is currently subscribed to.
           */
          currentPlan: function currentPlan() {
              var self = this;
  
              if (!this.userIsLoaded) {
                  return null;
              }
  
              var plan = _.find(this.plans, function (plan) {
                  return plan.id == self.user.stripe_plan;
              });
  
              if (plan !== 'undefined') {
                  return plan;
              }
          },
  
          /*
           * Get the plan currently selected on the subscribe form.
           */
          selectedPlan: function selectedPlan() {
              var self = this;
  
              return _.find(this.plans, function (plan) {
                  return plan.id == self.subscribeForm.plan;
              });
          },
  
          /*
           * Get the full selected plan price with currency symbol.
           */
          selectedPlanPrice: function selectedPlanPrice() {
              if (this.selectedPlan) {
                  return this.selectedPlan.currencySymbol + this.selectedPlan.price;
              }
          },
  
          /*
           * Get all of the plans that have a mnthly interval.
           */
          monthlyPlans: function monthlyPlans() {
              return _.filter(this.plans, function (plan) {
                  return plan.interval == 'monthly' && plan.active;
              });
          },
  
          /*
           * Get all of the plans that have a yearly interval.
           */
          yearlyPlans: function yearlyPlans() {
              return _.filter(this.plans, function (plan) {
                  return plan.interval == 'yearly' && plan.active;
              });
          },
  
          /*
           * Get all of the "default" available plans. Typically this is monthly.
           */
          defaultPlans: function defaultPlans() {
              if (this.monthlyPlans.length > 0) {
                  return this.monthlyPlans;
              }
  
              if (this.yearlyPlans.length > 0) {
                  return this.yearlyPlans;
              }
          },
  
          /*
           * Get all of the available plans except this user's current plan.
           * This'll typically be the monthly plans unless there are none.
           */
          defaultPlansExceptCurrent: function defaultPlansExceptCurrent() {
              if (this.monthlyPlansExceptCurrent.length > 0) {
                  return this.monthlyPlansExceptCurrent;
              }
  
              if (this.yearlyPlansExceptCurrent.length > 0) {
                  return this.yearlyPlansExceptCurrent;
              }
          },
  
          /*
           * Get all of the monthly plans except the user's current plan.
           */
          monthlyPlansExceptCurrent: function monthlyPlansExceptCurrent() {
              var self = this;
  
              if (!this.currentPlan) {
                  return [];
              }
  
              return _.filter(this.monthlyPlans, function (plan) {
                  return plan.id != self.currentPlan.id;
              });
          },
  
          /*
           * Get all of the yearly plans except the user's current plan.
           */
          yearlyPlansExceptCurrent: function yearlyPlansExceptCurrent() {
              var self = this;
  
              if (!this.currentPlan) {
                  return [];
              }
  
              return _.filter(this.yearlyPlans, function (plan) {
                  return plan.id != self.currentPlan.id;
              });
          },
  
          /*
           * Get the expiratoin date for the current coupon in displayable form.
           */
          currentCouponDisplayDiscount: function currentCouponDisplayDiscount() {
              if (this.currentCoupon) {
                  if (this.currentCoupon.amountOff) {
                      return this.currentPlan.currencySymbol + this.currentCoupon.amountOff;
                  }
  
                  if (this.currentCoupon.percentOff) {
                      return this.currentCoupon.percentOff + '%';
                  }
              }
          },
  
          /*
           * Get the expiratoin date for the current coupon in displayable form.
           */
          currentCouponDisplayExpiresOn: function currentCouponDisplayExpiresOn() {
              return moment(this.currentCoupon.expiresOn).format('MMMM Do, YYYY');
          }
      },
  
      events: {
          /**
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              this.extraBillingInfoForm.text = this.user.extra_billing_info;
  
              if (this.user.stripe_id) {
                  this.getCoupon();
              }
  
              return true;
          }
      },
  
      methods: {
          /*
           * Get the coupon currently applying to the customer.
           */
          getCoupon: function getCoupon() {
              this.$http.get('spark/api/subscriptions/user/coupon').success(function (coupon) {
                  this.currentCoupon = coupon;
              });
          },
  
          /*
           * Get all of the Spark plans from the API.
           */
          getPlans: function getPlans() {
              this.$http.get('spark/api/subscriptions/plans').success(function (plans) {
                  this.plans = plans;
              });
          },
  
          /*
           * Subscribe the user to a new plan.
           */
          subscribe: function subscribe() {
              var self = this;
  
              this.cardForm.fullErrors = {};
              this.cardForm.errors = [];
  
              this.subscribeForm.fullErrors = {};
              this.subscribeForm.errors = [];
  
              this.subscribeForm.busy = true;
  
              /*
               * Here we will build the payload to send to Stripe, which will
               * return a token. This token can be used to make charges on
               *  the user's credit cards instead of storing the numbers.
               */
              var payload = {
                  name: this.user.name,
                  number: this.cardForm.number,
                  cvc: this.cardForm.cvc,
                  exp_month: this.cardForm.month,
                  exp_year: this.cardForm.year,
                  address_zip: this.cardForm.zip
              };
  
              Stripe.card.createToken(payload, function (status, response) {
                  if (response.error) {
                      self.cardForm.fullErrors = { number: [response.error.message] };
                      self.cardForm.errors = [response.error.message];
  
                      self.subscribeForm.busy = false;
                  } else {
                      self.subscribeForm.stripe_token = response.id;
                      self.sendSubscription();
                  }
              });
          },
  
          /*
           * Subscribe the user to a new plan.
           */
          sendSubscription: function sendSubscription() {
              var self = this;
  
              Spark.post('/settings/user/plan', this.subscribeForm).then(function () {
                  self.$dispatch('updateUser');
              });
          },
  
          /*
           * Reset the subscription form plan to allow another plan to be selected.
           */
          selectAnotherPlan: function selectAnotherPlan() {
              this.subscribeForm.plan = '';
          },
  
          /*
           * Show the modal screen to select another subscription plan.
           */
          confirmPlanChange: function confirmPlanChange() {
              this.changePlanForm.errors = [];
              this.changePlanForm.changing = false;
  
              $('#modal-change-plan').modal('show');
  
              this.initializeTooltips();
          },
  
          /*
           * Subscribe the user to another subscription plan.
           */
          changePlan: function changePlan() {
              var self = this;
  
              Spark.put('/settings/user/plan', this.changePlanForm).then(function () {
                  self.$dispatch('updateUser');
  
                  /*
                   * We need to re-initialize the tooltips on the screen because
                   * some of the plans may not have been displayed yet if the
                   * users just "switched" plans to another available plan.
                   */
                  self.initializeTooltips();
  
                  $('#modal-change-plan').modal('hide');
              });
          },
  
          /*
           * Update the user's subscription billing card (Stripe portion).
           */
          updateCard: function updateCard() {
              var self = this;
  
              this.updateCardForm.errors = [];
              this.updateCardForm.updated = false;
              this.updateCardForm.updating = true;
  
              /*
               * Here we will build the payload to send to Stripe, which will
               * return a token. This token can be used to make charges on
               * the user's credit cards instead of storing the numbers.
               */
              var payload = {
                  name: this.user.name,
                  number: this.updateCardForm.number,
                  cvc: this.updateCardForm.cvc,
                  exp_month: this.updateCardForm.month,
                  exp_year: this.updateCardForm.year,
                  address_zip: this.updateCardForm.zip
              };
  
              Stripe.card.createToken(payload, function (status, response) {
                  if (response.error) {
                      self.updateCardForm.fullErrors = { number: [response.error.message] };
                      self.updateCardForm.errors = [response.error.message];
  
                      self.updateCardForm.updating = false;
                  } else {
                      self.updateCardUsingToken(response.id);
                  }
              });
          },
  
          /*
           * Update the user's subscription billing card.
           */
          updateCardUsingToken: function updateCardUsingToken(token) {
              this.$http.put('settings/user/card', { stripe_token: token }).success(function () {
                  this.$dispatch('updateUser');
  
                  this.updateCardForm = settingsSubscriptionScreenForms.updateCard();
                  this.updateCardForm.updated = true;
              }).error(function (errors) {
                  this.updateCardForm.updating = false;
                  Spark.setErrorsOnForm(this.updateCardForm, errors);
              });
          },
  
          /*
           * Update the user's extra billing information.
           */
          updateExtraBillingInfo: function updateExtraBillingInfo() {
              Spark.put('/settings/user/vat', this.extraBillingInfoForm);
          },
  
          /*
           * Display the modal window to confirm subscription deletion.
           */
          confirmSubscriptionCancellation: function confirmSubscriptionCancellation() {
              $('#modal-cancel-subscription').modal('show');
          },
  
          /*
           * Cancel the user's subscription with Stripe.
           */
          cancelSubscription: function cancelSubscription() {
              var self = this;
  
              Spark['delete']('/settings/user/plan', this.cancelSubscriptionForm).then(function () {
                  self.$dispatch('updateUser');
  
                  $('#modal-cancel-subscription').modal('hide');
  
                  setTimeout(function () {
                      self.cancelSubscriptionForm.cancelling = false;
                  }, 500);
              });
          },
  
          /*
           * Resume the user's subscription on Stripe.
           */
          resumeSubscription: function resumeSubscription() {
              var self = this;
  
              Spark.post('/settings/user/plan/resume', this.resumeSubscriptionForm).then(function () {
                  self.$dispatch('updateUser');
              });
          },
  
          /*
           * Get the feature list from the plan formatted for a tooltip.
           */
          getPlanFeaturesForTooltip: function getPlanFeaturesForTooltip(plan) {
              var result = '<ul>';
  
              _.each(plan.features, function (feature) {
                  result += '<li>' + feature + '</li>';
              });
  
              return result + '</ul>';
          },
  
          /*
           * Initialize the tooltips for the plan features.
           */
          initializeTooltips: function initializeTooltips() {
              setTimeout(function () {
                  $('[data-toggle="tooltip"]').tooltip({
                      html: true
                  });
              }, 250);
          }
      }
  });
  
  },{}],106:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-settings-teams-screen', {
      mixins: [Spark.helpers],
  
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          this.getInvitations();
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
              teams: [],
              invitations: [],
  
              teamToDelete: null,
  
              createTeamForm: new SparkForm({
                  name: ''
              }),
  
              deleteTeamForm: new SparkForm({})
          };
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              return true;
          },
  
          /*
           * Handle the "teamsRetrieved" event.
           */
          teamsRetrieved: function teamsRetrieved(teams) {
              this.teams = teams;
  
              return true;
          }
      },
  
      methods: {
          /*
           * Get all of the user's pending invitations from the API.
           */
          getInvitations: function getInvitations() {
              this.$http.get('/spark/api/teams/invitations').success(function (invitations) {
                  this.invitations = invitations;
              });
          },
  
          /**
           * Create a new team.
           */
          createTeam: function createTeam() {
              var self = this;
  
              Spark.post('/settings/teams', this.createTeamForm).then(function () {
                  self.createTeamForm.name = '';
  
                  self.$dispatch('updateUser');
                  self.$dispatch('updateTeams');
              });
          },
  
          /*
           * Leave the team.
           */
          leaveTeam: function leaveTeam(team) {
              this.teams = _.reject(this.teams, function (t) {
                  return t.id == team.id;
              });
  
              this.$http['delete']('/settings/teams/' + team.id + '/membership').success(function () {
                  this.$dispatch('updateUser');
                  this.$dispatch('updateTeams');
              });
          },
  
          /*
           * Confirm that the user really wants to delete the team.
           */
          confirmTeamDeletion: function confirmTeamDeletion(team) {
              this.teamToDelete = team;
  
              $('#modal-delete-team').modal('show');
          },
  
          /*
           * Delete the given team.
           */
          deleteTeam: function deleteTeam() {
              var self = this;
  
              Spark['delete']('/settings/teams/' + this.teamToDelete.id, this.deleteTeamForm).then(function () {
                  $('#modal-delete-team').modal('hide');
  
                  self.$dispatch('updateUser');
                  self.$dispatch('updateTeams');
              });
          },
  
          /*
           * Accept a pending invitation.
           */
          acceptInvite: function acceptInvite(invite) {
              this.invitations = _.reject(this.invitations, function (i) {
                  return i.id == invite.id;
              });
  
              this.$http.post('/settings/teams/invitations/' + invite.id + '/accept').success(function () {
                  this.$dispatch('updateUser');
                  this.$dispatch('updateTeams');
              });
          },
  
          /*
           * Reject a pending invitation.
           */
          rejectInvite: function rejectInvite(invite) {
              this.invitations = _.reject(this.invitations, function (i) {
                  return i.id == invite.id;
              });
  
              this.$http['delete']('settings/teams/invitations/' + invite.id);
          },
  
          /*
           * Determine if the current user owns the given team.
           */
          userOwns: function userOwns(team) {
              if (!this.user) {
                  return false;
              }
  
              return this.user.id === team.owner_id;
          }
      }
  });
  
  },{}],107:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-team-settings-screen', {
  	/*
    * Bootstrap the component. Load the initial data.
    */
  	ready: function ready() {
  		this.getTeam();
  		this.getRoles();
  	},
  
  	/*
    * Initial state of the component's data.
    */
  	data: function data() {
  		return { team: null };
  	},
  
  	events: {
  		/*
     * Handle the "updateTeam" event. Re-retrieve the team.
     */
  		updateTeam: function updateTeam() {
  			this.getTeam();
  
  			return true;
  		}
  	},
  
  	methods: {
  		/*
     * Get the team from the API.
     */
  		getTeam: function getTeam() {
  			this.$http.get('/spark/api/teams/' + TEAM_ID).success(function (team) {
  				this.team = team;
  
  				this.$broadcast('teamRetrieved', team);
  			});
  		},
  
  		/**
     * Get all of the roles that may be assigned to users.
     */
  		getRoles: function getRoles() {
  			this.$http.get('/spark/api/teams/roles').success(function (roles) {
  				this.roles = roles;
  
  				this.$broadcast('rolesRetrieved', roles);
  			});
  		}
  	}
  });
  
  },{}],108:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-team-settings-membership-screen', {
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          //
      },
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
              team: null,
              roles: [],
              leavingTeam: false,
  
              editingTeamMember: null,
  
              sendInviteForm: new SparkForm({
                  email: ''
              })
          };
      },
  
      computed: {
          /*
           * Determine if all necessary data has been loaded.
           */
          everythingIsLoaded: function everythingIsLoaded() {
              return this.user && this.team && this.roles.length > 0;
          },
  
          /*
           * Get all users except for the current user.
           */
          teamMembersExceptMe: function teamMembersExceptMe() {
              var self = this;
  
              return _.reject(this.team.users, function (user) {
                  return user.id === self.user.id;
              });
          }
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              return true;
          },
  
          /*
           * Handle the "teamRetrieved" event.
           */
          teamRetrieved: function teamRetrieved(team) {
              this.team = team;
  
              return true;
          },
  
          /*
           * Handle the "rolesRetrieved" event.
           */
          rolesRetrieved: function rolesRetrieved(roles) {
              this.roles = roles;
  
              return true;
          }
      },
  
      methods: {
          /*
           * Send an invitation to a new user.
           */
          sendInvite: function sendInvite() {
              var self = this;
  
              Spark.post('/settings/teams/' + this.team.id + '/invitations', this.sendInviteForm).then(function () {
                  self.$dispatch('updateTeam');
  
                  self.sendInviteForm.email = '';
              });
          },
  
          /*
           * Cancel an existing invitation.
           */
          cancelInvite: function cancelInvite(invite) {
              this.team.invitations = _.reject(this.team.invitations, function (i) {
                  return i.id === invite.id;
              });
  
              this.$http['delete']('/settings/teams/' + this.team.id + '/invitations/' + invite.id).success(function () {
                  this.$dispatch('updateTeam');
              });
          },
  
          /*
           * Edit an existing team member.
           */
          editTeamMember: function editTeamMember(member) {
              this.editingTeamMember = member;
  
              $('#modal-edit-team-member').modal('show');
          },
  
          /*
           * Remove an existing team member from the team.
           */
          removeTeamMember: function removeTeamMember(teamMember) {
              this.team.users = _.reject(this.team.users, function (u) {
                  return u.id == teamMember.id;
              });
  
              this.$http['delete']('/settings/teams/' + this.team.id + '/members/' + teamMember.id).success(function () {
                  this.$dispatch('updateTeam');
              });
          },
  
          /*
           * Leave the team.
           */
          leaveTeam: function leaveTeam() {
              this.leavingTeam = true;
  
              this.$http['delete']('/settings/teams/' + this.team.id + '/membership').success(function () {
                  window.location = '/settings?tab=teams';
              });
          },
  
          /*
           * Determine if the current user owns the given team.
           */
          userOwns: function userOwns(team) {
              if (!this.user) {
                  return false;
              }
  
              return this.user.id === team.owner_id;
          }
      },
  
      filters: {
          /**
           * Filter the role to its displayable name.
           */
          role: function role(value) {
              return _.find(this.roles, function (role) {
                  return role.value == value;
              }).text;
          }
      }
  });
  
  },{}],109:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-team-settings-edit-team-member-screen', {
      props: ['teamMember'],
  
      /*
       * Initial state of the component's data.
       */
      data: function data() {
          return {
              user: null,
              team: null,
              roles: [],
  
              updateTeamMemberForm: new SparkForm({
                  role: ''
              })
          };
      },
  
      watch: {
          /**
           * Watch for updates to the "teamMember" data.
           */
          'teamMember': function teamMember(member) {
              this.updateTeamMemberForm.role = member.pivot.role;
          }
      },
  
      computed: {
          /**
           * Get the roles that may be assigned to users.
           */
          assignableRoles: function assignableRoles() {
              return _.reject(this.roles, function (role) {
                  return role.value == 'owner';
              });
          }
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              return true;
          },
  
          /*
           * Handle the "teamRetrieved" event.
           */
          teamRetrieved: function teamRetrieved(team) {
              this.team = team;
  
              return true;
          },
  
          /*
           * Handle the "rolesRetrieved" event.
           */
          rolesRetrieved: function rolesRetrieved(roles) {
              this.roles = roles;
  
              return true;
          }
      },
  
      methods: {
          /*
           * Edit a given team member.
           */
          updateTeamMember: function updateTeamMember() {
              var self = this;
  
              Spark.put('/settings/teams/' + this.team.id + '/members/' + this.teamMember.id, this.updateTeamMemberForm).then(function () {
                  self.$dispatch('updateTeam');
  
                  $('#modal-edit-team-member').modal('hide');
              });
          }
      }
  });
  
  },{}],110:[function(require,module,exports){
  'use strict';
  
  Vue.component('spark-team-settings-owner-screen', {
      /*
       * Bootstrap the component. Load the initial data.
       */
      ready: function ready() {
          //
      },
  
      data: function data() {
          return {
              user: null,
              team: null,
  
              updateTeamForm: new SparkForm({
                  name: ''
              })
          };
      },
  
      events: {
          /*
           * Handle the "userRetrieved" event.
           */
          userRetrieved: function userRetrieved(user) {
              this.user = user;
  
              return true;
          },
  
          /*
           * Handle the "teamRetrieved" event.
           */
          teamRetrieved: function teamRetrieved(team) {
              this.team = team;
  
              this.updateTeamForm.name = this.team.name;
  
              return true;
          }
      },
  
      methods: {
          /**
           * Update the team's information.
           */
          updateTeam: function updateTeam() {
              var self = this;
  
              Spark.put('/settings/teams/' + this.team.id, this.updateTeamForm).then(function () {
                  self.$dispatch('updateTeam');
                  self.$dispatch('updateTeams');
              });
          }
      }
  });
  
  },{}],111:[function(require,module,exports){
  /**
   * Load the Spark form utilities.
   */
  'use strict';
  
  require('./core/form-utils');
  require('./core/form-fields');
  
  /*
   * Load the Spark components.
   */
  require('./core/components');
  
  /**
   * Export the Spark application.
   */
  module.exports = {
      el: '#spark-app',
  
      components: require('../components/components'),
  
      /*
       * Bootstrap the application. Load the initial data.
       */
      ready: function ready() {
          $(function () {
              $('.spark-first-field').filter(':visible:first').focus();
          });
  
          if (Spark.userId) {
              this.getUser();
          }
  
          if (Spark.currentTeamId) {
              this.getTeams();
              this.getCurrentTeam();
          }
  
          this.whenReady();
      },
  
      events: {
          /**
           * Handle requests to update the current user from a child component.
           */
          updateUser: function updateUser() {
              this.getUser();
  
              return true;
          },
  
          /**
           * Handle requests to update the teams from a child component.
           */
          updateTeams: function updateTeams() {
              this.getTeams();
  
              return true;
          },
  
          /**
           * Receive an updated team list from a child component.
           */
          updateTeams: function updateTeams() {
              this.getTeams();
  
              return true;
          }
      },
  
      methods: {
          /**
           * This method would be overridden by developer.
           */
          whenReady: function whenReady() {
              //
          },
  
          /**
           * Retrieve the user from the API and broadcast it to children.
           */
          getUser: function getUser() {
              this.$http.get('/spark/api/users/me').success(function (user) {
                  this.$broadcast('userRetrieved', user);
              });
          },
  
          /*
           * Get all of the user's current teams from the API.
           */
          getTeams: function getTeams() {
              this.$http.get('/spark/api/teams').success(function (teams) {
                  this.$broadcast('teamsRetrieved', teams);
              });
          },
  
          /*
           * Get the user's current team from the API.
           */
          getCurrentTeam: function getCurrentTeam() {
              this.$http.get('/spark/api/teams/' + Spark.currentTeamId).success(function (team) {
                  this.$broadcast('currentTeamRetrieved', team);
              });
          }
      }
  };
  
  },{"../components/components":88,"./core/components":96,"./core/form-fields":98,"./core/form-utils":99}]},{},[87]);
  
  //# sourceMappingURL=app.js.map
  