Merge afb-client

24 files changed, 13852 insertions, 0 deletions

diff --git a/afb-client/bower_components/tether/examples/chosen/chosen-sprite.png b/afb-client/bower_components/tether/examples/chosen/chosen-sprite.png
new file mode 100644
index 0000000..3611ae4
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/chosen/chosen-sprite.png
diff --git a/afb-client/bower_components/tether/examples/chosen/chosen.css b/afb-client/bower_components/tether/examples/chosen/chosen.css
new file mode 100644
index 0000000..828fe1f
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/chosen/chosen.css
@@ -0,0 +1,430 @@
+/* @group Base */
+.chosen-container {
+  position: relative;
+  display: inline-block;
+  vertical-align: middle;
+  font-size: 13px;
+  zoom: 1;
+  *display: inline;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  user-select: none;
+}
+.chosen-container .chosen-drop {
+  position: absolute;
+  top: 100%;
+  left: -9999px;
+  z-index: 1010;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  width: 100%;
+  border: 1px solid #aaa;
+  border-top: 0;
+  background: #fff;
+  box-shadow: 0 4px 5px rgba(0, 0, 0, 0.15);
+}
+.chosen-container.chosen-with-drop .chosen-drop {
+  left: 0;
+}
+.chosen-container a {
+  cursor: pointer;
+}
+
+/* @end */
+/* @group Single Chosen */
+.chosen-container-single .chosen-single {
+  position: relative;
+  display: block;
+  overflow: hidden;
+  padding: 0 0 0 8px;
+  height: 23px;
+  border: 1px solid #aaa;
+  border-radius: 5px;
+  background-color: #fff;
+  background: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(20%, #ffffff), color-stop(50%, #f6f6f6), color-stop(52%, #eeeeee), color-stop(100%, #f4f4f4));
+  background: -webkit-linear-gradient(top, #ffffff 20%, #f6f6f6 50%, #eeeeee 52%, #f4f4f4 100%);
+  background: -moz-linear-gradient(top, #ffffff 20%, #f6f6f6 50%, #eeeeee 52%, #f4f4f4 100%);
+  background: -o-linear-gradient(top, #ffffff 20%, #f6f6f6 50%, #eeeeee 52%, #f4f4f4 100%);
+  background: linear-gradient(top, #ffffff 20%, #f6f6f6 50%, #eeeeee 52%, #f4f4f4 100%);
+  background-clip: padding-box;
+  box-shadow: 0 0 3px white inset, 0 1px 1px rgba(0, 0, 0, 0.1);
+  color: #444;
+  text-decoration: none;
+  white-space: nowrap;
+  line-height: 24px;
+}
+.chosen-container-single .chosen-default {
+  color: #999;
+}
+.chosen-container-single .chosen-single span {
+  display: block;
+  overflow: hidden;
+  margin-right: 26px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.chosen-container-single .chosen-single-with-deselect span {
+  margin-right: 38px;
+}
+.chosen-container-single .chosen-single abbr {
+  position: absolute;
+  top: 6px;
+  right: 26px;
+  display: block;
+  width: 12px;
+  height: 12px;
+  background: url('chosen-sprite.png') -42px 1px no-repeat;
+  font-size: 1px;
+}
+.chosen-container-single .chosen-single abbr:hover {
+  background-position: -42px -10px;
+}
+.chosen-container-single.chosen-disabled .chosen-single abbr:hover {
+  background-position: -42px -10px;
+}
+.chosen-container-single .chosen-single div {
+  position: absolute;
+  top: 0;
+  right: 0;
+  display: block;
+  width: 18px;
+  height: 100%;
+}
+.chosen-container-single .chosen-single div b {
+  display: block;
+  width: 100%;
+  height: 100%;
+  background: url('chosen-sprite.png') no-repeat 0px 2px;
+}
+.chosen-container-single .chosen-search {
+  position: relative;
+  z-index: 1010;
+  margin: 0;
+  padding: 3px 4px;
+  white-space: nowrap;
+}
+.chosen-container-single .chosen-search input[type="text"] {
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  margin: 1px 0;
+  padding: 4px 20px 4px 5px;
+  width: 100%;
+  height: auto;
+  outline: 0;
+  border: 1px solid #aaa;
+  background: white url('chosen-sprite.png') no-repeat 100% -20px;
+  background: url('chosen-sprite.png') no-repeat 100% -20px, -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(1%, #eeeeee), color-stop(15%, #ffffff));
+  background: url('chosen-sprite.png') no-repeat 100% -20px, -webkit-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat 100% -20px, -moz-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat 100% -20px, -o-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat 100% -20px, linear-gradient(#eeeeee 1%, #ffffff 15%);
+  font-size: 1em;
+  font-family: sans-serif;
+  line-height: normal;
+  border-radius: 0;
+}
+.chosen-container-single .chosen-drop {
+  margin-top: -1px;
+  border-radius: 0 0 4px 4px;
+  background-clip: padding-box;
+}
+.chosen-container-single.chosen-container-single-nosearch .chosen-search {
+  position: absolute;
+  left: -9999px;
+}
+
+/* @end */
+/* @group Results */
+.chosen-container .chosen-results {
+  position: relative;
+  overflow-x: hidden;
+  overflow-y: auto;
+  margin: 0 4px 4px 0;
+  padding: 0 0 0 4px;
+  max-height: 240px;
+  -webkit-overflow-scrolling: touch;
+}
+.chosen-container .chosen-results li {
+  display: none;
+  margin: 0;
+  padding: 5px 6px;
+  list-style: none;
+  line-height: 15px;
+}
+.chosen-container .chosen-results li.active-result {
+  display: list-item;
+  cursor: pointer;
+}
+.chosen-container .chosen-results li.disabled-result {
+  display: list-item;
+  color: #ccc;
+  cursor: default;
+}
+.chosen-container .chosen-results li.highlighted {
+  background-color: #3875d7;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(20%, #3875d7), color-stop(90%, #2a62bc));
+  background-image: -webkit-linear-gradient(#3875d7 20%, #2a62bc 90%);
+  background-image: -moz-linear-gradient(#3875d7 20%, #2a62bc 90%);
+  background-image: -o-linear-gradient(#3875d7 20%, #2a62bc 90%);
+  background-image: linear-gradient(#3875d7 20%, #2a62bc 90%);
+  color: #fff;
+}
+.chosen-container .chosen-results li.no-results {
+  display: list-item;
+  background: #f4f4f4;
+}
+.chosen-container .chosen-results li.group-result {
+  display: list-item;
+  font-weight: bold;
+  cursor: default;
+}
+.chosen-container .chosen-results li.group-option {
+  padding-left: 15px;
+}
+.chosen-container .chosen-results li em {
+  font-style: normal;
+  text-decoration: underline;
+}
+
+/* @end */
+/* @group Multi Chosen */
+.chosen-container-multi .chosen-choices {
+  position: relative;
+  overflow: hidden;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: auto !important;
+  height: 1%;
+  border: 1px solid #aaa;
+  background-color: #fff;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(1%, #eeeeee), color-stop(15%, #ffffff));
+  background-image: -webkit-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background-image: -moz-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background-image: -o-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background-image: linear-gradient(#eeeeee 1%, #ffffff 15%);
+  cursor: text;
+}
+.chosen-container-multi .chosen-choices li {
+  float: left;
+  list-style: none;
+}
+.chosen-container-multi .chosen-choices li.search-field {
+  margin: 0;
+  padding: 0;
+  white-space: nowrap;
+}
+.chosen-container-multi .chosen-choices li.search-field input[type="text"] {
+  margin: 1px 0;
+  padding: 5px;
+  height: 15px;
+  outline: 0;
+  border: 0 !important;
+  background: transparent !important;
+  box-shadow: none;
+  color: #666;
+  font-size: 100%;
+  font-family: sans-serif;
+  line-height: normal;
+  border-radius: 0;
+}
+.chosen-container-multi .chosen-choices li.search-field .default {
+  color: #999;
+}
+.chosen-container-multi .chosen-choices li.search-choice {
+  position: relative;
+  margin: 3px 0 3px 5px;
+  padding: 3px 20px 3px 5px;
+  border: 1px solid #aaa;
+  border-radius: 3px;
+  background-color: #e4e4e4;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(20%, #f4f4f4), color-stop(50%, #f0f0f0), color-stop(52%, #e8e8e8), color-stop(100%, #eeeeee));
+  background-image: -webkit-linear-gradient(#f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: -moz-linear-gradient(#f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: -o-linear-gradient(#f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: linear-gradient(#f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-clip: padding-box;
+  box-shadow: 0 0 2px white inset, 0 1px 0 rgba(0, 0, 0, 0.05);
+  color: #333;
+  line-height: 13px;
+  cursor: default;
+}
+.chosen-container-multi .chosen-choices li.search-choice .search-choice-close {
+  position: absolute;
+  top: 4px;
+  right: 3px;
+  display: block;
+  width: 12px;
+  height: 12px;
+  background: url('chosen-sprite.png') -42px 1px no-repeat;
+  font-size: 1px;
+}
+.chosen-container-multi .chosen-choices li.search-choice .search-choice-close:hover {
+  background-position: -42px -10px;
+}
+.chosen-container-multi .chosen-choices li.search-choice-disabled {
+  padding-right: 5px;
+  border: 1px solid #ccc;
+  background-color: #e4e4e4;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(20%, #f4f4f4), color-stop(50%, #f0f0f0), color-stop(52%, #e8e8e8), color-stop(100%, #eeeeee));
+  background-image: -webkit-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: -moz-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: -o-linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  background-image: linear-gradient(top, #f4f4f4 20%, #f0f0f0 50%, #e8e8e8 52%, #eeeeee 100%);
+  color: #666;
+}
+.chosen-container-multi .chosen-choices li.search-choice-focus {
+  background: #d4d4d4;
+}
+.chosen-container-multi .chosen-choices li.search-choice-focus .search-choice-close {
+  background-position: -42px -10px;
+}
+.chosen-container-multi .chosen-results {
+  margin: 0;
+  padding: 0;
+}
+.chosen-container-multi .chosen-drop .result-selected {
+  display: list-item;
+  color: #ccc;
+  cursor: default;
+}
+
+/* @end */
+/* @group Active  */
+.chosen-container-active .chosen-single {
+  border: 1px solid #5897fb;
+  box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
+}
+.chosen-container-active.chosen-with-drop .chosen-single {
+  border: 1px solid #aaa;
+  -moz-border-radius-bottomright: 0;
+  border-bottom-right-radius: 0;
+  -moz-border-radius-bottomleft: 0;
+  border-bottom-left-radius: 0;
+  background-image: -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(20%, #eeeeee), color-stop(80%, #ffffff));
+  background-image: -webkit-linear-gradient(#eeeeee 20%, #ffffff 80%);
+  background-image: -moz-linear-gradient(#eeeeee 20%, #ffffff 80%);
+  background-image: -o-linear-gradient(#eeeeee 20%, #ffffff 80%);
+  background-image: linear-gradient(#eeeeee 20%, #ffffff 80%);
+  box-shadow: 0 1px 0 #fff inset;
+}
+.chosen-container-active.chosen-with-drop .chosen-single div {
+  border-left: none;
+  background: transparent;
+}
+.chosen-container-active.chosen-with-drop .chosen-single div b {
+  background-position: -18px 2px;
+}
+.chosen-container-active .chosen-choices {
+  border: 1px solid #5897fb;
+  box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
+}
+.chosen-container-active .chosen-choices li.search-field input[type="text"] {
+  color: #111 !important;
+}
+
+/* @end */
+/* @group Disabled Support */
+.chosen-disabled {
+  opacity: 0.5 !important;
+  cursor: default;
+}
+.chosen-disabled .chosen-single {
+  cursor: default;
+}
+.chosen-disabled .chosen-choices .search-choice .search-choice-close {
+  cursor: default;
+}
+
+/* @end */
+/* @group Right to Left */
+.chosen-rtl {
+  text-align: right;
+}
+.chosen-rtl .chosen-single {
+  overflow: visible;
+  padding: 0 8px 0 0;
+}
+.chosen-rtl .chosen-single span {
+  margin-right: 0;
+  margin-left: 26px;
+  direction: rtl;
+}
+.chosen-rtl .chosen-single-with-deselect span {
+  margin-left: 38px;
+}
+.chosen-rtl .chosen-single div {
+  right: auto;
+  left: 3px;
+}
+.chosen-rtl .chosen-single abbr {
+  right: auto;
+  left: 26px;
+}
+.chosen-rtl .chosen-choices li {
+  float: right;
+}
+.chosen-rtl .chosen-choices li.search-field input[type="text"] {
+  direction: rtl;
+}
+.chosen-rtl .chosen-choices li.search-choice {
+  margin: 3px 5px 3px 0;
+  padding: 3px 5px 3px 19px;
+}
+.chosen-rtl .chosen-choices li.search-choice .search-choice-close {
+  right: auto;
+  left: 4px;
+}
+.chosen-rtl.chosen-container-single-nosearch .chosen-search,
+.chosen-rtl .chosen-drop {
+  left: 9999px;
+}
+.chosen-rtl.chosen-container-single .chosen-results {
+  margin: 0 0 4px 4px;
+  padding: 0 4px 0 0;
+}
+.chosen-rtl .chosen-results li.group-option {
+  padding-right: 15px;
+  padding-left: 0;
+}
+.chosen-rtl.chosen-container-active.chosen-with-drop .chosen-single div {
+  border-right: none;
+}
+.chosen-rtl .chosen-search input[type="text"] {
+  padding: 4px 5px 4px 20px;
+  background: white url('chosen-sprite.png') no-repeat -30px -20px;
+  background: url('chosen-sprite.png') no-repeat -30px -20px, -webkit-gradient(linear, 50% 0%, 50% 100%, color-stop(1%, #eeeeee), color-stop(15%, #ffffff));
+  background: url('chosen-sprite.png') no-repeat -30px -20px, -webkit-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat -30px -20px, -moz-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat -30px -20px, -o-linear-gradient(#eeeeee 1%, #ffffff 15%);
+  background: url('chosen-sprite.png') no-repeat -30px -20px, linear-gradient(#eeeeee 1%, #ffffff 15%);
+  direction: rtl;
+}
+.chosen-rtl.chosen-container-single .chosen-single div b {
+  background-position: 6px 2px;
+}
+.chosen-rtl.chosen-container-single.chosen-with-drop .chosen-single div b {
+  background-position: -12px 2px;
+}
+
+/* @end */
+/* @group Retina compatibility */
+@media only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min-resolution: 144dpi) {
+  .chosen-rtl .chosen-search input[type="text"],
+  .chosen-container-single .chosen-single abbr,
+  .chosen-container-single .chosen-single div b,
+  .chosen-container-single .chosen-search input[type="text"],
+  .chosen-container-multi .chosen-choices .search-choice .search-choice-close,
+  .chosen-container .chosen-results-scroll-down span,
+  .chosen-container .chosen-results-scroll-up span {
+    background-image: url('chosen-sprite@2x.png') !important;
+    background-size: 52px 37px !important;
+    background-repeat: no-repeat !important;
+  }
+}
+/* @end */
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/chosen/chosen.js b/afb-client/bower_components/tether/examples/chosen/chosen.js
new file mode 100644
index 0000000..521556b
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/chosen/chosen.js
@@ -0,0 +1,1166 @@
+// Chosen, a Select Box Enhancer for jQuery and Prototype
+// by Patrick Filler for Harvest, http://getharvest.com
+//
+// Version 1.0.0
+// Full source at https://github.com/harvesthq/chosen
+// Copyright (c) 2011 Harvest http://getharvest.com
+
+// MIT License, https://github.com/harvesthq/chosen/blob/master/LICENSE.md
+// This file is generated by `grunt build`, do not edit it by hand.
+(function() {
+  var $, AbstractChosen, Chosen, SelectParser, _ref,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  SelectParser = (function() {
+    function SelectParser() {
+      this.options_index = 0;
+      this.parsed = [];
+    }
+
+    SelectParser.prototype.add_node = function(child) {
+      if (child.nodeName.toUpperCase() === "OPTGROUP") {
+        return this.add_group(child);
+      } else {
+        return this.add_option(child);
+      }
+    };
+
+    SelectParser.prototype.add_group = function(group) {
+      var group_position, option, _i, _len, _ref, _results;
+
+      group_position = this.parsed.length;
+      this.parsed.push({
+        array_index: group_position,
+        group: true,
+        label: this.escapeExpression(group.label),
+        children: 0,
+        disabled: group.disabled
+      });
+      _ref = group.childNodes;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        option = _ref[_i];
+        _results.push(this.add_option(option, group_position, group.disabled));
+      }
+      return _results;
+    };
+
+    SelectParser.prototype.add_option = function(option, group_position, group_disabled) {
+      if (option.nodeName.toUpperCase() === "OPTION") {
+        if (option.text !== "") {
+          if (group_position != null) {
+            this.parsed[group_position].children += 1;
+          }
+          this.parsed.push({
+            array_index: this.parsed.length,
+            options_index: this.options_index,
+            value: option.value,
+            text: option.text,
+            html: option.innerHTML,
+            selected: option.selected,
+            disabled: group_disabled === true ? group_disabled : option.disabled,
+            group_array_index: group_position,
+            classes: option.className,
+            style: option.style.cssText
+          });
+        } else {
+          this.parsed.push({
+            array_index: this.parsed.length,
+            options_index: this.options_index,
+            empty: true
+          });
+        }
+        return this.options_index += 1;
+      }
+    };
+
+    SelectParser.prototype.escapeExpression = function(text) {
+      var map, unsafe_chars;
+
+      if ((text == null) || text === false) {
+        return "";
+      }
+      if (!/[\&\<\>\"\'\`]/.test(text)) {
+        return text;
+      }
+      map = {
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#x27;",
+        "`": "&#x60;"
+      };
+      unsafe_chars = /&(?!\w+;)|[\<\>\"\'\`]/g;
+      return text.replace(unsafe_chars, function(chr) {
+        return map[chr] || "&amp;";
+      });
+    };
+
+    return SelectParser;
+
+  })();
+
+  SelectParser.select_to_array = function(select) {
+    var child, parser, _i, _len, _ref;
+
+    parser = new SelectParser();
+    _ref = select.childNodes;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      child = _ref[_i];
+      parser.add_node(child);
+    }
+    return parser.parsed;
+  };
+
+  AbstractChosen = (function() {
+    function AbstractChosen(form_field, options) {
+      this.form_field = form_field;
+      this.options = options != null ? options : {};
+      if (!AbstractChosen.browser_is_supported()) {
+        return;
+      }
+      this.is_multiple = this.form_field.multiple;
+      this.set_default_text();
+      this.set_default_values();
+      this.setup();
+      this.set_up_html();
+      this.register_observers();
+    }
+
+    AbstractChosen.prototype.set_default_values = function() {
+      var _this = this;
+
+      this.click_test_action = function(evt) {
+        return _this.test_active_click(evt);
+      };
+      this.activate_action = function(evt) {
+        return _this.activate_field(evt);
+      };
+      this.active_field = false;
+      this.mouse_on_container = false;
+      this.results_showing = false;
+      this.result_highlighted = null;
+      this.result_single_selected = null;
+      this.allow_single_deselect = (this.options.allow_single_deselect != null) && (this.form_field.options[0] != null) && this.form_field.options[0].text === "" ? this.options.allow_single_deselect : false;
+      this.disable_search_threshold = this.options.disable_search_threshold || 0;
+      this.disable_search = this.options.disable_search || false;
+      this.enable_split_word_search = this.options.enable_split_word_search != null ? this.options.enable_split_word_search : true;
+      this.group_search = this.options.group_search != null ? this.options.group_search : true;
+      this.search_contains = this.options.search_contains || false;
+      this.single_backstroke_delete = this.options.single_backstroke_delete != null ? this.options.single_backstroke_delete : true;
+      this.max_selected_options = this.options.max_selected_options || Infinity;
+      this.inherit_select_classes = this.options.inherit_select_classes || false;
+      this.display_selected_options = this.options.display_selected_options != null ? this.options.display_selected_options : true;
+      return this.display_disabled_options = this.options.display_disabled_options != null ? this.options.display_disabled_options : true;
+    };
+
+    AbstractChosen.prototype.set_default_text = function() {
+      if (this.form_field.getAttribute("data-placeholder")) {
+        this.default_text = this.form_field.getAttribute("data-placeholder");
+      } else if (this.is_multiple) {
+        this.default_text = this.options.placeholder_text_multiple || this.options.placeholder_text || AbstractChosen.default_multiple_text;
+      } else {
+        this.default_text = this.options.placeholder_text_single || this.options.placeholder_text || AbstractChosen.default_single_text;
+      }
+      return this.results_none_found = this.form_field.getAttribute("data-no_results_text") || this.options.no_results_text || AbstractChosen.default_no_result_text;
+    };
+
+    AbstractChosen.prototype.mouse_enter = function() {
+      return this.mouse_on_container = true;
+    };
+
+    AbstractChosen.prototype.mouse_leave = function() {
+      return this.mouse_on_container = false;
+    };
+
+    AbstractChosen.prototype.input_focus = function(evt) {
+      var _this = this;
+
+      if (this.is_multiple) {
+        if (!this.active_field) {
+          return setTimeout((function() {
+            return _this.container_mousedown();
+          }), 50);
+        }
+      } else {
+        if (!this.active_field) {
+          return this.activate_field();
+        }
+      }
+    };
+
+    AbstractChosen.prototype.input_blur = function(evt) {
+      var _this = this;
+
+      if (!this.mouse_on_container) {
+        this.active_field = false;
+        return setTimeout((function() {
+          return _this.blur_test();
+        }), 100);
+      }
+    };
+
+    AbstractChosen.prototype.results_option_build = function(options) {
+      var content, data, _i, _len, _ref;
+
+      content = '';
+      _ref = this.results_data;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        data = _ref[_i];
+        if (data.group) {
+          content += this.result_add_group(data);
+        } else {
+          content += this.result_add_option(data);
+        }
+        if (options != null ? options.first : void 0) {
+          if (data.selected && this.is_multiple) {
+            this.choice_build(data);
+          } else if (data.selected && !this.is_multiple) {
+            this.single_set_selected_text(data.text);
+          }
+        }
+      }
+      return content;
+    };
+
+    AbstractChosen.prototype.result_add_option = function(option) {
+      var classes, style;
+
+      if (!option.search_match) {
+        return '';
+      }
+      if (!this.include_option_in_results(option)) {
+        return '';
+      }
+      classes = [];
+      if (!option.disabled && !(option.selected && this.is_multiple)) {
+        classes.push("active-result");
+      }
+      if (option.disabled && !(option.selected && this.is_multiple)) {
+        classes.push("disabled-result");
+      }
+      if (option.selected) {
+        classes.push("result-selected");
+      }
+      if (option.group_array_index != null) {
+        classes.push("group-option");
+      }
+      if (option.classes !== "") {
+        classes.push(option.classes);
+      }
+      style = option.style.cssText !== "" ? " style=\"" + option.style + "\"" : "";
+      return "<li class=\"" + (classes.join(' ')) + "\"" + style + " data-option-array-index=\"" + option.array_index + "\">" + option.search_text + "</li>";
+    };
+
+    AbstractChosen.prototype.result_add_group = function(group) {
+      if (!(group.search_match || group.group_match)) {
+        return '';
+      }
+      if (!(group.active_options > 0)) {
+        return '';
+      }
+      return "<li class=\"group-result\">" + group.search_text + "</li>";
+    };
+
+    AbstractChosen.prototype.results_update_field = function() {
+      this.set_default_text();
+      if (!this.is_multiple) {
+        this.results_reset_cleanup();
+      }
+      this.result_clear_highlight();
+      this.result_single_selected = null;
+      this.results_build();
+      if (this.results_showing) {
+        return this.winnow_results();
+      }
+    };
+
+    AbstractChosen.prototype.results_toggle = function() {
+      if (this.results_showing) {
+        return this.results_hide();
+      } else {
+        return this.results_show();
+      }
+    };
+
+    AbstractChosen.prototype.results_search = function(evt) {
+      if (this.results_showing) {
+        return this.winnow_results();
+      } else {
+        return this.results_show();
+      }
+    };
+
+    AbstractChosen.prototype.winnow_results = function() {
+      var escapedSearchText, option, regex, regexAnchor, results, results_group, searchText, startpos, text, zregex, _i, _len, _ref;
+
+      this.no_results_clear();
+      results = 0;
+      searchText = this.get_search_text();
+      escapedSearchText = searchText.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+      regexAnchor = this.search_contains ? "" : "^";
+      regex = new RegExp(regexAnchor + escapedSearchText, 'i');
+      zregex = new RegExp(escapedSearchText, 'i');
+      _ref = this.results_data;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        option = _ref[_i];
+        option.search_match = false;
+        results_group = null;
+        if (this.include_option_in_results(option)) {
+          if (option.group) {
+            option.group_match = false;
+            option.active_options = 0;
+          }
+          if ((option.group_array_index != null) && this.results_data[option.group_array_index]) {
+            results_group = this.results_data[option.group_array_index];
+            if (results_group.active_options === 0 && results_group.search_match) {
+              results += 1;
+            }
+            results_group.active_options += 1;
+          }
+          if (!(option.group && !this.group_search)) {
+            option.search_text = option.group ? option.label : option.html;
+            option.search_match = this.search_string_match(option.search_text, regex);
+            if (option.search_match && !option.group) {
+              results += 1;
+            }
+            if (option.search_match) {
+              if (searchText.length) {
+                startpos = option.search_text.search(zregex);
+                text = option.search_text.substr(0, startpos + searchText.length) + '</em>' + option.search_text.substr(startpos + searchText.length);
+                option.search_text = text.substr(0, startpos) + '<em>' + text.substr(startpos);
+              }
+              if (results_group != null) {
+                results_group.group_match = true;
+              }
+            } else if ((option.group_array_index != null) && this.results_data[option.group_array_index].search_match) {
+              option.search_match = true;
+            }
+          }
+        }
+      }
+      this.result_clear_highlight();
+      if (results < 1 && searchText.length) {
+        this.update_results_content("");
+        return this.no_results(searchText);
+      } else {
+        this.update_results_content(this.results_option_build());
+        return this.winnow_results_set_highlight();
+      }
+    };
+
+    AbstractChosen.prototype.search_string_match = function(search_string, regex) {
+      var part, parts, _i, _len;
+
+      if (regex.test(search_string)) {
+        return true;
+      } else if (this.enable_split_word_search && (search_string.indexOf(" ") >= 0 || search_string.indexOf("[") === 0)) {
+        parts = search_string.replace(/\[|\]/g, "").split(" ");
+        if (parts.length) {
+          for (_i = 0, _len = parts.length; _i < _len; _i++) {
+            part = parts[_i];
+            if (regex.test(part)) {
+              return true;
+            }
+          }
+        }
+      }
+    };
+
+    AbstractChosen.prototype.choices_count = function() {
+      var option, _i, _len, _ref;
+
+      if (this.selected_option_count != null) {
+        return this.selected_option_count;
+      }
+      this.selected_option_count = 0;
+      _ref = this.form_field.options;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        option = _ref[_i];
+        if (option.selected) {
+          this.selected_option_count += 1;
+        }
+      }
+      return this.selected_option_count;
+    };
+
+    AbstractChosen.prototype.choices_click = function(evt) {
+      evt.preventDefault();
+      if (!(this.results_showing || this.is_disabled)) {
+        return this.results_show();
+      }
+    };
+
+    AbstractChosen.prototype.keyup_checker = function(evt) {
+      var stroke, _ref;
+
+      stroke = (_ref = evt.which) != null ? _ref : evt.keyCode;
+      this.search_field_scale();
+      switch (stroke) {
+        case 8:
+          if (this.is_multiple && this.backstroke_length < 1 && this.choices_count() > 0) {
+            return this.keydown_backstroke();
+          } else if (!this.pending_backstroke) {
+            this.result_clear_highlight();
+            return this.results_search();
+          }
+          break;
+        case 13:
+          evt.preventDefault();
+          if (this.results_showing) {
+            return this.result_select(evt);
+          }
+          break;
+        case 27:
+          if (this.results_showing) {
+            this.results_hide();
+          }
+          return true;
+        case 9:
+        case 38:
+        case 40:
+        case 16:
+        case 91:
+        case 17:
+          break;
+        default:
+          return this.results_search();
+      }
+    };
+
+    AbstractChosen.prototype.container_width = function() {
+      if (this.options.width != null) {
+        return this.options.width;
+      } else {
+        return "" + this.form_field.offsetWidth + "px";
+      }
+    };
+
+    AbstractChosen.prototype.include_option_in_results = function(option) {
+      if (this.is_multiple && (!this.display_selected_options && option.selected)) {
+        return false;
+      }
+      if (!this.display_disabled_options && option.disabled) {
+        return false;
+      }
+      if (option.empty) {
+        return false;
+      }
+      return true;
+    };
+
+    AbstractChosen.browser_is_supported = function() {
+      if (window.navigator.appName === "Microsoft Internet Explorer") {
+        return document.documentMode >= 8;
+      }
+      if (/iP(od|hone)/i.test(window.navigator.userAgent)) {
+        return false;
+      }
+      if (/Android/i.test(window.navigator.userAgent)) {
+        if (/Mobile/i.test(window.navigator.userAgent)) {
+          return false;
+        }
+      }
+      return true;
+    };
+
+    AbstractChosen.default_multiple_text = "Select Some Options";
+
+    AbstractChosen.default_single_text = "Select an Option";
+
+    AbstractChosen.default_no_result_text = "No results match";
+
+    return AbstractChosen;
+
+  })();
+
+  $ = jQuery;
+
+  $.fn.extend({
+    chosen: function(options) {
+      if (!AbstractChosen.browser_is_supported()) {
+        return this;
+      }
+      return this.each(function(input_field) {
+        var $this, chosen;
+
+        $this = $(this);
+        chosen = $this.data('chosen');
+        if (options === 'destroy' && chosen) {
+          chosen.destroy();
+        } else if (!chosen) {
+          $this.data('chosen', new Chosen(this, options));
+        }
+      });
+    }
+  });
+
+  Chosen = (function(_super) {
+    __extends(Chosen, _super);
+
+    function Chosen() {
+      _ref = Chosen.__super__.constructor.apply(this, arguments);
+      return _ref;
+    }
+
+    Chosen.prototype.setup = function() {
+      this.form_field_jq = $(this.form_field);
+      this.current_selectedIndex = this.form_field.selectedIndex;
+      return this.is_rtl = this.form_field_jq.hasClass("chosen-rtl");
+    };
+
+    Chosen.prototype.set_up_html = function() {
+      var container_classes, container_props;
+
+      container_classes = ["chosen-container"];
+      container_classes.push("chosen-container-" + (this.is_multiple ? "multi" : "single"));
+      if (this.inherit_select_classes && this.form_field.className) {
+        container_classes.push(this.form_field.className);
+      }
+      if (this.is_rtl) {
+        container_classes.push("chosen-rtl");
+      }
+      container_props = {
+        'class': container_classes.join(' '),
+        'style': "width: " + (this.container_width()) + ";",
+        'title': this.form_field.title
+      };
+      if (this.form_field.id.length) {
+        container_props.id = this.form_field.id.replace(/[^\w]/g, '_') + "_chosen";
+      }
+      this.container = $("<div />", container_props);
+      if (this.is_multiple) {
+        this.container.html('<ul class="chosen-choices"><li class="search-field"><input type="text" value="' + this.default_text + '" class="default" autocomplete="off" style="width:25px;" /></li></ul><div class="chosen-drop"><ul class="chosen-results"></ul></div>');
+      } else {
+        this.container.html('<a class="chosen-single chosen-default" tabindex="-1"><span>' + this.default_text + '</span><div><b></b></div></a><div class="chosen-drop"><div class="chosen-search"><input type="text" autocomplete="off" /></div><ul class="chosen-results"></ul></div>');
+      }
+      this.form_field_jq.hide().after(this.container);
+      this.dropdown = this.container.find('div.chosen-drop').first();
+      this.search_field = this.container.find('input').first();
+      this.search_results = this.container.find('ul.chosen-results').first();
+      this.search_field_scale();
+      this.search_no_results = this.container.find('li.no-results').first();
+      if (this.is_multiple) {
+        this.search_choices = this.container.find('ul.chosen-choices').first();
+        this.search_container = this.container.find('li.search-field').first();
+      } else {
+        this.search_container = this.container.find('div.chosen-search').first();
+        this.selected_item = this.container.find('.chosen-single').first();
+      }
+      this.results_build();
+      this.set_tab_index();
+      this.set_label_behavior();
+      return this.form_field_jq.trigger("chosen:ready", {
+        chosen: this
+      });
+    };
+
+    Chosen.prototype.register_observers = function() {
+      var _this = this;
+
+      this.container.bind('mousedown.chosen', function(evt) {
+        _this.container_mousedown(evt);
+      });
+      this.container.bind('mouseup.chosen', function(evt) {
+        _this.container_mouseup(evt);
+      });
+      this.container.bind('mouseenter.chosen', function(evt) {
+        _this.mouse_enter(evt);
+      });
+      this.container.bind('mouseleave.chosen', function(evt) {
+        _this.mouse_leave(evt);
+      });
+      this.search_results.bind('mouseup.chosen', function(evt) {
+        _this.search_results_mouseup(evt);
+      });
+      this.search_results.bind('mouseover.chosen', function(evt) {
+        _this.search_results_mouseover(evt);
+      });
+      this.search_results.bind('mouseout.chosen', function(evt) {
+        _this.search_results_mouseout(evt);
+      });
+      this.search_results.bind('mousewheel.chosen DOMMouseScroll.chosen', function(evt) {
+        _this.search_results_mousewheel(evt);
+      });
+      this.form_field_jq.bind("chosen:updated.chosen", function(evt) {
+        _this.results_update_field(evt);
+      });
+      this.form_field_jq.bind("chosen:activate.chosen", function(evt) {
+        _this.activate_field(evt);
+      });
+      this.form_field_jq.bind("chosen:open.chosen", function(evt) {
+        _this.container_mousedown(evt);
+      });
+      this.search_field.bind('blur.chosen', function(evt) {
+        _this.input_blur(evt);
+      });
+      this.search_field.bind('keyup.chosen', function(evt) {
+        _this.keyup_checker(evt);
+      });
+      this.search_field.bind('keydown.chosen', function(evt) {
+        _this.keydown_checker(evt);
+      });
+      this.search_field.bind('focus.chosen', function(evt) {
+        _this.input_focus(evt);
+      });
+      if (this.is_multiple) {
+        return this.search_choices.bind('click.chosen', function(evt) {
+          _this.choices_click(evt);
+        });
+      } else {
+        return this.container.bind('click.chosen', function(evt) {
+          evt.preventDefault();
+        });
+      }
+    };
+
+    Chosen.prototype.destroy = function() {
+      $(document).unbind("click.chosen", this.click_test_action);
+      if (this.search_field[0].tabIndex) {
+        this.form_field_jq[0].tabIndex = this.search_field[0].tabIndex;
+      }
+      this.container.remove();
+      this.form_field_jq.removeData('chosen');
+      return this.form_field_jq.show();
+    };
+
+    Chosen.prototype.search_field_disabled = function() {
+      this.is_disabled = this.form_field_jq[0].disabled;
+      if (this.is_disabled) {
+        this.container.addClass('chosen-disabled');
+        this.search_field[0].disabled = true;
+        if (!this.is_multiple) {
+          this.selected_item.unbind("focus.chosen", this.activate_action);
+        }
+        return this.close_field();
+      } else {
+        this.container.removeClass('chosen-disabled');
+        this.search_field[0].disabled = false;
+        if (!this.is_multiple) {
+          return this.selected_item.bind("focus.chosen", this.activate_action);
+        }
+      }
+    };
+
+    Chosen.prototype.container_mousedown = function(evt) {
+      if (!this.is_disabled) {
+        if (evt && evt.type === "mousedown" && !this.results_showing) {
+          evt.preventDefault();
+        }
+        if (!((evt != null) && ($(evt.target)).hasClass("search-choice-close"))) {
+          if (!this.active_field) {
+            if (this.is_multiple) {
+              this.search_field.val("");
+            }
+            $(document).bind('click.chosen', this.click_test_action);
+            this.results_show();
+          } else if (!this.is_multiple && evt && (($(evt.target)[0] === this.selected_item[0]) || $(evt.target).parents("a.chosen-single").length)) {
+            evt.preventDefault();
+            this.results_toggle();
+          }
+          return this.activate_field();
+        }
+      }
+    };
+
+    Chosen.prototype.container_mouseup = function(evt) {
+      if (evt.target.nodeName === "ABBR" && !this.is_disabled) {
+        return this.results_reset(evt);
+      }
+    };
+
+    Chosen.prototype.search_results_mousewheel = function(evt) {
+      var delta, _ref1, _ref2;
+
+      delta = -((_ref1 = evt.originalEvent) != null ? _ref1.wheelDelta : void 0) || ((_ref2 = evt.originialEvent) != null ? _ref2.detail : void 0);
+      if (delta != null) {
+        evt.preventDefault();
+        if (evt.type === 'DOMMouseScroll') {
+          delta = delta * 40;
+        }
+        return this.search_results.scrollTop(delta + this.search_results.scrollTop());
+      }
+    };
+
+    Chosen.prototype.blur_test = function(evt) {
+      if (!this.active_field && this.container.hasClass("chosen-container-active")) {
+        return this.close_field();
+      }
+    };
+
+    Chosen.prototype.close_field = function() {
+      $(document).unbind("click.chosen", this.click_test_action);
+      this.active_field = false;
+      this.results_hide();
+      this.container.removeClass("chosen-container-active");
+      this.clear_backstroke();
+      this.show_search_field_default();
+      return this.search_field_scale();
+    };
+
+    Chosen.prototype.activate_field = function() {
+      this.container.addClass("chosen-container-active");
+      this.active_field = true;
+      this.search_field.val(this.search_field.val());
+      return this.search_field.focus();
+    };
+
+    Chosen.prototype.test_active_click = function(evt) {
+      if (this.container.is($(evt.target).closest('.chosen-container'))) {
+        return this.active_field = true;
+      } else {
+        return this.close_field();
+      }
+    };
+
+    Chosen.prototype.results_build = function() {
+      this.parsing = true;
+      this.selected_option_count = null;
+      this.results_data = SelectParser.select_to_array(this.form_field);
+      if (this.is_multiple) {
+        this.search_choices.find("li.search-choice").remove();
+      } else if (!this.is_multiple) {
+        this.single_set_selected_text();
+        if (this.disable_search || this.form_field.options.length <= this.disable_search_threshold) {
+          this.search_field[0].readOnly = true;
+          this.container.addClass("chosen-container-single-nosearch");
+        } else {
+          this.search_field[0].readOnly = false;
+          this.container.removeClass("chosen-container-single-nosearch");
+        }
+      }
+      this.update_results_content(this.results_option_build({
+        first: true
+      }));
+      this.search_field_disabled();
+      this.show_search_field_default();
+      this.search_field_scale();
+      return this.parsing = false;
+    };
+
+    Chosen.prototype.result_do_highlight = function(el) {
+      var high_bottom, high_top, maxHeight, visible_bottom, visible_top;
+
+      if (el.length) {
+        this.result_clear_highlight();
+        this.result_highlight = el;
+        this.result_highlight.addClass("highlighted");
+        maxHeight = parseInt(this.search_results.css("maxHeight"), 10);
+        visible_top = this.search_results.scrollTop();
+        visible_bottom = maxHeight + visible_top;
+        high_top = this.result_highlight.position().top + this.search_results.scrollTop();
+        high_bottom = high_top + this.result_highlight.outerHeight();
+        if (high_bottom >= visible_bottom) {
+          return this.search_results.scrollTop((high_bottom - maxHeight) > 0 ? high_bottom - maxHeight : 0);
+        } else if (high_top < visible_top) {
+          return this.search_results.scrollTop(high_top);
+        }
+      }
+    };
+
+    Chosen.prototype.result_clear_highlight = function() {
+      if (this.result_highlight) {
+        this.result_highlight.removeClass("highlighted");
+      }
+      return this.result_highlight = null;
+    };
+
+    Chosen.prototype.results_show = function() {
+      if (this.is_multiple && this.max_selected_options <= this.choices_count()) {
+        this.form_field_jq.trigger("chosen:maxselected", {
+          chosen: this
+        });
+        return false;
+      }
+      this.container.addClass("chosen-with-drop");
+      this.form_field_jq.trigger("chosen:showing_dropdown", {
+        chosen: this
+      });
+      this.results_showing = true;
+      this.search_field.focus();
+      this.search_field.val(this.search_field.val());
+      return this.winnow_results();
+    };
+
+    Chosen.prototype.update_results_content = function(content) {
+      return this.search_results.html(content);
+    };
+
+    Chosen.prototype.results_hide = function() {
+      if (this.results_showing) {
+        this.result_clear_highlight();
+        this.container.removeClass("chosen-with-drop");
+        this.form_field_jq.trigger("chosen:hiding_dropdown", {
+          chosen: this
+        });
+      }
+      return this.results_showing = false;
+    };
+
+    Chosen.prototype.set_tab_index = function(el) {
+      var ti;
+
+      if (this.form_field.tabIndex) {
+        ti = this.form_field.tabIndex;
+        this.form_field.tabIndex = -1;
+        return this.search_field[0].tabIndex = ti;
+      }
+    };
+
+    Chosen.prototype.set_label_behavior = function() {
+      var _this = this;
+
+      this.form_field_label = this.form_field_jq.parents("label");
+      if (!this.form_field_label.length && this.form_field.id.length) {
+        this.form_field_label = $("label[for='" + this.form_field.id + "']");
+      }
+      if (this.form_field_label.length > 0) {
+        return this.form_field_label.bind('click.chosen', function(evt) {
+          if (_this.is_multiple) {
+            return _this.container_mousedown(evt);
+          } else {
+            return _this.activate_field();
+          }
+        });
+      }
+    };
+
+    Chosen.prototype.show_search_field_default = function() {
+      if (this.is_multiple && this.choices_count() < 1 && !this.active_field) {
+        this.search_field.val(this.default_text);
+        return this.search_field.addClass("default");
+      } else {
+        this.search_field.val("");
+        return this.search_field.removeClass("default");
+      }
+    };
+
+    Chosen.prototype.search_results_mouseup = function(evt) {
+      var target;
+
+      target = $(evt.target).hasClass("active-result") ? $(evt.target) : $(evt.target).parents(".active-result").first();
+      if (target.length) {
+        this.result_highlight = target;
+        this.result_select(evt);
+        return this.search_field.focus();
+      }
+    };
+
+    Chosen.prototype.search_results_mouseover = function(evt) {
+      var target;
+
+      target = $(evt.target).hasClass("active-result") ? $(evt.target) : $(evt.target).parents(".active-result").first();
+      if (target) {
+        return this.result_do_highlight(target);
+      }
+    };
+
+    Chosen.prototype.search_results_mouseout = function(evt) {
+      if ($(evt.target).hasClass("active-result" || $(evt.target).parents('.active-result').first())) {
+        return this.result_clear_highlight();
+      }
+    };
+
+    Chosen.prototype.choice_build = function(item) {
+      var choice, close_link,
+        _this = this;
+
+      choice = $('<li />', {
+        "class": "search-choice"
+      }).html("<span>" + item.html + "</span>");
+      if (item.disabled) {
+        choice.addClass('search-choice-disabled');
+      } else {
+        close_link = $('<a />', {
+          "class": 'search-choice-close',
+          'data-option-array-index': item.array_index
+        });
+        close_link.bind('click.chosen', function(evt) {
+          return _this.choice_destroy_link_click(evt);
+        });
+        choice.append(close_link);
+      }
+      return this.search_container.before(choice);
+    };
+
+    Chosen.prototype.choice_destroy_link_click = function(evt) {
+      evt.preventDefault();
+      evt.stopPropagation();
+      if (!this.is_disabled) {
+        return this.choice_destroy($(evt.target));
+      }
+    };
+
+    Chosen.prototype.choice_destroy = function(link) {
+      if (this.result_deselect(link[0].getAttribute("data-option-array-index"))) {
+        this.show_search_field_default();
+        if (this.is_multiple && this.choices_count() > 0 && this.search_field.val().length < 1) {
+          this.results_hide();
+        }
+        link.parents('li').first().remove();
+        return this.search_field_scale();
+      }
+    };
+
+    Chosen.prototype.results_reset = function() {
+      this.form_field.options[0].selected = true;
+      this.selected_option_count = null;
+      this.single_set_selected_text();
+      this.show_search_field_default();
+      this.results_reset_cleanup();
+      this.form_field_jq.trigger("change");
+      if (this.active_field) {
+        return this.results_hide();
+      }
+    };
+
+    Chosen.prototype.results_reset_cleanup = function() {
+      this.current_selectedIndex = this.form_field.selectedIndex;
+      return this.selected_item.find("abbr").remove();
+    };
+
+    Chosen.prototype.result_select = function(evt) {
+      var high, item, selected_index;
+
+      if (this.result_highlight) {
+        high = this.result_highlight;
+        this.result_clear_highlight();
+        if (this.is_multiple && this.max_selected_options <= this.choices_count()) {
+          this.form_field_jq.trigger("chosen:maxselected", {
+            chosen: this
+          });
+          return false;
+        }
+        if (this.is_multiple) {
+          high.removeClass("active-result");
+        } else {
+          if (this.result_single_selected) {
+            this.result_single_selected.removeClass("result-selected");
+            selected_index = this.result_single_selected[0].getAttribute('data-option-array-index');
+            this.results_data[selected_index].selected = false;
+          }
+          this.result_single_selected = high;
+        }
+        high.addClass("result-selected");
+        item = this.results_data[high[0].getAttribute("data-option-array-index")];
+        item.selected = true;
+        this.form_field.options[item.options_index].selected = true;
+        this.selected_option_count = null;
+        if (this.is_multiple) {
+          this.choice_build(item);
+        } else {
+          this.single_set_selected_text(item.text);
+        }
+        if (!((evt.metaKey || evt.ctrlKey) && this.is_multiple)) {
+          this.results_hide();
+        }
+        this.search_field.val("");
+        if (this.is_multiple || this.form_field.selectedIndex !== this.current_selectedIndex) {
+          this.form_field_jq.trigger("change", {
+            'selected': this.form_field.options[item.options_index].value
+          });
+        }
+        this.current_selectedIndex = this.form_field.selectedIndex;
+        return this.search_field_scale();
+      }
+    };
+
+    Chosen.prototype.single_set_selected_text = function(text) {
+      if (text == null) {
+        text = this.default_text;
+      }
+      if (text === this.default_text) {
+        this.selected_item.addClass("chosen-default");
+      } else {
+        this.single_deselect_control_build();
+        this.selected_item.removeClass("chosen-default");
+      }
+      return this.selected_item.find("span").text(text);
+    };
+
+    Chosen.prototype.result_deselect = function(pos) {
+      var result_data;
+
+      result_data = this.results_data[pos];
+      if (!this.form_field.options[result_data.options_index].disabled) {
+        result_data.selected = false;
+        this.form_field.options[result_data.options_index].selected = false;
+        this.selected_option_count = null;
+        this.result_clear_highlight();
+        if (this.results_showing) {
+          this.winnow_results();
+        }
+        this.form_field_jq.trigger("change", {
+          deselected: this.form_field.options[result_data.options_index].value
+        });
+        this.search_field_scale();
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    Chosen.prototype.single_deselect_control_build = function() {
+      if (!this.allow_single_deselect) {
+        return;
+      }
+      if (!this.selected_item.find("abbr").length) {
+        this.selected_item.find("span").first().after("<abbr class=\"search-choice-close\"></abbr>");
+      }
+      return this.selected_item.addClass("chosen-single-with-deselect");
+    };
+
+    Chosen.prototype.get_search_text = function() {
+      if (this.search_field.val() === this.default_text) {
+        return "";
+      } else {
+        return $('<div/>').text($.trim(this.search_field.val())).html();
+      }
+    };
+
+    Chosen.prototype.winnow_results_set_highlight = function() {
+      var do_high, selected_results;
+
+      selected_results = !this.is_multiple ? this.search_results.find(".result-selected.active-result") : [];
+      do_high = selected_results.length ? selected_results.first() : this.search_results.find(".active-result").first();
+      if (do_high != null) {
+        return this.result_do_highlight(do_high);
+      }
+    };
+
+    Chosen.prototype.no_results = function(terms) {
+      var no_results_html;
+
+      no_results_html = $('<li class="no-results">' + this.results_none_found + ' "<span></span>"</li>');
+      no_results_html.find("span").first().html(terms);
+      return this.search_results.append(no_results_html);
+    };
+
+    Chosen.prototype.no_results_clear = function() {
+      return this.search_results.find(".no-results").remove();
+    };
+
+    Chosen.prototype.keydown_arrow = function() {
+      var next_sib;
+
+      if (this.results_showing && this.result_highlight) {
+        next_sib = this.result_highlight.nextAll("li.active-result").first();
+        if (next_sib) {
+          return this.result_do_highlight(next_sib);
+        }
+      } else {
+        return this.results_show();
+      }
+    };
+
+    Chosen.prototype.keyup_arrow = function() {
+      var prev_sibs;
+
+      if (!this.results_showing && !this.is_multiple) {
+        return this.results_show();
+      } else if (this.result_highlight) {
+        prev_sibs = this.result_highlight.prevAll("li.active-result");
+        if (prev_sibs.length) {
+          return this.result_do_highlight(prev_sibs.first());
+        } else {
+          if (this.choices_count() > 0) {
+            this.results_hide();
+          }
+          return this.result_clear_highlight();
+        }
+      }
+    };
+
+    Chosen.prototype.keydown_backstroke = function() {
+      var next_available_destroy;
+
+      if (this.pending_backstroke) {
+        this.choice_destroy(this.pending_backstroke.find("a").first());
+        return this.clear_backstroke();
+      } else {
+        next_available_destroy = this.search_container.siblings("li.search-choice").last();
+        if (next_available_destroy.length && !next_available_destroy.hasClass("search-choice-disabled")) {
+          this.pending_backstroke = next_available_destroy;
+          if (this.single_backstroke_delete) {
+            return this.keydown_backstroke();
+          } else {
+            return this.pending_backstroke.addClass("search-choice-focus");
+          }
+        }
+      }
+    };
+
+    Chosen.prototype.clear_backstroke = function() {
+      if (this.pending_backstroke) {
+        this.pending_backstroke.removeClass("search-choice-focus");
+      }
+      return this.pending_backstroke = null;
+    };
+
+    Chosen.prototype.keydown_checker = function(evt) {
+      var stroke, _ref1;
+
+      stroke = (_ref1 = evt.which) != null ? _ref1 : evt.keyCode;
+      this.search_field_scale();
+      if (stroke !== 8 && this.pending_backstroke) {
+        this.clear_backstroke();
+      }
+      switch (stroke) {
+        case 8:
+          this.backstroke_length = this.search_field.val().length;
+          break;
+        case 9:
+          if (this.results_showing && !this.is_multiple) {
+            this.result_select(evt);
+          }
+          this.mouse_on_container = false;
+          break;
+        case 13:
+          evt.preventDefault();
+          break;
+        case 38:
+          evt.preventDefault();
+          this.keyup_arrow();
+          break;
+        case 40:
+          evt.preventDefault();
+          this.keydown_arrow();
+          break;
+      }
+    };
+
+    Chosen.prototype.search_field_scale = function() {
+      var div, f_width, h, style, style_block, styles, w, _i, _len;
+
+      if (this.is_multiple) {
+        h = 0;
+        w = 0;
+        style_block = "position:absolute; left: -1000px; top: -1000px; display:none;";
+        styles = ['font-size', 'font-style', 'font-weight', 'font-family', 'line-height', 'text-transform', 'letter-spacing'];
+        for (_i = 0, _len = styles.length; _i < _len; _i++) {
+          style = styles[_i];
+          style_block += style + ":" + this.search_field.css(style) + ";";
+        }
+        div = $('<div />', {
+          'style': style_block
+        });
+        div.text(this.search_field.val());
+        $('body').append(div);
+        w = div.width() + 25;
+        div.remove();
+        f_width = this.container.outerWidth();
+        if (w > f_width - 10) {
+          w = f_width - 10;
+        }
+        return this.search_field.css({
+          'width': w + 'px'
+        });
+      }
+    };
+
+    return Chosen;
+
+  })(AbstractChosen);
+
+}).call(this);
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/chosen/index.html b/afb-client/bower_components/tether/examples/chosen/index.html
new file mode 100644
index 0000000..cf5b490
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/chosen/index.html
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../../css/drop.css" />
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="chosen.css" />
+    </head>
+    <body>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        <br/>
+        Favorite pizza style: <br/>
+        <div class="drop-chosen-target chosen-container chosen-container-single chosen-with-drop" style="width: 350px">
+            <a class="chosen-single chosen-default" tabindex="-1"><span>Choose a style...</span><div><b></b></div></a>
+        </div>
+        <br/>
+        <br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        text<br/>
+        <script src="../resources/js/log.js"></script>
+        <script src="../resources/js/jquery.js"></script>
+        <script src="chosen.js"></script>
+        <script src="../../drop.js"></script>
+        <script>
+            $(function(){
+                var $target, $drop;
+
+                $target = $('.drop-chosen-target').drop({
+                    className: 'drop-chosen',
+                    attach: 'bottom-left',
+                    content: ''
+                });
+
+                $drop = $target.data().drop.$drop;
+
+                $drop.append('<select><option>Plain</option><option>Pepperoni</option><option>Supreme</option></select>');
+
+                $drop.on('openDrop', function(event){
+                    $target.addClass('chosen-container-active');
+                }).on('closeDrop', function(event){
+                    $target.removeClass('chosen-container-active');
+                });
+
+                $drop.on('openDrop', function(event) {
+                    var $select = $drop.find('select');
+
+                    if (!$drop.find('.chosen-container').length) {
+                        $select
+                            .css('width', $target.outerWidth())
+                            .chosen({
+                                allow_single_deselect: true,
+                                disable_search_threshold: 0
+                            })
+                        ;
+                    }
+
+                    setTimeout(function(){
+                        $drop.find('.chosen-search input').click().focus().keyup();
+                        $target.drop('positionDrop');
+                    }, 0);
+                });
+            });
+        </script>
+        <style>
+            .drop-chosen-target > a {
+                outline: none;
+            }
+
+            .drop.drop-chosen {
+                background: transparent;
+            }
+
+            .drop.drop-chosen .chosen-container > .chosen-single {
+                display: none;
+            }
+
+            .drop.drop-chosen .chosen-container .chosen-drop {
+                position: static;
+            }
+        </style>
+    </body>
+</html>
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/common/css/style.css b/afb-client/bower_components/tether/examples/common/css/style.css
new file mode 100644
index 0000000..2d82380
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/common/css/style.css
@@ -0,0 +1,48 @@
+body {
+    min-height: 3000px;
+}
+.element {
+    width: 200px;
+    height: 200px;
+    background-color: #fe8;
+    position: absolute;
+    z-index: 6;
+}
+
+.target {
+    width: 300px;
+    height: 50px;
+    margin: 0 35%;
+    background-color: #4e9;
+}
+
+.container {
+    height: 600px;
+    overflow: scroll;
+    width: 600px;
+    border: 20px solid #CCC;
+    margin-top: 100px;
+}
+
+body {
+    padding: 15px;
+}
+
+body > .container {
+    margin: 0 auto;
+}
+
+.pad {
+    height: 400px;
+    width: 100px;
+}
+
+.instructions {
+    width: 100%;
+    text-align: center;
+    font-size: 24px;
+    padding: 15px;
+    background-color: rgba(210, 180, 140, 0.4);
+    margin: -15px -15px 0 -15px;
+}
+
diff --git a/afb-client/bower_components/tether/examples/content-visible/index.html b/afb-client/bower_components/tether/examples/content-visible/index.html
new file mode 100644
index 0000000..94e2176
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/content-visible/index.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <link rel="stylesheet" href="../resources/css/base.css" />
+    </head>
+    <body>
+
+    <div class="instructions">Scroll the page</div>
+
+    <style>
+      .instructions {
+        width: 100%;
+        text-align: center;
+        font-size: 24px;
+        padding: 15px;
+        background-color: rgba(210, 180, 140, 0.4);
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        min-height: 1200vh;
+        height: 100%;
+      }
+
+      .content-box {
+        width: 600px;
+        border: 10px solid #999;
+        height: 600vh;
+        background-color: #439CCC;
+        margin: 200vh auto;
+      }
+      .element {
+        border: 10px solid #999;
+        background-color: #FFDC00;
+        width: 300px;
+        height: 200px;
+        padding: 0 15px;
+        font-size: 20px;
+        font-weight: bold;
+      }
+    </style>
+
+    <div class="content-box">
+      <div class="element">
+        <p>This is some sort of crazy dialog.</p>
+
+        <p>It's setup to align with the center of the visible part of the blue area.</p>
+      </div>
+    </div>
+
+    <script src="../../tether.js"></script>
+    <script>
+      new Tether({
+        element: '.element',
+        target: '.content-box',
+        attachment: 'middle center',
+        targetAttachment: 'middle center',
+        targetModifier: 'visible'
+      });
+    </script>
+  </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/dolls/dolls.css b/afb-client/bower_components/tether/examples/dolls/dolls.css
new file mode 100644
index 0000000..931c0de
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/dolls/dolls.css
@@ -0,0 +1,18 @@
+.tether-element, .tether-target {
+  width: 200px;
+  height: 50px;
+  background-color: #4cc;
+  position: absolute;
+}
+body {
+  width: 100%;
+  height: 100%;
+  overflow: scroll;
+}
+.scroll {
+  width: 400%;
+  height: 400%;
+}
+.tether-target:not(.tether-element) {
+  cursor: move;
+}
diff --git a/afb-client/bower_components/tether/examples/dolls/dolls.js b/afb-client/bower_components/tether/examples/dolls/dolls.js
new file mode 100644
index 0000000..5d0b06b
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/dolls/dolls.js
@@ -0,0 +1,83 @@
+var tethers = [];
+
+document.addEventListener('DOMContentLoaded', function(){
+  dragging = null;
+
+  document.body.addEventListener('mouseup', function(){
+    dragging = null;
+  });
+
+  document.body.addEventListener('mousemove', function(e){
+    if (dragging){
+      dragging.style.top = e.clientY + 'px';
+      dragging.style.left = e.clientX + 'px';
+
+      Tether.position()
+    }
+  });
+
+  document.body.addEventListener('mousedown', function(e){
+    if (e.target.getAttribute('data-index'))
+      dragging = e.target;
+  })
+
+  var count = 60;
+  var parent = null;
+  var dir = 'left';
+  var first = null;
+
+  while (count--){
+    var el = document.createElement('div');
+    el.setAttribute('data-index', count);
+    document.querySelector('.scroll').appendChild(el);
+
+    if (!first)
+      first = el;
+ 
+    if (count % 10 === 0)
+      dir = dir == 'right' ? 'left' : 'right';
+
+    if (parent){
+      tethers.push(new Tether({
+        element: el,
+        target: parent,
+        attachment: 'middle ' + dir,
+        targetOffset: (dir == 'left' ? '10px 10px' : '10px -10px')
+      }));
+
+    }
+
+    parent = el;
+  }
+
+  initAnim(first);
+});
+
+function initAnim(el){
+  var start = performance.now()
+  var last = 0;
+  var lastTop = 0;
+  var tick = function(){
+    var diff = performance.now() - last;
+
+    if (!last || diff > 50){
+      last = performance.now();
+
+      var nextTop = 50 * Math.sin((last - start) / 1000);
+
+      var curTop = parseFloat(el.style.top || 0);
+      var topChange = nextTop - lastTop;
+      lastTop = nextTop;
+
+      var top = curTop + topChange;
+
+      el.style.top = top + 'px';
+
+      Tether.position();
+    }
+
+    requestAnimationFrame(tick);
+  };
+
+  tick();
+}
diff --git a/afb-client/bower_components/tether/examples/dolls/index.html b/afb-client/bower_components/tether/examples/dolls/index.html
new file mode 100644
index 0000000..610fb34
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/dolls/index.html
@@ -0,0 +1,7 @@
+<link rel="stylesheet" href="./dolls.css" />
+<script src="../../tether.js"></script>
+<script src="./dolls.js"></script>
+<body>
+  <div class="scroll">
+  </div>
+</body>
diff --git a/afb-client/bower_components/tether/examples/element-scroll/index.html b/afb-client/bower_components/tether/examples/element-scroll/index.html
new file mode 100644
index 0000000..1eb6f1e
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/element-scroll/index.html
@@ -0,0 +1,499 @@
+<!DOCTYPE html>
+<html>
+    <head>
+      <link rel="stylesheet" href="../resources/css/base.css" />
+    </head>
+    <body>
+
+    <div class="scroll">
+      <p>For a long time after the course of the steamer <em>Sofala</em> had been
+      altered for the land, the low swampy coast had retained its appearance
+      of a mere smudge of darkness beyond a belt of glitter. The sunrays
+      seemed to fall violently upon the calm sea--seemed to shatter themselves
+      upon an adamantine surface into sparkling dust, into a dazzling vapor
+      of light that blinded the eye and wearied the brain with its unsteady
+      brightness.</p>
+
+      <p>Captain Whalley did not look at it. When his Serang, approaching the
+      roomy cane arm-chair which he filled capably, had informed him in a low
+      voice that the course was to be altered, he had risen at once and had
+      remained on his feet, face forward, while the head of his ship swung
+      through a quarter of a circle. He had not uttered a single word, not
+      even the word to steady the helm. It was the Serang, an elderly, alert,
+      little Malay, with a very dark skin, who murmured the order to the
+      helmsman. And then slowly Captain Whalley sat down again in the
+      arm-chair on the bridge and fixed his eyes on the deck between his feet.</p>
+
+      <p>He could not hope to see anything new upon this lane of the sea. He had
+      been on these coasts for the last three years. From Low Cape to Malantan
+      the distance was fifty miles, six hours' steaming for the old ship with
+      the tide, or seven against. Then you steered straight for the land, and
+      by-and-by three palms would appear on the sky, tall and slim, and with
+      their disheveled heads in a bunch, as if in confidential criticism of
+      the dark mangroves. The Sofala would be headed towards the somber
+      strip of the coast, which at a given moment, as the ship closed with
+      it obliquely, would show several clean shining fractures--the brimful
+      estuary of a river. Then on through a brown liquid, three parts water
+      and one part black earth, on and on between the low shores, three parts
+      black earth and one part brackish water, the Sofala would plow her way
+      up-stream, as she had done once every month for these seven years or
+      more, long before he was aware of her existence, long before he had ever
+      thought of having anything to do with her and her invariable voyages.
+      The old ship ought to have known the road better than her men, who had
+      not been kept so long at it without a change; better than the faithful
+      Serang, whom he had brought over from his last ship to keep the
+      captain's watch; better than he himself, who had been her captain for
+      the last three years only. She could always be depended upon to make her
+      courses. Her compasses were never out. She was no trouble at all to
+      take about, as if her great age had given her knowledge, wisdom, and
+      steadiness. She made her landfalls to a degree of the bearing, and
+      almost to a minute of her allowed time. At any moment, as he sat on
+      the bridge without looking up, or lay sleepless in his bed, simply by
+      reckoning the days and the hours he could tell where he was--the precise
+      spot of the beat. He knew it well too, this monotonous huckster's
+      round, up and down the Straits; he knew its order and its sights and its
+      people. Malacca to begin with, in at daylight and out at dusk, to cross
+      over with a rigid phosphorescent wake this highway of the Far East.
+      Darkness and gleams on the water, clear stars on a black sky, perhaps
+      the lights of a home steamer keeping her unswerving course in the
+      middle, or maybe the elusive shadow of a native craft with her mat sails
+      flitting by silently--and the low land on the other side in sight
+      at daylight. At noon the three palms of the next place of call, up a
+      sluggish river. The only white man residing there was a retired young
+      sailor, with whom he had become friendly in the course of many voyages.
+      Sixty miles farther on there was another place of call, a deep bay with
+      only a couple of houses on the beach. And so on, in and out, picking
+      up coastwise cargo here and there, and finishing with a hundred miles'
+      steady steaming through the maze of an archipelago of small islands up
+      to a large native town at the end of the beat. There was a three days'
+      rest for the old ship before he started her again in inverse order,
+      seeing the same shores from another bearing, hearing the same voices
+      in the same places, back again to the Sofala's port of registry on
+      the great highway to the East, where he would take up a berth nearly
+      opposite the big stone pile of the harbor office till it was time to
+      start again on the old round of 1600 miles and thirty days. Not a very
+      enterprising life, this, for Captain Whalley, Henry Whalley, otherwise
+      Dare-devil Harry--Whalley of the Condor, a famous clipper in her day.
+      No. Not a very enterprising life for a man who had served famous firms,
+      who had sailed famous ships (more than one or two of them his own); who
+      had made famous passages, had been the pioneer of new routes and new
+      trades; who had steered across the unsurveyed tracts of the South Seas,
+      and had seen the sun rise on uncharted islands. Fifty years at sea, and
+      forty out in the East ("a pretty thorough apprenticeship," he used
+      to remark smilingly), had made him honorably known to a generation of
+      shipowners and merchants in all the ports from Bombay clear over to
+      where the East merges into the West upon the coast of the two Americas.
+      His fame remained writ, not very large but plain enough, on the
+      Admiralty charts. Was there not somewhere between Australia and China a
+      Whalley Island and a Condor Reef? On that dangerous coral formation the
+      celebrated clipper had hung stranded for three days, her captain and
+      crew throwing her cargo overboard with one hand and with the other, as
+      it were, keeping off her a flotilla of savage war-canoes. At that time
+      neither the island nor the reef had any official existence. Later the
+      officers of her Majesty's steam vessel Fusilier, dispatched to make a
+      survey of the route, recognized in the adoption of these two names the
+      enterprise of the man and the solidity of the ship. Besides, as anyone
+      who cares may see, the "General Directory," vol. ii. p. 410, begins the
+      description of the "Malotu or Whalley Passage" with the words: "This
+      advantageous route, first discovered in 1850 by Captain Whalley in the
+      ship Condor," &amp;c., and ends by recommending it warmly to sailing vessels
+      leaving the China ports for the south in the months from December to
+      April inclusive.</p>
+
+      <p>This was the clearest gain he had out of life. Nothing could rob him
+      of this kind of fame. The piercing of the Isthmus of Suez, like the
+      breaking of a dam, had let in upon the East a flood of new ships, new
+      men, new methods of trade. It had changed the face of the Eastern seas
+      and the very spirit of their life; so that his early experiences meant
+      nothing whatever to the new generation of seamen.</p>
+
+      <p>In those bygone days he had handled many thousands of pounds of his
+      employers' money and of his own; he had attended faithfully, as by law
+      a shipmaster is expected to do, to the conflicting interests of owners,
+      charterers, and underwriters. He had never lost a ship or consented to
+      a shady transaction; and he had lasted well, outlasting in the end the
+      conditions that had gone to the making of his name. He had buried his
+      wife (in the Gulf of Petchili), had married off his daughter to the man
+      of her unlucky choice, and had lost more than an ample competence in the
+      crash of the notorious Travancore and Deccan Banking Corporation, whose
+      downfall had shaken the East like an earthquake. And he was sixty-five
+      years old.</p>
+
+      <p>His age sat lightly enough on him; and of his ruin he was not ashamed.
+      He had not been alone to believe in the stability of the Banking
+      Corporation. Men whose judgment in matters of finance was as expert as
+      his seamanship had commended the prudence of his investments, and had
+      themselves lost much money in the great failure. The only difference
+      between him and them was that he had lost his all. And yet not his all.
+      There had remained to him from his lost fortune a very pretty little
+      bark, Fair Maid, which he had bought to occupy his leisure of a retired
+      sailor--"to play with," as he expressed it himself.</p>
+
+      <p>He had formally declared himself tired of the sea the year preceding his
+      daughter's marriage. But after the young couple had gone to settle in
+      Melbourne he found out that he could not make himself happy on shore. He
+      was too much of a merchant sea-captain for mere yachting to satisfy him.
+      He wanted the illusion of affairs; and his acquisition of the Fair
+      Maid preserved the continuity of his life. He introduced her to his
+      acquaintances in various ports as "my last command." When he grew too
+      old to be trusted with a ship, he would lay her up and go ashore to be
+      buried, leaving directions in his will to have the bark towed out and
+      scuttled decently in deep water on the day of the funeral. His daughter
+      would not grudge him the satisfaction of knowing that no stranger would
+      handle his last command after him. With the fortune he was able to leave
+      her, the value of a 500-ton bark was neither here nor there. All this
+      would be said with a jocular twinkle in his eye: the vigorous old man
+      had too much vitality for the sentimentalism of regret; and a little
+      wistfully withal, because he was at home in life, taking a genuine
+      pleasure in its feelings and its possessions; in the dignity of his
+      reputation and his wealth, in his love for his daughter, and in his
+      satisfaction with the ship--the plaything of his lonely leisure.</p>
+
+      <p>He had the cabin arranged in accordance with his simple ideal of comfort
+      at sea. A big bookcase (he was a great reader) occupied one side of his
+      stateroom; the portrait of his late wife, a flat bituminous oil-painting
+      representing the profile and one long black ringlet of a young woman,
+      faced his bed-place. Three chronometers ticked him to sleep and greeted
+      him on waking with the tiny competition of their beats. He rose at five
+      every day. The officer of the morning watch, drinking his early cup
+      of coffee aft by the wheel, would hear through the wide orifice of the
+      copper ventilators all the splashings, blowings, and splutterings of
+      his captain's toilet. These noises would be followed by a sustained
+      deep murmur of the Lord's Prayer recited in a loud earnest voice. Five
+      minutes afterwards the head and shoulders of Captain Whalley emerged
+      out of the companion-hatchway. Invariably he paused for a while on the
+      stairs, looking all round at the horizon; upwards at the trim of the
+      sails; inhaling deep draughts of the fresh air. Only then he would step
+      out on the poop, acknowledging the hand raised to the peak of the cap
+      with a majestic and benign "Good morning to you." He walked the deck
+      till eight scrupulously. Sometimes, not above twice a year, he had to
+      use a thick cudgel-like stick on account of a stiffness in the hip--a
+      slight touch of rheumatism, he supposed. Otherwise he knew nothing of
+      the ills of the flesh. At the ringing of the breakfast bell he went
+      below to feed his canaries, wind up the chronometers, and take the
+      head of the table. From there he had before his eyes the big carbon
+      photographs of his daughter, her husband, and two fat-legged babies
+      --his grandchildren--set in black frames into the maplewood bulkheads
+      of the cuddy. After breakfast he dusted the glass over these portraits
+      himself with a cloth, and brushed the oil painting of his wife with a
+      plumate kept suspended from a small brass hook by the side of the heavy
+      gold frame. Then with the door of his stateroom shut, he would sit down
+      on the couch under the portrait to read a chapter out of a thick pocket
+      Bible--her Bible. But on some days he only sat there for half an hour
+      with his finger between the leaves and the closed book resting on his
+      knees. Perhaps he had remembered suddenly how fond of boat-sailing she
+      used to be.</p>
+
+      <p>She had been a real shipmate and a true woman too. It was like an
+      article of faith with him that there never had been, and never could be,
+      a brighter, cheerier home anywhere afloat or ashore than his home under
+      the poop-deck of the Condor, with the big main cabin all white and gold,
+      garlanded as if for a perpetual festival with an unfading wreath. She
+      had decorated the center of every panel with a cluster of home flowers.
+      It took her a twelvemonth to go round the cuddy with this labor of love.
+      To him it had remained a marvel of painting, the highest achievement of
+      taste and skill; and as to old Swinburne, his mate, every time he
+      came down to his meals he stood transfixed with admiration before the
+      progress of the work. You could almost smell these roses, he declared,
+      sniffing the faint flavor of turpentine which at that time pervaded the
+      saloon, and (as he confessed afterwards) made him somewhat less hearty
+      than usual in tackling his food. But there was nothing of the sort to
+      interfere with his enjoyment of her singing. "Mrs. Whalley is a regular
+      out-and-out nightingale, sir," he would pronounce with a judicial air
+      after listening profoundly over the skylight to the very end of the
+      piece. In fine weather, in the second dog-watch, the two men could hear
+      her trills and roulades going on to the accompaniment of the piano in
+      the cabin. On the very day they got engaged he had written to London
+      for the instrument; but they had been married for over a year before it
+      reached them, coming out round the Cape. The big case made part of the
+      first direct general cargo landed in Hong-kong harbor--an event that to
+      the men who walked the busy quays of to-day seemed as hazily remote as
+      the dark ages of history. But Captain Whalley could in a half hour of
+      solitude live again all his life, with its romance, its idyl, and its
+      sorrow. He had to close her eyes himself. She went away from under the
+      ensign like a sailor's wife, a sailor herself at heart. He had read
+      the service over her, out of her own prayer-book, without a break in his
+      voice. When he raised his eyes he could see old Swinburne facing him
+      with his cap pressed to his breast, and his rugged, weather-beaten,
+      impassive face streaming with drops of water like a lump of chipped red
+      granite in a shower. It was all very well for that old sea-dog to cry.
+      He had to read on to the end; but after the splash he did not remember
+      much of what happened for the next few days. An elderly sailor of the
+      crew, deft at needlework, put together a mourning frock for the child
+      out of one of her black skirts.</p>
+
+      <p>He was not likely to forget; but you cannot dam up life like a sluggish
+      stream. It will break out and flow over a man's troubles, it will close
+      upon a sorrow like the sea upon a dead body, no matter how much love has
+      gone to the bottom. And the world is not bad. People had been very
+      kind to him; especially Mrs. Gardner, the wife of the senior partner
+      in Gardner, Patteson, &amp; Co., the owners of the Condor. It was she who
+      volunteered to look after the little one, and in due course took her to
+      England (something of a journey in those days, even by the overland
+      mail route) with her own girls to finish her education. It was ten years
+      before he saw her again.</p>
+
+      <p>As a little child she had never been frightened of bad weather; she
+      would beg to be taken up on deck in the bosom of his oilskin coat to
+      watch the big seas hurling themselves upon the Condor. The swirl and
+      crash of the waves seemed to fill her small soul with a breathless
+      delight. "A good boy spoiled," he used to say of her in joke. He had
+      named her Ivy because of the sound of the word, and obscurely fascinated
+      by a vague association of ideas. She had twined herself tightly round
+      his heart, and he intended her to cling close to her father as to a
+      tower of strength; forgetting, while she was little, that in the nature
+      of things she would probably elect to cling to someone else. But
+      he loved life well enough for even that event to give him a certain
+      satisfaction, apart from his more intimate feeling of loss.</p>
+
+      <p>After he had purchased the Fair Maid to occupy his loneliness, he
+      hastened to accept a rather unprofitable freight to Australia simply for
+      the opportunity of seeing his daughter in her own home. What made him
+      dissatisfied there was not to see that she clung now to somebody else,
+      but that the prop she had selected seemed on closer examination "a
+      rather poor stick"--even in the matter of health. He disliked his
+      son-in-law's studied civility perhaps more than his method of
+      handling the sum of money he had given Ivy at her marriage. But of his
+      apprehensions he said nothing. Only on the day of his departure, with
+      the hall-door open already, holding her hands and looking steadily into
+      her eyes, he had said, "You know, my dear, all I have is for you and the
+      chicks. Mind you write to me openly." She had answered him by an almost
+      imperceptible movement of her head. She resembled her mother in
+      the color of her eyes, and in character--and also in this, that she
+      understood him without many words.</p>
+
+      <p>Sure enough she had to write; and some of these letters made Captain
+      Whalley lift his white eye-brows. For the rest he considered he was
+      reaping the true reward of his life by being thus able to produce on
+      demand whatever was needed. He had not enjoyed himself so much in a
+      way since his wife had died. Characteristically enough his son-in-law's
+      punctuality in failure caused him at a distance to feel a sort of
+      kindness towards the man. The fellow was so perpetually being jammed on
+      a lee shore that to charge it all to his reckless navigation would be
+      manifestly unfair. No, no! He knew well what that meant. It was bad
+      luck. His own had been simply marvelous, but he had seen in his life too
+      many good men--seamen and others--go under with the sheer weight of bad
+      luck not to recognize the fatal signs. For all that, he was cogitating
+      on the best way of tying up very strictly every penny he had to leave,
+      when, with a preliminary rumble of rumors (whose first sound reached
+      him in Shanghai as it happened), the shock of the big failure came;
+      and, after passing through the phases of stupor, of incredulity, of
+      indignation, he had to accept the fact that he had nothing to speak of
+      to leave.</p>
+
+      <p>Upon that, as if he had only waited for this catastrophe, the unlucky
+      man, away there in Melbourne, gave up his unprofitable game, and sat
+      down--in an invalid's bath-chair at that too. "He will never walk
+      again," wrote the wife. For the first time in his life Captain Whalley
+      was a bit staggered.</p>
+
+      <p>The Fair Maid had to go to work in bitter earnest now. It was no longer
+      a matter of preserving alive the memory of Dare-devil Harry Whalley in
+      the Eastern Seas, or of keeping an old man in pocket-money and clothes,
+      with, perhaps, a bill for a few hundred first-class cigars thrown in at
+      the end of the year. He would have to buckle-to, and keep her going hard
+      on a scant allowance of gilt for the ginger-bread scrolls at her stem
+      and stern.</p>
+
+      <p>This necessity opened his eyes to the fundamental changes of the world.
+      Of his past only the familiar names remained, here and there, but
+      the things and the men, as he had known them, were gone. The name of
+      Gardner, Patteson, &amp; Co. was still displayed on the walls of warehouses
+      by the waterside, on the brass plates and window-panes in the business
+      quarters of more than one Eastern port, but there was no longer a
+      Gardner or a Patteson in the firm. There was no longer for Captain
+      Whalley an arm-chair and a welcome in the private office, with a bit of
+      business ready to be put in the way of an old friend, for the sake of
+      bygone services. The husbands of the Gardner girls sat behind the desks
+      in that room where, long after he had left the employ, he had kept his
+      right of entrance in the old man's time. Their ships now had yellow
+      funnels with black tops, and a time-table of appointed routes like a
+      confounded service of tramways. The winds of December and June were all
+      one to them; their captains (excellent young men he doubted not) were,
+      to be sure, familiar with Whalley Island, because of late years the
+      Government had established a white fixed light on the north end (with
+      a red danger sector over the Condor Reef), but most of them would have
+      been extremely surprised to hear that a flesh-and-blood Whalley still
+      existed--an old man going about the world trying to pick up a cargo here
+      and there for his little bark.</p>
+
+      <p>And everywhere it was the same. Departed the men who would have nodded
+      appreciatively at the mention of his name, and would have thought
+      themselves bound in honor to do something for Dare-devil Harry Whalley.
+      Departed the opportunities which he would have known how to seize; and
+      gone with them the white-winged flock of clippers that lived in the
+      boisterous uncertain life of the winds, skimming big fortunes out of
+      the foam of the sea. In a world that pared down the profits to an
+      irreducible minimum, in a world that was able to count its disengaged
+      tonnage twice over every day, and in which lean charters were snapped up
+      by cable three months in advance, there were no chances of fortune for
+      an individual wandering haphazard with a little bark--hardly indeed any
+      room to exist.</p>
+
+      <p>He found it more difficult from year to year. He suffered greatly from
+      the smallness of remittances he was able to send his daughter. Meantime
+      he had given up good cigars, and even in the matter of inferior cheroots
+      limited himself to six a day. He never told her of his difficulties, and
+      she never enlarged upon her struggle to live. Their confidence in each
+      other needed no explanations, and their perfect understanding endured
+      without protestations of gratitude or regret. He would have been shocked
+      if she had taken it into her head to thank him in so many words, but
+      he found it perfectly natural that she should tell him she needed two
+      hundred pounds.</p>
+
+      <p>He had come in with the Fair Maid in ballast to look for a freight in
+      the Sofala's port of registry, and her letter met him there. Its tenor
+      was that it was no use mincing matters. Her only resource was in opening
+      a boarding-house, for which the prospects, she judged, were good. Good
+      enough, at any rate, to make her tell him frankly that with two hundred
+      pounds she could make a start. He had torn the envelope open, hastily,
+      on deck, where it was handed to him by the ship-chandler's runner, who
+      had brought his mail at the moment of anchoring. For the second time
+      in his life he was appalled, and remained stock-still at the cabin door
+      with the paper trembling between his fingers. Open a boarding-house! Two
+      hundred pounds for a start! The only resource! And he did not know where
+      to lay his hands on two hundred pence.</p>
+
+      <p>All that night Captain Whalley walked the poop of his anchored ship, as
+      though he had been about to close with the land in thick weather, and
+      uncertain of his position after a run of many gray days without a sight
+      of sun, moon, or stars. The black night twinkled with the guiding lights
+      of seamen and the steady straight lines of lights on shore; and all
+      around the Fair Maid the riding lights of ships cast trembling trails
+      upon the water of the roadstead. Captain Whalley saw not a gleam
+      anywhere till the dawn broke and he found out that his clothing was
+      soaked through with the heavy dew.</p>
+
+      <p>His ship was awake. He stopped short, stroked his wet beard, and
+      descended the poop ladder backwards, with tired feet. At the sight
+      of him the chief officer, lounging about sleepily on the quarterdeck,
+      remained open-mouthed in the middle of a great early-morning yawn.</p>
+
+      <p>"Good morning to you," pronounced Captain Whalley solemnly, passing into
+      the cabin. But he checked himself in the doorway, and without looking
+      back, "By the bye," he said, "there should be an empty wooden case put
+      away in the lazarette. It has not been broken up--has it?"</p>
+
+      <p>The mate shut his mouth, and then asked as if dazed, "What empty case,
+      sir?"</p>
+
+      <p>"A big flat packing-case belonging to that painting in my room. Let it
+      be taken up on deck and tell the carpenter to look it over. I may want
+      to use it before long."</p>
+
+      <p>The chief officer did not stir a limb till he had heard the door of the
+      captain's state-room slam within the cuddy. Then he beckoned aft the
+      second mate with his forefinger to tell him that there was something "in
+      the wind."</p>
+
+      <p>When the bell rang Captain Whalley's authoritative voice boomed out
+      through a closed door, "Sit down and don't wait for me." And his
+      impressed officers took their places, exchanging looks and whispers
+      across the table. What! No breakfast? And after apparently knocking
+      about all night on deck, too! Clearly, there was something in the wind.
+      In the skylight above their heads, bowed earnestly over the plates,
+      three wire cages rocked and rattled to the restless jumping of the
+      hungry canaries; and they could detect the sounds of their "old
+      man's" deliberate movements within his state-room. Captain Whalley was
+      methodically winding up the chronometers, dusting the portrait of
+      his late wife, getting a clean white shirt out of the drawers, making
+      himself ready in his punctilious unhurried manner to go ashore. He could
+      not have swallowed a single mouthful of food that morning. He had made
+      up his mind to sell the Fair Maid.</p>
+    </div>
+
+    <div class="pointer"></div>
+
+    <style>
+      body {
+        cursor: pointer;
+      }
+      .scroll {
+        height: 80vh;
+        width: 80vw;
+        max-height: 600px;
+        position: fixed;
+        top: 5em;
+        left: 10vw;
+
+        overflow-y: scroll;
+        padding: 4em;
+        box-sizing: border-box;
+        line-height: 1.2;
+      }
+      .scroll::-webkit-scrollbar, .scroll::-webkit-scrollbar-track, .scroll::-webkit-scrollbar-thumb {
+        display: none;
+      }
+
+      .pointer {
+        height: 3.6em;
+        width: 77vw;
+        border: 5px solid #CCC;
+        border-radius: 15px;
+        background-color: rgba(0, 0, 0, 0.05);
+        pointer-events: none;
+      }
+      .highlight {
+        background-color: rgba(255, 255, 0, 0.3);
+      }
+      .hover {
+        background-color: rgba(0, 255, 255, 0.2);
+      }
+    </style>
+
+    <script src="../../tether.js"></script>
+    <script>
+      var pointer = document.querySelector('.pointer');
+      var scroll = document.querySelector('.scroll');
+
+      // This creates the pointer tether and links it up
+      // with the scroll handle
+      new Tether({
+        element: pointer,
+        target: scroll,
+        attachment: 'middle right',
+        targetAttachment: 'middle left',
+        targetModifier: 'scroll-handle'
+      });
+
+      // Everything after this is for the highlighting effect
+      var paras = document.querySelectorAll('p');
+      for(var i=paras.length; i--;){
+        var sents = paras[i].innerHTML.split('.');
+        for (var j=sents.length; j--;){
+          if (sents[j].trim().length)
+            sents[j] = '<span>' + sents[j] + '.</span>';
+        }
+        paras[i].innerHTML = sents.join('');
+      }
+
+      var spans = document.querySelectorAll('p span');
+
+      function highlight(){
+        if (!spans) return;
+
+        var bar = pointer.getBoundingClientRect();
+
+        for (var i=spans.length; i--;){
+          var coord = spans[i].getBoundingClientRect();
+
+          if (bar.top < coord.top && bar.bottom > coord.top){
+            spans[i].classList.add('hover');
+          } else if (spans[i].classList.contains('hover')) {
+            spans[i].classList.remove('hover');
+          }
+        }
+
+        requestAnimationFrame(highlight);
+      }
+
+      highlight();
+
+      document.body.addEventListener('click', function(){
+        var els = document.querySelectorAll('.hover');
+        for (var i=els.length; i--;)
+          els[i].classList.toggle('highlight');
+      });
+    </script>
+  </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/enable-disable/index.html b/afb-client/bower_components/tether/examples/enable-disable/index.html
new file mode 100644
index 0000000..c962adf
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/enable-disable/index.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+    </head>
+    <body>
+        <div class="instructions">Click the green target to enable/disable the tethering.</div>
+
+        <div class="element"></div>
+        <div class="container">
+            <div class="pad"></div>
+            <div class="target"></div>
+            <div class="pad"></div>
+        </div>
+
+        <script src="../../tether.js"></script>
+        <script>
+            var tether = new Tether({
+                element: '.element',
+                target: '.target',
+                attachment: 'top left',
+                targetAttachment: 'top right'
+            });
+
+            document.querySelector('.target').addEventListener('click', function(){
+                if (tether.enabled)
+                    tether.disable();
+                else
+                    tether.enable();
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/facebook/facebook.css b/afb-client/bower_components/tether/examples/facebook/facebook.css
new file mode 100644
index 0000000..eae1508
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/facebook/facebook.css
@@ -0,0 +1,86 @@
+.drop-target.drop-open {
+    outline: 2px solid;
+}
+
+.body {
+    position: relative;
+    margin-right: 300px;
+}
+
+.page {
+    max-width: 100%;
+    width: 1080px;
+    padding: 0 10px;
+    box-sizing: border-box;
+    margin: 0 auto;
+}
+
+.navigation {
+    background: blue;
+    color: #fff;
+    margin-right: 300px;
+    margin-bottom: 30px;
+}
+
+.navigation .item a {
+    padding: 30px 20px;
+    display: inline-block;
+}
+
+.navigation .item a {
+    color: inherit;
+}
+
+.navigation .drop-target.drop-open {
+    background: #fff;
+    color: blue;
+    outline: none;
+}
+
+.right-sidebar {
+    position: fixed;
+    height: 50%;
+    width: 300px;
+    background: #eee;
+    overflow: auto;
+    right: 0;
+}
+
+.right-sidebar .drop-target.drop-open {
+    background: blue;
+    color: #fff;
+    outline: none;
+}
+
+.right-sidebar .item a {
+    display: block;
+    padding: 20px;
+    margin-bottom: 10px;
+    background: rgba(0, 0, 0, .1);
+}
+
+.right-sidebar-top {
+    top: 0;
+}
+
+.right-sidebar-bottom {
+    top: 50%;
+    background: #ccc;
+}
+
+.scroll-container {
+    position: relative; 
+    overflow: auto;
+    background: #eee;
+    padding: 20px;
+    margin-bottom: 20px;
+    margin-right: 20px;
+    height: 200px;
+    width: 200px;
+}
+
+.absolute-container {
+    position: absolute;
+    top: 20px;
+    right: 300px;
+}
diff --git a/afb-client/bower_components/tether/examples/facebook/index.html b/afb-client/bower_components/tether/examples/facebook/index.html
new file mode 100644
index 0000000..d4bcf8e
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/facebook/index.html
@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../../css/drop.css" />
+        <link rel="stylesheet" href="../../css/drop-theme-default.css" />
+        <link rel="stylesheet" href="../../css/drop-theme-arrows.css" />
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="facebook.css" />
+    </head>
+    <body>
+        <div class="navigation">
+            <div class="page">
+                <span class="item">DROPBOOK</span>
+                <span class="item">
+                    <a class="drop-target" data-constrain="false" data-attach="bottom left">DROP</a>
+                </span>
+                <span class="item">
+                    <a class="drop-target" data-constrain="false" data-attach="bottom left">DROP</a>
+                </span>
+                <span class="item">
+                    <a class="drop-target" data-constrain="false" data-attach="bottom left">DROP</a>
+                </span>
+            </div>
+        </div>
+        <div class="right-sidebar right-sidebar-top">
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="true" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left top">DROP</a>
+            </div>
+        </div>
+        <div class="right-sidebar right-sidebar-bottom">
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="true" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+            <div class="item">
+                <a class="drop-target" data-constrain="false" data-class="drop-theme-arrows" data-attach="left bottom">DROP</a>
+            </div>
+        </div>
+        <div class="body">
+            <div class="page">
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor<br/>
+                incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud<br/>
+                exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/><br/>
+
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor<br/>
+                incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud<br/>
+                exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/><br/>
+
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor<br/>
+                incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud<br/>
+                exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/><br/>
+
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor<br/>
+                incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud<br/>
+                exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/><br/>
+
+                <a class="drop-target" data-constrain="true" data-attach="bottom left">DROP</a><br/><br/>
+                <div class="scroll-container">
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  Lorem ipsum dolor sit amet, consectetur adipisicing elit,
+                  <br/><br/><a class="drop-target" data-constrain="true" data-attach="bottom left">DROP</a><br/><br/> sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/>
+                </div>
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/><br/>
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/><br/>
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/><br/>
+                Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/><br/>
+                <div class="scroll-container">
+                    <br/>
+                    <a class="drop-target" data-constrain="true" data-attach="bottom left">DROP</a><br/>
+                    <br/>
+                    <div style="width: 150%; background: #ccc; height: 1px"></div>
+                </div>
+                <div class="scroll-container">
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    <br/><br/>
+                    <div style="width: 150%; background: #ccc; height: 1px">
+                        <div style="margin-left: 100%">
+                            <a class="drop-target" data-constrain="true" data-attach="bottom left">DROP</a>
+                        </div>
+                    </div>
+                    <br/><br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/>
+                </div>
+                <div class="scroll-container absolute-container">
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, <br/><br/><a class="drop-target" data-constrain="false" data-attach="left top">DROP</a><br/><br/> sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.<br/>
+                    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.<br/>
+                </div>
+            </div>
+        </div>
+
+        <script src="../resources/js/log.js"></script>
+        <script src="../resources/js/jquery.js"></script>
+        <script src="../../utils.js"></script>
+        <script src="../../tether.js"></script>
+        <script src="../../drop.js"></script>
+        <script src="../../constraint.js"></script>
+        <style>
+            .drop .drop-content {
+                min-height: 100px;
+                min-width: 100px;
+            }
+        </style>
+        <script>
+            $('.drop-target').each(function(){
+                new Drop({
+                    target: this,
+                    className: $(this).data().class || 'drop-theme-default',
+                    attach: $(this).data().attach,
+                    constrainToScrollParent: $(this).data().constrain,
+                    openOn: 'click'
+                });
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/out-of-bounds/index.html b/afb-client/bower_components/tether/examples/out-of-bounds/index.html
new file mode 100644
index 0000000..f8aa6ab
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/out-of-bounds/index.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+        <style>
+            .tether-element.tether-out-of-bounds {
+                display: none;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="instructions">Resize the screen to see the tethered element disappear when it can't fit.</div>
+
+        <div class="element"></div>
+        <div class="target"></div>
+
+        <script src="../../tether.js"></script>
+        <script>
+            new Tether({
+                element: '.element',
+                target: '.target',
+                attachment: 'top left',
+                targetAttachment: 'top right',
+                constraints: [{
+                    to: 'window',
+                    attachment: 'together'
+                }]
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/pin/index.html b/afb-client/bower_components/tether/examples/pin/index.html
new file mode 100644
index 0000000..9ed4a88
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/pin/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+    </head>
+    <body>
+        <div class="instructions">Resize the screen to see the tethered element stick to the edges of the screen when it's resized.</div>
+
+        <div class="element"></div>
+        <div class="target"></div>
+
+        <script src="../../tether.js"></script>
+        <script>
+            new Tether({
+                element: '.element',
+                target: '.target',
+                attachment: 'top left',
+                targetAttachment: 'top right',
+                constraints: [{
+                    to: 'window',
+                    pin: true
+                }]
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/resources/css/base.css b/afb-client/bower_components/tether/examples/resources/css/base.css
new file mode 100644
index 0000000..8006e9d
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/resources/css/base.css
@@ -0,0 +1,10 @@
+body {
+    font-family: "Helvetica Neue", sans-serif;
+    color: #444;
+    margin: 0px;
+}
+
+a {
+    cursor: pointer;
+    color: blue;
+}
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/resources/js/jquery.js b/afb-client/bower_components/tether/examples/resources/js/jquery.js
new file mode 100644
index 0000000..11be4b4
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/resources/js/jquery.js
@@ -0,0 +1,9597 @@
+/*!
+ * jQuery JavaScript Library v1.9.1
+ * http://jquery.com/
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ *
+ * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
+ * Released under the MIT license
+ * http://jquery.org/license
+ *
+ * Date: 2013-2-4
+ */
+(function( window, undefined ) {
+
+// Can't do this because several apps including ASP.NET trace
+// the stack via arguments.caller.callee and Firefox dies if
+// you try to trace through "use strict" call chains. (#13335)
+// Support: Firefox 18+
+//"use strict";
+var
+    // The deferred used on DOM ready
+    readyList,
+
+    // A central reference to the root jQuery(document)
+    rootjQuery,
+
+    // Support: IE<9
+    // For `typeof node.method` instead of `node.method !== undefined`
+    core_strundefined = typeof undefined,
+
+    // Use the correct document accordingly with window argument (sandbox)
+    document = window.document,
+    location = window.location,
+
+    // Map over jQuery in case of overwrite
+    _jQuery = window.jQuery,
+
+    // Map over the $ in case of overwrite
+    _$ = window.$,
+
+    // [[Class]] -> type pairs
+    class2type = {},
+
+    // List of deleted data cache ids, so we can reuse them
+    core_deletedIds = [],
+
+    core_version = "1.9.1",
+
+    // Save a reference to some core methods
+    core_concat = core_deletedIds.concat,
+    core_push = core_deletedIds.push,
+    core_slice = core_deletedIds.slice,
+    core_indexOf = core_deletedIds.indexOf,
+    core_toString = class2type.toString,
+    core_hasOwn = class2type.hasOwnProperty,
+    core_trim = core_version.trim,
+
+    // Define a local copy of jQuery
+    jQuery = function( selector, context ) {
+        // The jQuery object is actually just the init constructor 'enhanced'
+        return new jQuery.fn.init( selector, context, rootjQuery );
+    },
+
+    // Used for matching numbers
+    core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
+
+    // Used for splitting on whitespace
+    core_rnotwhite = /\S+/g,
+
+    // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
+    rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
+
+    // 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 = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
+
+    // Match a standalone tag
+    rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
+
+    // JSON RegExp
+    rvalidchars = /^[\],:{}\s]*$/,
+    rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
+    rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
+    rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/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();
+    },
+
+    // The ready event handler
+    completed = function( event ) {
+
+        // readyState === "complete" is good enough for us to call the dom ready in oldIE
+        if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
+            detach();
+            jQuery.ready();
+        }
+    },
+    // Clean-up method for dom ready events
+    detach = function() {
+        if ( document.addEventListener ) {
+            document.removeEventListener( "DOMContentLoaded", completed, false );
+            window.removeEventListener( "load", completed, false );
+
+        } else {
+            document.detachEvent( "onreadystatechange", completed );
+            window.detachEvent( "onload", completed );
+        }
+    };
+
+jQuery.fn = jQuery.prototype = {
+    // The current version of jQuery being used
+    jquery: core_version,
+
+    constructor: jQuery,
+    init: function( selector, context, rootjQuery ) {
+        var match, elem;
+
+        // HANDLE: $(""), $(null), $(undefined), $(false)
+        if ( !selector ) {
+            return this;
+        }
+
+        // Handle HTML strings
+        if ( typeof selector === "string" ) {
+            if ( selector.charAt(0) === "<" && selector.charAt( 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;
+
+                    // scripts is true for back-compat
+                    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] );
+
+                    // Check parentNode to catch when Blackberry 4.6 returns
+                    // nodes that are no longer in the document #6963
+                    if ( elem && elem.parentNode ) {
+                        // Handle the case where IE and Opera return items
+                        // by name instead of ID
+                        if ( elem.id !== match[2] ) {
+                            return rootjQuery.find( selector );
+                        }
+
+                        // Otherwise, we 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 rootjQuery.ready( selector );
+        }
+
+        if ( selector.selector !== undefined ) {
+            this.selector = selector.selector;
+            this.context = selector.context;
+        }
+
+        return jQuery.makeArray( selector, this );
+    },
+
+    // Start with an empty selector
+    selector: "",
+
+    // The default length of a jQuery object is 0
+    length: 0,
+
+    // The number of elements contained in the matched element set
+    size: function() {
+        return this.length;
+    },
+
+    toArray: function() {
+        return core_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 a 'clean' array
+            this.toArray() :
+
+            // Return just the object
+            ( num < 0 ? this[ this.length + num ] : this[ num ] );
+    },
+
+    // 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 );
+    },
+
+    ready: function( fn ) {
+        // Add the callback
+        jQuery.ready.promise().done( fn );
+
+        return this;
+    },
+
+    slice: function() {
+        return this.pushStack( core_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] ] : [] );
+    },
+
+    map: function( callback ) {
+        return this.pushStack( jQuery.map(this, function( elem, i ) {
+            return callback.call( elem, i, elem );
+        }));
+    },
+
+    end: function() {
+        return this.prevObject || this.constructor(null);
+    },
+
+    // For internal use only.
+    // Behaves like an Array's method, not like a jQuery method.
+    push: core_push,
+    sort: [].sort,
+    splice: [].splice
+};
+
+// Give the init function the jQuery prototype for later instantiation
+jQuery.fn.init.prototype = jQuery.fn;
+
+jQuery.extend = jQuery.fn.extend = function() {
+    var src, copyIsArray, copy, name, options, clone,
+        target = arguments[0] || {},
+        i = 1,
+        length = arguments.length,
+        deep = false;
+
+    // Handle a deep copy situation
+    if ( typeof target === "boolean" ) {
+        deep = target;
+        target = arguments[1] || {};
+        // skip the boolean and the target
+        i = 2;
+    }
+
+    // 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 ( length === i ) {
+        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({
+    noConflict: function( deep ) {
+        if ( window.$ === jQuery ) {
+            window.$ = _$;
+        }
+
+        if ( deep && window.jQuery === jQuery ) {
+            window.jQuery = _jQuery;
+        }
+
+        return jQuery;
+    },
+
+    // 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;
+        }
+
+        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+        if ( !document.body ) {
+            return setTimeout( jQuery.ready );
+        }
+
+        // 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.trigger ) {
+            jQuery( document ).trigger("ready").off("ready");
+        }
+    },
+
+    // See test/unit/core.js for details concerning isFunction.
+    // Since version 1.3, DOM methods and functions like alert
+    // aren't supported. They return false on IE (#2968).
+    isFunction: function( obj ) {
+        return jQuery.type(obj) === "function";
+    },
+
+    isArray: Array.isArray || function( obj ) {
+        return jQuery.type(obj) === "array";
+    },
+
+    isWindow: function( obj ) {
+        return obj != null && obj == obj.window;
+    },
+
+    isNumeric: function( obj ) {
+        return !isNaN( parseFloat(obj) ) && isFinite( obj );
+    },
+
+    type: function( obj ) {
+        if ( obj == null ) {
+            return String( obj );
+        }
+        return typeof obj === "object" || typeof obj === "function" ?
+            class2type[ core_toString.call(obj) ] || "object" :
+            typeof obj;
+    },
+
+    isPlainObject: function( obj ) {
+        // Must be an Object.
+        // Because of IE, we also have to check the presence of the constructor property.
+        // Make sure that DOM nodes and window objects don't pass through, as well
+        if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
+            return false;
+        }
+
+        try {
+            // Not own constructor property must be Object
+            if ( obj.constructor &&
+                !core_hasOwn.call(obj, "constructor") &&
+                !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
+                return false;
+            }
+        } catch ( e ) {
+            // IE8,9 Will throw exceptions on certain host objects #9897
+            return false;
+        }
+
+        // Own properties are enumerated firstly, so to speed up,
+        // if last one is own, then all properties are own.
+
+        var key;
+        for ( key in obj ) {}
+
+        return key === undefined || core_hasOwn.call( obj, key );
+    },
+
+    isEmptyObject: function( obj ) {
+        var name;
+        for ( name in obj ) {
+            return false;
+        }
+        return true;
+    },
+
+    error: function( msg ) {
+        throw new Error( msg );
+    },
+
+    // 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
+    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 ) {
+            jQuery( scripts ).remove();
+        }
+        return jQuery.merge( [], parsed.childNodes );
+    },
+
+    parseJSON: function( data ) {
+        // Attempt to parse using the native JSON parser first
+        if ( window.JSON && window.JSON.parse ) {
+            return window.JSON.parse( data );
+        }
+
+        if ( data === null ) {
+            return data;
+        }
+
+        if ( typeof data === "string" ) {
+
+            // Make sure leading/trailing whitespace is removed (IE can't handle it)
+            data = jQuery.trim( data );
+
+            if ( data ) {
+                // Make sure the incoming data is actual JSON
+                // Logic borrowed from http://json.org/json2.js
+                if ( rvalidchars.test( data.replace( rvalidescape, "@" )
+                    .replace( rvalidtokens, "]" )
+                    .replace( rvalidbraces, "")) ) {
+
+                    return ( new Function( "return " + data ) )();
+                }
+            }
+        }
+
+        jQuery.error( "Invalid JSON: " + data );
+    },
+
+    // Cross-browser xml parsing
+    parseXML: function( data ) {
+        var xml, tmp;
+        if ( !data || typeof data !== "string" ) {
+            return null;
+        }
+        try {
+            if ( window.DOMParser ) { // Standard
+                tmp = new DOMParser();
+                xml = tmp.parseFromString( data , "text/xml" );
+            } else { // IE
+                xml = new ActiveXObject( "Microsoft.XMLDOM" );
+                xml.async = "false";
+                xml.loadXML( data );
+            }
+        } catch( e ) {
+            xml = undefined;
+        }
+        if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
+            jQuery.error( "Invalid XML: " + data );
+        }
+        return xml;
+    },
+
+    noop: function() {},
+
+    // Evaluates a script in a global context
+    // Workarounds based on findings by Jim Driscoll
+    // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
+    globalEval: function( data ) {
+        if ( data && jQuery.trim( data ) ) {
+            // We use execScript on Internet Explorer
+            // We use an anonymous function so that context is window
+            // rather than jQuery in Firefox
+            ( window.execScript || function( data ) {
+                window[ "eval" ].call( window, data );
+            } )( data );
+        }
+    },
+
+    // Convert dashed to camelCase; used by the css and data modules
+    // 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;
+    },
+
+    // Use native String.trim function wherever possible
+    trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
+        function( text ) {
+            return text == null ?
+                "" :
+                core_trim.call( text );
+        } :
+
+        // Otherwise use our own trimming functionality
+        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 {
+                core_push.call( ret, arr );
+            }
+        }
+
+        return ret;
+    },
+
+    inArray: function( elem, arr, i ) {
+        var len;
+
+        if ( arr ) {
+            if ( core_indexOf ) {
+                return core_indexOf.call( arr, elem, i );
+            }
+
+            len = arr.length;
+            i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
+
+            for ( ; i < len; i++ ) {
+                // Skip accessing in sparse arrays
+                if ( i in arr && arr[ i ] === elem ) {
+                    return i;
+                }
+            }
+        }
+
+        return -1;
+    },
+
+    merge: function( first, second ) {
+        var l = second.length,
+            i = first.length,
+            j = 0;
+
+        if ( typeof l === "number" ) {
+            for ( ; j < l; j++ ) {
+                first[ i++ ] = second[ j ];
+            }
+        } else {
+            while ( second[j] !== undefined ) {
+                first[ i++ ] = second[ j++ ];
+            }
+        }
+
+        first.length = i;
+
+        return first;
+    },
+
+    grep: function( elems, callback, inv ) {
+        var retVal,
+            ret = [],
+            i = 0,
+            length = elems.length;
+        inv = !!inv;
+
+        // Go through the array, only saving the items
+        // that pass the validator function
+        for ( ; i < length; i++ ) {
+            retVal = !!callback( elems[ i ], i );
+            if ( inv !== retVal ) {
+                ret.push( elems[ i ] );
+            }
+        }
+
+        return ret;
+    },
+
+    // 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
+        if ( isArray ) {
+            for ( ; i < length; i++ ) {
+                value = callback( elems[ i ], i, arg );
+
+                if ( value != null ) {
+                    ret[ ret.length ] = value;
+                }
+            }
+
+        // Go through every key on the object,
+        } else {
+            for ( i in elems ) {
+                value = callback( elems[ i ], i, arg );
+
+                if ( value != null ) {
+                    ret[ ret.length ] = value;
+                }
+            }
+        }
+
+        // Flatten any nested arrays
+        return core_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 args, proxy, tmp;
+
+        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 = core_slice.call( arguments, 2 );
+        proxy = function() {
+            return fn.apply( context || this, args.concat( core_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;
+    },
+
+    // Multifunctional method to get and set values of a collection
+    // The value/s can optionally be executed if it's a function
+    access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
+        var i = 0,
+            length = 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 < length; i++ ) {
+                    fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
+                }
+            }
+        }
+
+        return chainable ?
+            elems :
+
+            // Gets
+            bulk ?
+                fn.call( elems ) :
+                length ? fn( elems[0], key ) : emptyGet;
+    },
+
+    now: function() {
+        return ( new Date() ).getTime();
+    }
+});
+
+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 );
+
+        // Standards-based browsers support DOMContentLoaded
+        } else if ( document.addEventListener ) {
+            // Use the handy event callback
+            document.addEventListener( "DOMContentLoaded", completed, false );
+
+            // A fallback to window.onload, that will always work
+            window.addEventListener( "load", completed, false );
+
+        // If IE event model is used
+        } else {
+            // Ensure firing before onload, maybe late but safe also for iframes
+            document.attachEvent( "onreadystatechange", completed );
+
+            // A fallback to window.onload, that will always work
+            window.attachEvent( "onload", completed );
+
+            // If IE and not a frame
+            // continually check to see if the document is ready
+            var top = false;
+
+            try {
+                top = window.frameElement == null && document.documentElement;
+            } catch(e) {}
+
+            if ( top && top.doScroll ) {
+                (function doScrollCheck() {
+                    if ( !jQuery.isReady ) {
+
+                        try {
+                            // Use the trick by Diego Perini
+                            // http://javascript.nwbox.com/IEContentLoaded/
+                            top.doScroll("left");
+                        } catch(e) {
+                            return setTimeout( doScrollCheck, 50 );
+                        }
+
+                        // detach all dom ready events
+                        detach();
+
+                        // and execute any waiting functions
+                        jQuery.ready();
+                    }
+                })();
+            }
+        }
+    }
+    return readyList.promise( obj );
+};
+
+// 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 ) {
+    var length = obj.length,
+        type = jQuery.type( obj );
+
+    if ( jQuery.isWindow( obj ) ) {
+        return false;
+    }
+
+    if ( obj.nodeType === 1 && length ) {
+        return true;
+    }
+
+    return type === "array" || type !== "function" &&
+        ( length === 0 ||
+        typeof length === "number" && length > 0 && ( length - 1 ) in obj );
+}
+
+// All jQuery objects should point back to these
+rootjQuery = jQuery(document);
+// 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( core_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 // Flag to know if list is currently firing
+        firing,
+        // Last fire value (for non-forgettable lists)
+        memory,
+        // Flag to know if list was already fired
+        fired,
+        // End of the loop when firing
+        firingLength,
+        // Index of currently firing callback (modified by remove if needed)
+        firingIndex,
+        // First callback to fire (used internally by add and fireWith)
+        firingStart,
+        // 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 = [];
+                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 ) {
+                args = args || [];
+                args = [ context, args.slice ? args.slice() : args ];
+                if ( list && ( !fired || stack ) ) {
+                    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 action = tuple[ 0 ],
+                                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[ action + "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 = core_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 ? core_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();
+    }
+});
+jQuery.support = (function() {
+
+    var support, all, a,
+        input, select, fragment,
+        opt, eventName, isSupported, i,
+        div = document.createElement("div");
+
+    // Setup
+    div.setAttribute( "className", "t" );
+    div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
+
+    // Support tests won't run in some limited or non-browser environments
+    all = div.getElementsByTagName("*");
+    a = div.getElementsByTagName("a")[ 0 ];
+    if ( !all || !a || !all.length ) {
+        return {};
+    }
+
+    // First batch of tests
+    select = document.createElement("select");
+    opt = select.appendChild( document.createElement("option") );
+    input = div.getElementsByTagName("input")[ 0 ];
+
+    a.style.cssText = "top:1px;float:left;opacity:.5";
+    support = {
+        // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
+        getSetAttribute: div.className !== "t",
+
+        // IE strips leading whitespace when .innerHTML is used
+        leadingWhitespace: div.firstChild.nodeType === 3,
+
+        // Make sure that tbody elements aren't automatically inserted
+        // IE will insert them into empty tables
+        tbody: !div.getElementsByTagName("tbody").length,
+
+        // Make sure that link elements get serialized correctly by innerHTML
+        // This requires a wrapper element in IE
+        htmlSerialize: !!div.getElementsByTagName("link").length,
+
+        // Get the style information from getAttribute
+        // (IE uses .cssText instead)
+        style: /top/.test( a.getAttribute("style") ),
+
+        // Make sure that URLs aren't manipulated
+        // (IE normalizes it by default)
+        hrefNormalized: a.getAttribute("href") === "/a",
+
+        // Make sure that element opacity exists
+        // (IE uses filter instead)
+        // Use a regex to work around a WebKit issue. See #5145
+        opacity: /^0.5/.test( a.style.opacity ),
+
+        // Verify style float existence
+        // (IE uses styleFloat instead of cssFloat)
+        cssFloat: !!a.style.cssFloat,
+
+        // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere)
+        checkOn: !!input.value,
+
+        // Make sure that a selected-by-default option has a working selected property.
+        // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
+        optSelected: opt.selected,
+
+        // Tests for enctype support on a form (#6743)
+        enctype: !!document.createElement("form").enctype,
+
+        // Makes sure cloning an html5 element does not cause problems
+        // Where outerHTML is undefined, this still works
+        html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
+
+        // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
+        boxModel: document.compatMode === "CSS1Compat",
+
+        // Will be defined later
+        deleteExpando: true,
+        noCloneEvent: true,
+        inlineBlockNeedsLayout: false,
+        shrinkWrapBlocks: false,
+        reliableMarginRight: true,
+        boxSizingReliable: true,
+        pixelPosition: false
+    };
+
+    // Make sure checked status is properly cloned
+    input.checked = true;
+    support.noCloneChecked = input.cloneNode( true ).checked;
+
+    // Make sure that the options inside disabled selects aren't marked as disabled
+    // (WebKit marks them as disabled)
+    select.disabled = true;
+    support.optDisabled = !opt.disabled;
+
+    // Support: IE<9
+    try {
+        delete div.test;
+    } catch( e ) {
+        support.deleteExpando = false;
+    }
+
+    // Check if we can trust getAttribute("value")
+    input = document.createElement("input");
+    input.setAttribute( "value", "" );
+    support.input = input.getAttribute( "value" ) === "";
+
+    // Check if an input maintains its value after becoming a radio
+    input.value = "t";
+    input.setAttribute( "type", "radio" );
+    support.radioValue = input.value === "t";
+
+    // #11217 - WebKit loses check when the name is after the checked attribute
+    input.setAttribute( "checked", "t" );
+    input.setAttribute( "name", "t" );
+
+    fragment = document.createDocumentFragment();
+    fragment.appendChild( input );
+
+    // Check if a disconnected checkbox will retain its checked
+    // value of true after appended to the DOM (IE6/7)
+    support.appendChecked = input.checked;
+
+    // WebKit doesn't clone checked state correctly in fragments
+    support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+    // Support: IE<9
+    // Opera does not clone events (and typeof div.attachEvent === undefined).
+    // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()
+    if ( div.attachEvent ) {
+        div.attachEvent( "onclick", function() {
+            support.noCloneEvent = false;
+        });
+
+        div.cloneNode( true ).click();
+    }
+
+    // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)
+    // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php
+    for ( i in { submit: true, change: true, focusin: true }) {
+        div.setAttribute( eventName = "on" + i, "t" );
+
+        support[ i + "Bubbles" ] = eventName in window || div.attributes[ eventName ].expando === false;
+    }
+
+    div.style.backgroundClip = "content-box";
+    div.cloneNode( true ).style.backgroundClip = "";
+    support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+    // Run tests that need a body at doc ready
+    jQuery(function() {
+        var container, marginDiv, tds,
+            divReset = "padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",
+            body = document.getElementsByTagName("body")[0];
+
+        if ( !body ) {
+            // Return for frameset docs that don't have a body
+            return;
+        }
+
+        container = document.createElement("div");
+        container.style.cssText = "border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px";
+
+        body.appendChild( container ).appendChild( div );
+
+        // Support: IE8
+        // Check if table cells still have offsetWidth/Height when they are set
+        // to display:none and there are still other visible table cells in a
+        // table row; if so, offsetWidth/Height are not reliable for use when
+        // determining if an element has been hidden directly using
+        // display:none (it is still safe to use offsets if a parent element is
+        // hidden; don safety goggles and see bug #4512 for more information).
+        div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
+        tds = div.getElementsByTagName("td");
+        tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
+        isSupported = ( tds[ 0 ].offsetHeight === 0 );
+
+        tds[ 0 ].style.display = "";
+        tds[ 1 ].style.display = "none";
+
+        // Support: IE8
+        // Check if empty table cells still have offsetWidth/Height
+        support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
+
+        // Check box-sizing and margin behavior
+        div.innerHTML = "";
+        div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
+        support.boxSizing = ( div.offsetWidth === 4 );
+        support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
+
+        // Use window.getComputedStyle because jsdom on node.js will break without it.
+        if ( window.getComputedStyle ) {
+            support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
+            support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
+
+            // Check if div with explicit width and no margin-right incorrectly
+            // gets computed margin-right based on width of container. (#3333)
+            // Fails in WebKit before Feb 2011 nightlies
+            // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+            marginDiv = div.appendChild( document.createElement("div") );
+            marginDiv.style.cssText = div.style.cssText = divReset;
+            marginDiv.style.marginRight = marginDiv.style.width = "0";
+            div.style.width = "1px";
+
+            support.reliableMarginRight =
+                !parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
+        }
+
+        if ( typeof div.style.zoom !== core_strundefined ) {
+            // Support: IE<8
+            // Check if natively block-level elements act like inline-block
+            // elements when setting their display to 'inline' and giving
+            // them layout
+            div.innerHTML = "";
+            div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
+            support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
+
+            // Support: IE6
+            // Check if elements with layout shrink-wrap their children
+            div.style.display = "block";
+            div.innerHTML = "<div></div>";
+            div.firstChild.style.width = "5px";
+            support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
+
+            if ( support.inlineBlockNeedsLayout ) {
+                // Prevent IE 6 from affecting layout for positioned elements #11048
+                // Prevent IE from shrinking the body in IE 7 mode #12869
+                // Support: IE<8
+                body.style.zoom = 1;
+            }
+        }
+
+        body.removeChild( container );
+
+        // Null elements to avoid leaks in IE
+        container = div = tds = marginDiv = null;
+    });
+
+    // Null elements to avoid leaks in IE
+    all = select = fragment = opt = a = input = null;
+
+    return support;
+})();
+
+var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
+    rmultiDash = /([A-Z])/g;
+
+function internalData( elem, name, data, pvt /* Internal Use Only */ ){
+    if ( !jQuery.acceptData( elem ) ) {
+        return;
+    }
+
+    var thisCache, ret,
+        internalKey = jQuery.expando,
+        getByName = typeof name === "string",
+
+        // We have to handle DOM nodes and JS objects differently because IE6-7
+        // can't GC object references properly across the DOM-JS boundary
+        isNode = elem.nodeType,
+
+        // Only DOM nodes need the global jQuery cache; JS object data is
+        // attached directly to the object so GC can occur automatically
+        cache = isNode ? jQuery.cache : elem,
+
+        // Only defining an ID for JS objects if its cache already exists allows
+        // the code to shortcut on the same path as a DOM node with no cache
+        id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
+
+    // Avoid doing any more work than we need to when trying to get data on an
+    // object that has no data at all
+    if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
+        return;
+    }
+
+    if ( !id ) {
+        // Only DOM nodes need a new unique ID for each element since their data
+        // ends up in the global cache
+        if ( isNode ) {
+            elem[ internalKey ] = id = core_deletedIds.pop() || jQuery.guid++;
+        } else {
+            id = internalKey;
+        }
+    }
+
+    if ( !cache[ id ] ) {
+        cache[ id ] = {};
+
+        // Avoids exposing jQuery metadata on plain JS objects when the object
+        // is serialized using JSON.stringify
+        if ( !isNode ) {
+            cache[ id ].toJSON = jQuery.noop;
+        }
+    }
+
+    // An object can be passed to jQuery.data instead of a key/value pair; this gets
+    // shallow copied over onto the existing cache
+    if ( typeof name === "object" || typeof name === "function" ) {
+        if ( pvt ) {
+            cache[ id ] = jQuery.extend( cache[ id ], name );
+        } else {
+            cache[ id ].data = jQuery.extend( cache[ id ].data, name );
+        }
+    }
+
+    thisCache = cache[ id ];
+
+    // jQuery data() is stored in a separate object inside the object's internal data
+    // cache in order to avoid key collisions between internal data and user-defined
+    // data.
+    if ( !pvt ) {
+        if ( !thisCache.data ) {
+            thisCache.data = {};
+        }
+
+        thisCache = thisCache.data;
+    }
+
+    if ( data !== undefined ) {
+        thisCache[ jQuery.camelCase( name ) ] = data;
+    }
+
+    // Check for both converted-to-camel and non-converted data property names
+    // If a data property was specified
+    if ( getByName ) {
+
+        // First Try to find as-is property data
+        ret = thisCache[ name ];
+
+        // Test for null|undefined property data
+        if ( ret == null ) {
+
+            // Try to find the camelCased property
+            ret = thisCache[ jQuery.camelCase( name ) ];
+        }
+    } else {
+        ret = thisCache;
+    }
+
+    return ret;
+}
+
+function internalRemoveData( elem, name, pvt ) {
+    if ( !jQuery.acceptData( elem ) ) {
+        return;
+    }
+
+    var i, l, thisCache,
+        isNode = elem.nodeType,
+
+        // See jQuery.data for more information
+        cache = isNode ? jQuery.cache : elem,
+        id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
+
+    // If there is already no cache entry for this object, there is no
+    // purpose in continuing
+    if ( !cache[ id ] ) {
+        return;
+    }
+
+    if ( name ) {
+
+        thisCache = pvt ? cache[ id ] : cache[ id ].data;
+
+        if ( thisCache ) {
+
+            // Support array or space separated string names for data keys
+            if ( !jQuery.isArray( name ) ) {
+
+                // try the string as a key before any manipulation
+                if ( name in thisCache ) {
+                    name = [ name ];
+                } else {
+
+                    // split the camel cased version by spaces unless a key with the spaces exists
+                    name = jQuery.camelCase( name );
+                    if ( name in thisCache ) {
+                        name = [ name ];
+                    } else {
+                        name = name.split(" ");
+                    }
+                }
+            } else {
+                // 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 = name.concat( jQuery.map( name, jQuery.camelCase ) );
+            }
+
+            for ( i = 0, l = name.length; i < l; i++ ) {
+                delete thisCache[ name[i] ];
+            }
+
+            // If there is no data left in the cache, we want to continue
+            // and let the cache object itself get destroyed
+            if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
+                return;
+            }
+        }
+    }
+
+    // See jQuery.data for more information
+    if ( !pvt ) {
+        delete cache[ id ].data;
+
+        // Don't destroy the parent cache unless the internal data object
+        // had been the only thing left in it
+        if ( !isEmptyDataObject( cache[ id ] ) ) {
+            return;
+        }
+    }
+
+    // Destroy the cache
+    if ( isNode ) {
+        jQuery.cleanData( [ elem ], true );
+
+    // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
+    } else if ( jQuery.support.deleteExpando || cache != cache.window ) {
+        delete cache[ id ];
+
+    // When all else fails, null
+    } else {
+        cache[ id ] = null;
+    }
+}
+
+jQuery.extend({
+    cache: {},
+
+    // Unique for each copy of jQuery on the page
+    // Non-digits removed to match rinlinejQuery
+    expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
+
+    // The following elements throw uncatchable exceptions if you
+    // attempt to add expando properties to them.
+    noData: {
+        "embed": true,
+        // Ban all objects except for Flash (which handle expandos)
+        "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
+        "applet": true
+    },
+
+    hasData: function( elem ) {
+        elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
+        return !!elem && !isEmptyDataObject( elem );
+    },
+
+    data: function( elem, name, data ) {
+        return internalData( elem, name, data );
+    },
+
+    removeData: function( elem, name ) {
+        return internalRemoveData( elem, name );
+    },
+
+    // For internal use only.
+    _data: function( elem, name, data ) {
+        return internalData( elem, name, data, true );
+    },
+
+    _removeData: function( elem, name ) {
+        return internalRemoveData( elem, name, true );
+    },
+
+    // A method for determining if a DOM node can handle the data expando
+    acceptData: function( elem ) {
+        // Do not set data on non-element because it will not be cleared (#8335).
+        if ( elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9 ) {
+            return false;
+        }
+
+        var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
+
+        // nodes accept data unless otherwise specified; rejection can be conditional
+        return !noData || noData !== true && elem.getAttribute("classid") === noData;
+    }
+});
+
+jQuery.fn.extend({
+    data: function( key, value ) {
+        var attrs, name,
+            elem = this[0],
+            i = 0,
+            data = null;
+
+        // Gets all values
+        if ( key === undefined ) {
+            if ( this.length ) {
+                data = jQuery.data( elem );
+
+                if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
+                    attrs = elem.attributes;
+                    for ( ; i < attrs.length; i++ ) {
+                        name = attrs[i].name;
+
+                        if ( !name.indexOf( "data-" ) ) {
+                            name = jQuery.camelCase( name.slice(5) );
+
+                            dataAttr( elem, name, data[ name ] );
+                        }
+                    }
+                    jQuery._data( elem, "parsedAttrs", true );
+                }
+            }
+
+            return data;
+        }
+
+        // Sets multiple values
+        if ( typeof key === "object" ) {
+            return this.each(function() {
+                jQuery.data( this, key );
+            });
+        }
+
+        return jQuery.access( this, function( value ) {
+
+            if ( value === undefined ) {
+                // Try to fetch any internally stored data first
+                return elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : null;
+            }
+
+            this.each(function() {
+                jQuery.data( this, key, value );
+            });
+        }, null, value, arguments.length > 1, null, true );
+    },
+
+    removeData: function( key ) {
+        return this.each(function() {
+            jQuery.removeData( this, key );
+        });
+    }
+});
+
+function dataAttr( elem, key, data ) {
+    // If nothing was found internally, try to fetch any
+    // data from the HTML5 data-* attribute
+    if ( data === undefined && elem.nodeType === 1 ) {
+
+        var 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
+            jQuery.data( elem, key, data );
+
+        } else {
+            data = undefined;
+        }
+    }
+
+    return data;
+}
+
+// checks a cache object for emptiness
+function isEmptyDataObject( obj ) {
+    var name;
+    for ( name in obj ) {
+
+        // if the public data object is empty, the private is still empty
+        if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
+            continue;
+        }
+        if ( name !== "toJSON" ) {
+            return false;
+        }
+    }
+
+    return true;
+}
+jQuery.extend({
+    queue: function( elem, type, data ) {
+        var queue;
+
+        if ( elem ) {
+            type = ( type || "fx" ) + "queue";
+            queue = jQuery._data( elem, type );
+
+            // Speed up dequeue by getting out quickly if this is just a lookup
+            if ( data ) {
+                if ( !queue || jQuery.isArray(data) ) {
+                    queue = jQuery._data( 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--;
+        }
+
+        hooks.cur = fn;
+        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 intended for public consumption - generates a queueHooks object, or returns the current one
+    _queueHooks: function( elem, type ) {
+        var key = type + "queueHooks";
+        return jQuery._data( elem, key ) || jQuery._data( elem, key, {
+            empty: jQuery.Callbacks("once memory").add(function() {
+                jQuery._removeData( elem, type + "queue" );
+                jQuery._removeData( elem, 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 );
+        });
+    },
+    // Based off of the plugin by Clint Helfers, with permission.
+    // http://blindsignals.com/index.php/2009/07/jquery-delay/
+    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 );
+            };
+        });
+    },
+    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 = jQuery._data( elements[ i ], type + "queueHooks" );
+            if ( tmp && tmp.empty ) {
+                count++;
+                tmp.empty.add( resolve );
+            }
+        }
+        resolve();
+        return defer.promise( obj );
+    }
+});
+var nodeHook, boolHook,
+    rclass = /[\t\r\n]/g,
+    rreturn = /\r/g,
+    rfocusable = /^(?:input|select|textarea|button|object)$/i,
+    rclickable = /^(?:a|area)$/i,
+    rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
+    ruseDefault = /^(?:checked|selected)$/i,
+    getSetAttribute = jQuery.support.getSetAttribute,
+    getSetInput = jQuery.support.input;
+
+jQuery.fn.extend({
+    attr: function( name, value ) {
+        return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
+    },
+
+    removeAttr: function( name ) {
+        return this.each(function() {
+            jQuery.removeAttr( this, name );
+        });
+    },
+
+    prop: function( name, value ) {
+        return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
+    },
+
+    removeProp: function( name ) {
+        name = jQuery.propFix[ name ] || name;
+        return this.each(function() {
+            // try/catch handles cases where IE balks (such as removing a property on window)
+            try {
+                this[ name ] = undefined;
+                delete this[ name ];
+            } catch( e ) {}
+        });
+    },
+
+    addClass: function( value ) {
+        var classes, elem, cur, clazz, j,
+            i = 0,
+            len = this.length,
+            proceed = typeof value === "string" && value;
+
+        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( core_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 + " ";
+                        }
+                    }
+                    elem.className = jQuery.trim( cur );
+
+                }
+            }
+        }
+
+        return this;
+    },
+
+    removeClass: function( value ) {
+        var classes, elem, cur, clazz, j,
+            i = 0,
+            len = this.length,
+            proceed = arguments.length === 0 || typeof value === "string" && value;
+
+        if ( jQuery.isFunction( value ) ) {
+            return this.each(function( j ) {
+                jQuery( this ).removeClass( value.call( this, j, this.className ) );
+            });
+        }
+        if ( proceed ) {
+            classes = ( value || "" ).match( core_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 + " ", " " );
+                        }
+                    }
+                    elem.className = value ? jQuery.trim( cur ) : "";
+                }
+            }
+        }
+
+        return this;
+    },
+
+    toggleClass: function( value, stateVal ) {
+        var type = typeof value,
+            isBool = typeof stateVal === "boolean";
+
+        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 ),
+                    state = stateVal,
+                    classNames = value.match( core_rnotwhite ) || [];
+
+                while ( (className = classNames[ i++ ]) ) {
+                    // check each className given, space separated list
+                    state = isBool ? state : !self.hasClass( className );
+                    self[ state ? "addClass" : "removeClass" ]( className );
+                }
+
+            // Toggle whole class name
+            } else if ( type === core_strundefined || type === "boolean" ) {
+                if ( this.className ) {
+                    // store className if set
+                    jQuery._data( 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 ? "" : jQuery._data( 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;
+    },
+
+    val: function( value ) {
+        var ret, hooks, 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,
+                self = jQuery(this);
+
+            if ( this.nodeType !== 1 ) {
+                return;
+            }
+
+            if ( isFunction ) {
+                val = value.call( this, i, self.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 ) {
+                // attributes.value is undefined in Blackberry 4.7 but
+                // uses .value. See #6932
+                var val = elem.attributes.value;
+                return !val || val.specified ? elem.value : elem.text;
+            }
+        },
+        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 ];
+
+                    // oldIE 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
+                            ( jQuery.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 values = jQuery.makeArray( value );
+
+                jQuery(elem).find("option").each(function() {
+                    this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
+                });
+
+                if ( !values.length ) {
+                    elem.selectedIndex = -1;
+                }
+                return values;
+            }
+        }
+    },
+
+    attr: function( elem, name, value ) {
+        var hooks, notxml, 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 === core_strundefined ) {
+            return jQuery.prop( elem, name, value );
+        }
+
+        notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
+
+        // All attributes are lowercase
+        // Grab necessary hook if one is defined
+        if ( notxml ) {
+            name = name.toLowerCase();
+            hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
+        }
+
+        if ( value !== undefined ) {
+
+            if ( value === null ) {
+                jQuery.removeAttr( elem, name );
+
+            } else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+                return ret;
+
+            } else {
+                elem.setAttribute( name, value + "" );
+                return value;
+            }
+
+        } else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+            return ret;
+
+        } else {
+
+            // In IE9+, Flash objects don't have .getAttribute (#12945)
+            // Support: IE9+
+            if ( typeof elem.getAttribute !== core_strundefined ) {
+                ret =  elem.getAttribute( 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( core_rnotwhite );
+
+        if ( attrNames && elem.nodeType === 1 ) {
+            while ( (name = attrNames[i++]) ) {
+                propName = jQuery.propFix[ name ] || name;
+
+                // Boolean attributes get special treatment (#10870)
+                if ( rboolean.test( name ) ) {
+                    // Set corresponding property to false for boolean attributes
+                    // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8
+                    if ( !getSetAttribute && ruseDefault.test( name ) ) {
+                        elem[ jQuery.camelCase( "default-" + name ) ] =
+                            elem[ propName ] = false;
+                    } else {
+                        elem[ propName ] = false;
+                    }
+
+                // See #9699 for explanation of this approach (setting first, then removal)
+                } else {
+                    jQuery.attr( elem, name, "" );
+                }
+
+                elem.removeAttribute( getSetAttribute ? name : propName );
+            }
+        }
+    },
+
+    attrHooks: {
+        type: {
+            set: function( elem, value ) {
+                if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
+                    // Setting the type on a radio button after the value resets the value in IE6-9
+                    // Reset value to default in case type is set after value during creation
+                    var val = elem.value;
+                    elem.setAttribute( "type", value );
+                    if ( val ) {
+                        elem.value = val;
+                    }
+                    return value;
+                }
+            }
+        }
+    },
+
+    propFix: {
+        tabindex: "tabIndex",
+        readonly: "readOnly",
+        "for": "htmlFor",
+        "class": "className",
+        maxlength: "maxLength",
+        cellspacing: "cellSpacing",
+        cellpadding: "cellPadding",
+        rowspan: "rowSpan",
+        colspan: "colSpan",
+        usemap: "useMap",
+        frameborder: "frameBorder",
+        contenteditable: "contentEditable"
+    },
+
+    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 ) {
+            if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
+                return ret;
+
+            } else {
+                return ( elem[ name ] = value );
+            }
+
+        } else {
+            if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
+                return ret;
+
+            } else {
+                return elem[ name ];
+            }
+        }
+    },
+
+    propHooks: {
+        tabIndex: {
+            get: function( elem ) {
+                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
+                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
+                var attributeNode = elem.getAttributeNode("tabindex");
+
+                return attributeNode && attributeNode.specified ?
+                    parseInt( attributeNode.value, 10 ) :
+                    rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
+                        0 :
+                        undefined;
+            }
+        }
+    }
+});
+
+// Hook for boolean attributes
+boolHook = {
+    get: function( elem, name ) {
+        var
+            // Use .prop to determine if this attribute is understood as boolean
+            prop = jQuery.prop( elem, name ),
+
+            // Fetch it accordingly
+            attr = typeof prop === "boolean" && elem.getAttribute( name ),
+            detail = typeof prop === "boolean" ?
+
+                getSetInput && getSetAttribute ?
+                    attr != null :
+                    // oldIE fabricates an empty string for missing boolean attributes
+                    // and conflates checked/selected into attroperties
+                    ruseDefault.test( name ) ?
+                        elem[ jQuery.camelCase( "default-" + name ) ] :
+                        !!attr :
+
+                // fetch an attribute node for properties not recognized as boolean
+                elem.getAttributeNode( name );
+
+        return detail && detail.value !== false ?
+            name.toLowerCase() :
+            undefined;
+    },
+    set: function( elem, value, name ) {
+        if ( value === false ) {
+            // Remove boolean attributes when set to false
+            jQuery.removeAttr( elem, name );
+        } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {
+            // IE<8 needs the *property* name
+            elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );
+
+        // Use defaultChecked and defaultSelected for oldIE
+        } else {
+            elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true;
+        }
+
+        return name;
+    }
+};
+
+// fix oldIE value attroperty
+if ( !getSetInput || !getSetAttribute ) {
+    jQuery.attrHooks.value = {
+        get: function( elem, name ) {
+            var ret = elem.getAttributeNode( name );
+            return jQuery.nodeName( elem, "input" ) ?
+
+                // Ignore the value *property* by using defaultValue
+                elem.defaultValue :
+
+                ret && ret.specified ? ret.value : undefined;
+        },
+        set: function( elem, value, name ) {
+            if ( jQuery.nodeName( elem, "input" ) ) {
+                // Does not return so that setAttribute is also used
+                elem.defaultValue = value;
+            } else {
+                // Use nodeHook if defined (#1954); otherwise setAttribute is fine
+                return nodeHook && nodeHook.set( elem, value, name );
+            }
+        }
+    };
+}
+
+// IE6/7 do not support getting/setting some attributes with get/setAttribute
+if ( !getSetAttribute ) {
+
+    // Use this for any attribute in IE6/7
+    // This fixes almost every IE6/7 issue
+    nodeHook = jQuery.valHooks.button = {
+        get: function( elem, name ) {
+            var ret = elem.getAttributeNode( name );
+            return ret && ( name === "id" || name === "name" || name === "coords" ? ret.value !== "" : ret.specified ) ?
+                ret.value :
+                undefined;
+        },
+        set: function( elem, value, name ) {
+            // Set the existing or create a new attribute node
+            var ret = elem.getAttributeNode( name );
+            if ( !ret ) {
+                elem.setAttributeNode(
+                    (ret = elem.ownerDocument.createAttribute( name ))
+                );
+            }
+
+            ret.value = value += "";
+
+            // Break association with cloned elements by also using setAttribute (#9646)
+            return name === "value" || value === elem.getAttribute( name ) ?
+                value :
+                undefined;
+        }
+    };
+
+    // Set contenteditable to false on removals(#10429)
+    // Setting to empty string throws an error as an invalid value
+    jQuery.attrHooks.contenteditable = {
+        get: nodeHook.get,
+        set: function( elem, value, name ) {
+            nodeHook.set( elem, value === "" ? false : value, name );
+        }
+    };
+
+    // Set width and height to auto instead of 0 on empty string( Bug #8150 )
+    // This is for removals
+    jQuery.each([ "width", "height" ], function( i, name ) {
+        jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+            set: function( elem, value ) {
+                if ( value === "" ) {
+                    elem.setAttribute( name, "auto" );
+                    return value;
+                }
+            }
+        });
+    });
+}
+
+
+// Some attributes require a special call on IE
+// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
+if ( !jQuery.support.hrefNormalized ) {
+    jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
+        jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
+            get: function( elem ) {
+                var ret = elem.getAttribute( name, 2 );
+                return ret == null ? undefined : ret;
+            }
+        });
+    });
+
+    // href/src property should get the full normalized URL (#10299/#12915)
+    jQuery.each([ "href", "src" ], function( i, name ) {
+        jQuery.propHooks[ name ] = {
+            get: function( elem ) {
+                return elem.getAttribute( name, 4 );
+            }
+        };
+    });
+}
+
+if ( !jQuery.support.style ) {
+    jQuery.attrHooks.style = {
+        get: function( elem ) {
+            // Return undefined in the case of empty string
+            // Note: IE uppercases css property names, but if we were to .toLowerCase()
+            // .cssText, that would destroy case senstitivity in URL's, like in "background"
+            return elem.style.cssText || undefined;
+        },
+        set: function( elem, value ) {
+            return ( elem.style.cssText = value + "" );
+        }
+    };
+}
+
+// Safari mis-reports the default selected property of an option
+// Accessing the parent's selectedIndex property fixes it
+if ( !jQuery.support.optSelected ) {
+    jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
+        get: function( elem ) {
+            var parent = elem.parentNode;
+
+            if ( parent ) {
+                parent.selectedIndex;
+
+                // Make sure that it also works with optgroups, see #5701
+                if ( parent.parentNode ) {
+                    parent.parentNode.selectedIndex;
+                }
+            }
+            return null;
+        }
+    });
+}
+
+// IE6/7 call enctype encoding
+if ( !jQuery.support.enctype ) {
+    jQuery.propFix.enctype = "encoding";
+}
+
+// Radios and checkboxes getter/setter
+if ( !jQuery.support.checkOn ) {
+    jQuery.each([ "radio", "checkbox" ], function() {
+        jQuery.valHooks[ this ] = {
+            get: function( elem ) {
+                // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
+                return elem.getAttribute("value") === null ? "on" : elem.value;
+            }
+        };
+    });
+}
+jQuery.each([ "radio", "checkbox" ], function() {
+    jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
+        set: function( elem, value ) {
+            if ( jQuery.isArray( value ) ) {
+                return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
+            }
+        }
+    });
+});
+var rformElems = /^(?:input|select|textarea)$/i,
+    rkeyEvent = /^key/,
+    rmouseEvent = /^(?:mouse|contextmenu)|click/,
+    rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+    rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
+
+function returnTrue() {
+    return true;
+}
+
+function returnFalse() {
+    return false;
+}
+
+/*
+ * 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 tmp, events, t, handleObjIn,
+            special, eventHandle, handleObj,
+            handlers, type, namespaces, origType,
+            elemData = jQuery._data( 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 !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?
+                    jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
+                    undefined;
+            };
+            // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
+            eventHandle.elem = elem;
+        }
+
+        // Handle multiple events separated by a space
+        // jQuery(...).bind("mouseover mouseout", fn);
+        types = ( types || "" ).match( core_rnotwhite ) || [""];
+        t = types.length;
+        while ( t-- ) {
+            tmp = rtypenamespace.exec( types[t] ) || [];
+            type = origType = tmp[1];
+            namespaces = ( tmp[2] || "" ).split( "." ).sort();
+
+            // 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/attachEvent if the special events handler returns false
+                if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+                    // Bind the global event handler to the element
+                    if ( elem.addEventListener ) {
+                        elem.addEventListener( type, eventHandle, false );
+
+                    } else if ( elem.attachEvent ) {
+                        elem.attachEvent( "on" + type, eventHandle );
+                    }
+                }
+            }
+
+            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;
+        }
+
+        // Nullify elem to prevent memory leaks in IE
+        elem = null;
+    },
+
+    // Detach an event or set of events from an element
+    remove: function( elem, types, handler, selector, mappedTypes ) {
+        var j, handleObj, tmp,
+            origCount, t, events,
+            special, handlers, type,
+            namespaces, origType,
+            elemData = jQuery.hasData( elem ) && jQuery._data( elem );
+
+        if ( !elemData || !(events = elemData.events) ) {
+            return;
+        }
+
+        // Once for each type.namespace in types; type may be omitted
+        types = ( types || "" ).match( core_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;
+
+            // removeData also checks for emptiness and clears the expando if empty
+            // so use it instead of delete
+            jQuery._removeData( elem, "events" );
+        }
+    },
+
+    trigger: function( event, data, elem, onlyHandlers ) {
+        var handle, ontype, cur,
+            bubbleType, special, tmp, i,
+            eventPath = [ elem || document ],
+            type = core_hasOwn.call( event, "type" ) ? event.type : event,
+            namespaces = core_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 );
+
+        event.isTrigger = true;
+        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 = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
+            if ( handle ) {
+                handle.apply( cur, data );
+            }
+
+            // Native handler
+            handle = ontype && cur[ ontype ];
+            if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === 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( elem.ownerDocument, data ) === false) &&
+                !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
+
+                // Call a native DOM method on the target with the same name name as the event.
+                // Can't use an .isFunction() check here because IE6/7 fails that test.
+                // Don't do default actions on window, that's where global variables be (#6170)
+                if ( ontype && 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;
+                    try {
+                        elem[ type ]();
+                    } catch ( e ) {
+                        // IE<9 dies on focus/blur to hidden element (#1486,#12518)
+                        // only reproducible on winXP IE8 native, not IE9 in IE8 mode
+                    }
+                    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, ret, handleObj, matched, j,
+            handlerQueue = [],
+            args = core_slice.call( arguments ),
+            handlers = ( jQuery._data( 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 sel, handleObj, matches, i,
+            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 check non-elements (#13208)
+                // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
+                if ( cur.nodeType === 1 && (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;
+    },
+
+    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: IE<9
+        // Fix target property (#1925)
+        if ( !event.target ) {
+            event.target = originalEvent.srcElement || document;
+        }
+
+        // Support: Chrome 23+, Safari?
+        // Target should not be a text node (#504, #13143)
+        if ( event.target.nodeType === 3 ) {
+            event.target = event.target.parentNode;
+        }
+
+        // Support: IE<9
+        // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)
+        event.metaKey = !!event.metaKey;
+
+        return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
+    },
+
+    // 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 fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
+        filter: function( event, original ) {
+            var body, eventDoc, doc,
+                button = original.button,
+                fromElement = original.fromElement;
+
+            // 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 relatedTarget, if necessary
+            if ( !event.relatedTarget && fromElement ) {
+                event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
+            }
+
+            // 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;
+        }
+    },
+
+    special: {
+        load: {
+            // Prevent triggered image.load events from bubbling to window.load
+            noBubble: true
+        },
+        click: {
+            // For checkbox, fire native event so checked state will be right
+            trigger: function() {
+                if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
+                    this.click();
+                    return false;
+                }
+            }
+        },
+        focus: {
+            // Fire native event if possible so blur/focus sequence is correct
+            trigger: function() {
+                if ( this !== document.activeElement && this.focus ) {
+                    try {
+                        this.focus();
+                        return false;
+                    } catch ( e ) {
+                        // Support: IE<9
+                        // If we error on focus to hidden element (#1486, #12518),
+                        // let .trigger() run the handlers
+                    }
+                }
+            },
+            delegateType: "focusin"
+        },
+        blur: {
+            trigger: function() {
+                if ( this === document.activeElement && this.blur ) {
+                    this.blur();
+                    return false;
+                }
+            },
+            delegateType: "focusout"
+        },
+
+        beforeunload: {
+            postDispatch: function( event ) {
+
+                // Even when returnValue equals to undefined Firefox will still show alert
+                if ( event.result !== undefined ) {
+                    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 = document.removeEventListener ?
+    function( elem, type, handle ) {
+        if ( elem.removeEventListener ) {
+            elem.removeEventListener( type, handle, false );
+        }
+    } :
+    function( elem, type, handle ) {
+        var name = "on" + type;
+
+        if ( elem.detachEvent ) {
+
+            // #8545, #7054, preventing memory leaks for custom events in IE6-8
+            // detachEvent needed property on element, by name of that event, to properly expose it to GC
+            if ( typeof elem[ name ] === core_strundefined ) {
+                elem[ name ] = null;
+            }
+
+            elem.detachEvent( name, handle );
+        }
+    };
+
+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.returnValue === false ||
+            src.getPreventDefault && src.getPreventDefault() ) ? 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 ) {
+            return;
+        }
+
+        // If preventDefault exists, run it on the original event
+        if ( e.preventDefault ) {
+            e.preventDefault();
+
+        // Support: IE
+        // Otherwise set the returnValue property of the original event to false
+        } else {
+            e.returnValue = false;
+        }
+    },
+    stopPropagation: function() {
+        var e = this.originalEvent;
+
+        this.isPropagationStopped = returnTrue;
+        if ( !e ) {
+            return;
+        }
+        // If stopPropagation exists, run it on the original event
+        if ( e.stopPropagation ) {
+            e.stopPropagation();
+        }
+
+        // Support: IE
+        // Set the cancelBubble property of the original event to true
+        e.cancelBubble = true;
+    },
+    stopImmediatePropagation: function() {
+        this.isImmediatePropagationStopped = returnTrue;
+        this.stopPropagation();
+    }
+};
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+jQuery.each({
+    mouseenter: "mouseover",
+    mouseleave: "mouseout"
+}, 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;
+        }
+    };
+});
+
+// IE submit delegation
+if ( !jQuery.support.submitBubbles ) {
+
+    jQuery.event.special.submit = {
+        setup: function() {
+            // Only need this for delegated form submit events
+            if ( jQuery.nodeName( this, "form" ) ) {
+                return false;
+            }
+
+            // Lazy-add a submit handler when a descendant form may potentially be submitted
+            jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
+                // Node name check avoids a VML-related crash in IE (#9807)
+                var elem = e.target,
+                    form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
+                if ( form && !jQuery._data( form, "submitBubbles" ) ) {
+                    jQuery.event.add( form, "submit._submit", function( event ) {
+                        event._submit_bubble = true;
+                    });
+                    jQuery._data( form, "submitBubbles", true );
+                }
+            });
+            // return undefined since we don't need an event listener
+        },
+
+        postDispatch: function( event ) {
+            // If form was submitted by the user, bubble the event up the tree
+            if ( event._submit_bubble ) {
+                delete event._submit_bubble;
+                if ( this.parentNode && !event.isTrigger ) {
+                    jQuery.event.simulate( "submit", this.parentNode, event, true );
+                }
+            }
+        },
+
+        teardown: function() {
+            // Only need this for delegated form submit events
+            if ( jQuery.nodeName( this, "form" ) ) {
+                return false;
+            }
+
+            // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
+            jQuery.event.remove( this, "._submit" );
+        }
+    };
+}
+
+// IE change delegation and checkbox/radio fix
+if ( !jQuery.support.changeBubbles ) {
+
+    jQuery.event.special.change = {
+
+        setup: function() {
+
+            if ( rformElems.test( this.nodeName ) ) {
+                // IE doesn't fire change on a check/radio until blur; trigger it on click
+                // after a propertychange. Eat the blur-change in special.change.handle.
+                // This still fires onchange a second time for check/radio after blur.
+                if ( this.type === "checkbox" || this.type === "radio" ) {
+                    jQuery.event.add( this, "propertychange._change", function( event ) {
+                        if ( event.originalEvent.propertyName === "checked" ) {
+                            this._just_changed = true;
+                        }
+                    });
+                    jQuery.event.add( this, "click._change", function( event ) {
+                        if ( this._just_changed && !event.isTrigger ) {
+                            this._just_changed = false;
+                        }
+                        // Allow triggered, simulated change events (#11500)
+                        jQuery.event.simulate( "change", this, event, true );
+                    });
+                }
+                return false;
+            }
+            // Delegated event; lazy-add a change handler on descendant inputs
+            jQuery.event.add( this, "beforeactivate._change", function( e ) {
+                var elem = e.target;
+
+                if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) {
+                    jQuery.event.add( elem, "change._change", function( event ) {
+                        if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
+                            jQuery.event.simulate( "change", this.parentNode, event, true );
+                        }
+                    });
+                    jQuery._data( elem, "changeBubbles", true );
+                }
+            });
+        },
+
+        handle: function( event ) {
+            var elem = event.target;
+
+            // Swallow native change events from checkbox/radio, we already triggered them above
+            if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
+                return event.handleObj.handler.apply( this, arguments );
+            }
+        },
+
+        teardown: function() {
+            jQuery.event.remove( this, "._change" );
+
+            return !rformElems.test( this.nodeName );
+        }
+    };
+}
+
+// Create "bubbling" focus and blur events
+if ( !jQuery.support.focusinBubbles ) {
+    jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
+
+        // Attach a single capturing handler while someone wants focusin/focusout
+        var attaches = 0,
+            handler = function( event ) {
+                jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
+            };
+
+        jQuery.event.special[ fix ] = {
+            setup: function() {
+                if ( attaches++ === 0 ) {
+                    document.addEventListener( orig, handler, true );
+                }
+            },
+            teardown: function() {
+                if ( --attaches === 0 ) {
+                    document.removeEventListener( orig, handler, true );
+                }
+            }
+        };
+    });
+}
+
+jQuery.fn.extend({
+
+    on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
+        var type, origFn;
+
+        // 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 );
+        });
+    },
+
+    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 );
+    },
+
+    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 );
+        }
+    }
+});
+/*!
+ * Sizzle CSS Selector Engine
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license
+ * http://sizzlejs.com/
+ */
+(function( window, undefined ) {
+
+var i,
+    cachedruns,
+    Expr,
+    getText,
+    isXML,
+    compile,
+    hasDuplicate,
+    outermostContext,
+
+    // Local document vars
+    setDocument,
+    document,
+    docElem,
+    documentIsXML,
+    rbuggyQSA,
+    rbuggyMatches,
+    matches,
+    contains,
+    sortOrder,
+
+    // Instance-specific data
+    expando = "sizzle" + -(new Date()),
+    preferredDoc = window.document,
+    support = {},
+    dirruns = 0,
+    done = 0,
+    classCache = createCache(),
+    tokenCache = createCache(),
+    compilerCache = createCache(),
+
+    // General-purpose constants
+    strundefined = typeof undefined,
+    MAX_NEGATIVE = 1 << 31,
+
+    // Array methods
+    arr = [],
+    pop = arr.pop,
+    push = arr.push,
+    slice = arr.slice,
+    // Use a stripped-down indexOf if we can't use a native one
+    indexOf = arr.indexOf || function( elem ) {
+        var i = 0,
+            len = this.length;
+        for ( ; i < len; i++ ) {
+            if ( this[i] === elem ) {
+                return i;
+            }
+        }
+        return -1;
+    },
+
+
+    // 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#" ),
+
+    // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
+    operators = "([*^$|!~]?=)",
+    attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
+        "*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
+
+    // Prefer arguments quoted,
+    //   then not containing pseudos/brackets,
+    //   then attribute selectors/non-parenthetical expressions,
+    //   then anything else
+    // These preferences are here to reduce the number of selectors
+    //   needing tokenize in the PSEUDO preFilter
+    pseudos = ":(" + characterEncoding + ")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|" + attributes.replace( 3, 8 ) + ")*)|.*)\\)|)",
+
+    // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+    rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
+
+    rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+    rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
+    rpseudo = new RegExp( pseudos ),
+    ridentifier = new RegExp( "^" + identifier + "$" ),
+
+    matchExpr = {
+        "ID": new RegExp( "^#(" + characterEncoding + ")" ),
+        "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
+        "NAME": new RegExp( "^\\[name=['\"]?(" + 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" ),
+        // 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" )
+    },
+
+    rsibling = /[\x20\t\r\n\f]*[+~]/,
+
+    rnative = /^[^{]+\{\s*\[native code/,
+
+    // Easily-parseable/retrievable ID or TAG or CLASS selectors
+    rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+    rinputs = /^(?:input|select|textarea|button)$/i,
+    rheader = /^h\d$/i,
+
+    rescape = /'|\\/g,
+    rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
+
+    // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+    runescape = /\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,
+    funescape = function( _, escaped ) {
+        var high = "0x" + escaped - 0x10000;
+        // NaN means non-codepoint
+        return high !== high ?
+            escaped :
+            // BMP codepoint
+            high < 0 ?
+                String.fromCharCode( high + 0x10000 ) :
+                // Supplemental Plane codepoint (surrogate pair)
+                String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+    };
+
+// Use a stripped-down slice if we can't use a native one
+try {
+    slice.call( preferredDoc.documentElement.childNodes, 0 )[0].nodeType;
+} catch ( e ) {
+    slice = function( i ) {
+        var elem,
+            results = [];
+        while ( (elem = this[i++]) ) {
+            results.push( elem );
+        }
+        return results;
+    };
+}
+
+/**
+ * For feature detection
+ * @param {Function} fn The function to test for native support
+ */
+function isNative( fn ) {
+    return rnative.test( fn + "" );
+}
+
+/**
+ * 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 cache,
+        keys = [];
+
+    return (cache = function( 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);
+    });
+}
+
+/**
+ * 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 {
+        // release memory in IE
+        div = null;
+    }
+}
+
+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 || [];
+
+    if ( !selector || typeof selector !== "string" ) {
+        return results;
+    }
+
+    if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
+        return [];
+    }
+
+    if ( !documentIsXML && !seed ) {
+
+        // Shortcuts
+        if ( (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 #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, slice.call(context.getElementsByTagName( selector ), 0) );
+                return results;
+
+            // Speed-up: Sizzle(".CLASS")
+            } else if ( (m = match[3]) && support.getByClassName && context.getElementsByClassName ) {
+                push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
+                return results;
+            }
+        }
+
+        // QSA path
+        if ( support.qsa && !rbuggyQSA.test(selector) ) {
+            old = true;
+            nid = expando;
+            newContext = context;
+            newSelector = nodeType === 9 && 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 ) && context.parentNode || context;
+                newSelector = groups.join(",");
+            }
+
+            if ( newSelector ) {
+                try {
+                    push.apply( results, slice.call( newContext.querySelectorAll(
+                        newSelector
+                    ), 0 ) );
+                    return results;
+                } catch(qsaError) {
+                } finally {
+                    if ( !old ) {
+                        context.removeAttribute("id");
+                    }
+                }
+            }
+        }
+    }
+
+    // All others
+    return select( selector.replace( rtrim, "$1" ), context, results, seed );
+}
+
+/**
+ * Detect xml
+ * @param {Element|Object} elem An element or a document
+ */
+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 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;
+
+    // Support tests
+    documentIsXML = isXML( doc );
+
+    // Check if getElementsByTagName("*") returns only elements
+    support.tagNameNoComments = assert(function( div ) {
+        div.appendChild( doc.createComment("") );
+        return !div.getElementsByTagName("*").length;
+    });
+
+    // Check if attributes should be retrieved by attribute nodes
+    support.attributes = assert(function( div ) {
+        div.innerHTML = "<select></select>";
+        var type = typeof div.lastChild.getAttribute("multiple");
+        // IE8 returns a string for some attributes even when not present
+        return type !== "boolean" && type !== "string";
+    });
+
+    // Check if getElementsByClassName can be trusted
+    support.getByClassName = assert(function( div ) {
+        // Opera can't find a second classname (in 9.6)
+        div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
+        if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
+            return false;
+        }
+
+        // Safari 3.2 caches class attributes and doesn't catch changes
+        div.lastChild.className = "e";
+        return div.getElementsByClassName("e").length === 2;
+    });
+
+    // Check if getElementById returns elements by name
+    // Check if getElementsByName privileges form controls or returns elements by ID
+    support.getByName = assert(function( div ) {
+        // Inject content
+        div.id = expando + 0;
+        div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
+        docElem.insertBefore( div, docElem.firstChild );
+
+        // Test
+        var pass = doc.getElementsByName &&
+            // buggy browsers will return fewer than the correct 2
+            doc.getElementsByName( expando ).length === 2 +
+            // buggy browsers will return more than the correct 0
+            doc.getElementsByName( expando + 0 ).length;
+        support.getIdNotName = !doc.getElementById( expando );
+
+        // Cleanup
+        docElem.removeChild( div );
+
+        return pass;
+    });
+
+    // IE6/7 return modified attributes
+    Expr.attrHandle = assert(function( div ) {
+        div.innerHTML = "<a href='#'></a>";
+        return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
+            div.firstChild.getAttribute("href") === "#";
+    }) ?
+        {} :
+        {
+            "href": function( elem ) {
+                return elem.getAttribute( "href", 2 );
+            },
+            "type": function( elem ) {
+                return elem.getAttribute("type");
+            }
+        };
+
+    // ID find and filter
+    if ( support.getIdNotName ) {
+        Expr.find["ID"] = function( id, context ) {
+            if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
+                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 {
+        Expr.find["ID"] = function( id, context ) {
+            if ( typeof context.getElementById !== strundefined && !documentIsXML ) {
+                var m = context.getElementById( id );
+
+                return m ?
+                    m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
+                        [m] :
+                        undefined :
+                    [];
+            }
+        };
+        Expr.filter["ID"] =  function( id ) {
+            var attrId = id.replace( runescape, funescape );
+            return function( elem ) {
+                var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
+                return node && node.value === attrId;
+            };
+        };
+    }
+
+    // Tag
+    Expr.find["TAG"] = support.tagNameNoComments ?
+        function( tag, context ) {
+            if ( typeof context.getElementsByTagName !== strundefined ) {
+                return context.getElementsByTagName( tag );
+            }
+        } :
+        function( tag, context ) {
+            var elem,
+                tmp = [],
+                i = 0,
+                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;
+        };
+
+    // Name
+    Expr.find["NAME"] = support.getByName && function( tag, context ) {
+        if ( typeof context.getElementsByName !== strundefined ) {
+            return context.getElementsByName( name );
+        }
+    };
+
+    // Class
+    Expr.find["CLASS"] = support.getByClassName && function( className, context ) {
+        if ( typeof context.getElementsByClassName !== strundefined && !documentIsXML ) {
+            return context.getElementsByClassName( className );
+        }
+    };
+
+    // QSA and matchesSelector support
+
+    // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
+    rbuggyMatches = [];
+
+    // qSa(:focus) reports false when true (Chrome 21),
+    // no need to also add to buggyMatches since matches checks buggyQSA
+    // A support test would require too much code (would include document ready)
+    rbuggyQSA = [ ":focus" ];
+
+    if ( (support.qsa = isNative(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 explictly
+            // setting a boolean content attribute,
+            // since its presence should be enough
+            // http://bugs.jquery.com/ticket/12359
+            div.innerHTML = "<select><option selected=''></option></select>";
+
+            // IE8 - Some boolean attributes are not treated correctly
+            if ( !div.querySelectorAll("[selected]").length ) {
+                rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
+            }
+
+            // 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");
+            }
+        });
+
+        assert(function( div ) {
+
+            // Opera 10-12/IE8 - ^= $= *= and empty values
+            // Should not select anything
+            div.innerHTML = "<input type='hidden' i=''/>";
+            if ( div.querySelectorAll("[i^='']").length ) {
+                rbuggyQSA.push( "[*^$]=" + 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 = isNative( (matches = docElem.matchesSelector ||
+        docElem.mozMatchesSelector ||
+        docElem.webkitMatchesSelector ||
+        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 = new RegExp( rbuggyQSA.join("|") );
+    rbuggyMatches = new RegExp( rbuggyMatches.join("|") );
+
+    // Element contains another
+    // Purposefully does not implement inclusive descendent
+    // As in, an element does not contain itself
+    contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?
+        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;
+        };
+
+    // Document order sorting
+    sortOrder = docElem.compareDocumentPosition ?
+    function( a, b ) {
+        var compare;
+
+        if ( a === b ) {
+            hasDuplicate = true;
+            return 0;
+        }
+
+        if ( (compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b )) ) {
+            if ( compare & 1 || a.parentNode && a.parentNode.nodeType === 11 ) {
+                if ( a === doc || contains( preferredDoc, a ) ) {
+                    return -1;
+                }
+                if ( b === doc || contains( preferredDoc, b ) ) {
+                    return 1;
+                }
+                return 0;
+            }
+            return compare & 4 ? -1 : 1;
+        }
+
+        return a.compareDocumentPosition ? -1 : 1;
+    } :
+    function( a, b ) {
+        var cur,
+            i = 0,
+            aup = a.parentNode,
+            bup = b.parentNode,
+            ap = [ a ],
+            bp = [ b ];
+
+        // Exit early if the nodes are identical
+        if ( a === b ) {
+            hasDuplicate = true;
+            return 0;
+
+        // Parentless nodes are either documents or disconnected
+        } else if ( !aup || !bup ) {
+            return a === doc ? -1 :
+                b === doc ? 1 :
+                aup ? -1 :
+                bup ? 1 :
+                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;
+    };
+
+    // Always assume the presence of duplicates if sort doesn't
+    // pass them to our comparison function (as in Google Chrome).
+    hasDuplicate = false;
+    [0, 0].sort( sortOrder );
+    support.detectDuplicates = hasDuplicate;
+
+    return document;
+};
+
+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']" );
+
+    // rbuggyQSA always contains :focus, so no need for an existence check
+    if ( support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !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 ) {
+    var val;
+
+    // Set document vars if needed
+    if ( ( elem.ownerDocument || elem ) !== document ) {
+        setDocument( elem );
+    }
+
+    if ( !documentIsXML ) {
+        name = name.toLowerCase();
+    }
+    if ( (val = Expr.attrHandle[ name ]) ) {
+        return val( elem );
+    }
+    if ( documentIsXML || support.attributes ) {
+        return elem.getAttribute( name );
+    }
+    return ( (val = elem.getAttributeNode( name )) || elem.getAttribute( name ) ) && elem[ name ] === true ?
+        name :
+        val && val.specified ? val.value : null;
+};
+
+Sizzle.error = function( msg ) {
+    throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+// Document sorting and removing duplicates
+Sizzle.uniqueSort = function( results ) {
+    var elem,
+        duplicates = [],
+        i = 1,
+        j = 0;
+
+    // Unless we *know* we can detect duplicates, assume their presence
+    hasDuplicate = !support.detectDuplicates;
+    results.sort( sortOrder );
+
+    if ( hasDuplicate ) {
+        for ( ; (elem = results[i]); i++ ) {
+            if ( elem === results[ i - 1 ] ) {
+                j = duplicates.push( i );
+            }
+        }
+        while ( j-- ) {
+            results.splice( duplicates[ j ], 1 );
+        }
+    }
+
+    return results;
+};
+
+function siblingCheck( a, b ) {
+    var cur = b && a,
+        diff = cur && ( ~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
+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
+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
+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]);
+                }
+            }
+        });
+    });
+}
+
+/**
+ * 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
+        for ( ; (node = elem[i]); 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 (see #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,
+
+    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[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[5] && match[2];
+
+            if ( matchExpr["CHILD"].test( match[0] ) ) {
+                return null;
+            }
+
+            // Accept quoted arguments as-is
+            if ( match[4] ) {
+                match[2] = match[4];
+
+            // 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( nodeName ) {
+            if ( nodeName === "*" ) {
+                return function() { return true; };
+            }
+
+            nodeName = nodeName.replace( runescape, funescape ).toLowerCase();
+            return 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( elem.className || (typeof elem.getAttribute !== strundefined && 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 + " " ).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.call( 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 );
+                    return !results.pop();
+                };
+        }),
+
+        "has": markFunction(function( selector ) {
+            return function( elem ) {
+                return Sizzle( selector, elem ).length > 0;
+            };
+        }),
+
+        "contains": markFunction(function( text ) {
+            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 identifider
+            if ( !ridentifier.test(lang || "") ) {
+                Sizzle.error( "unsupported lang: " + lang );
+            }
+            lang = lang.replace( runescape, funescape ).toLowerCase();
+            return function( elem ) {
+                var elemLang;
+                do {
+                    if ( (elemLang = documentIsXML ?
+                        elem.getAttribute("xml:lang") || elem.getAttribute("lang") :
+                        elem.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 only affected by element nodes and content nodes(including text(3), cdata(4)),
+            //   not comment, processing instructions, or others
+            // Thanks to Diego Perini for the nodeName shortcut
+            //   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
+            for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+                if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
+                    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;
+            // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
+            // use getAttribute instead to test this case
+            return elem.nodeName.toLowerCase() === "input" &&
+                elem.type === "text" &&
+                ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
+        },
+
+        // 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;
+        })
+    }
+};
+
+// 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 );
+}
+
+function tokenize( 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 data, cache, outerCache,
+                dirkey = 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 ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
+                            if ( (data = cache[1]) === true || data === cachedruns ) {
+                                return data === true;
+                            }
+                        } else {
+                            cache = outerCache[ dir ] = [ dirkey ];
+                            cache[1] = matcher( elem, context, xml ) || cachedruns;
+                            if ( cache[1] === true ) {
+                                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 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.call( 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.call( checkContext, elem ) > -1;
+        }, implicitRelative, true ),
+        matchers = [ function( elem, context, xml ) {
+            return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+                (checkContext = context).nodeType ?
+                    matchContext( elem, context, xml ) :
+                    matchAnyContext( elem, context, xml ) );
+        } ];
+
+    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( tokens.slice( 0, i - 1 ) ).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 ) {
+    // A counter to specify which element is currently being matched
+    var matcherCachedRuns = 0,
+        bySet = setMatchers.length > 0,
+        byElement = elementMatchers.length > 0,
+        superMatcher = function( seed, context, xml, results, expandContext ) {
+            var elem, j, matcher,
+                setMatched = [],
+                matchedCount = 0,
+                i = "0",
+                unmatched = seed && [],
+                outermost = expandContext != null,
+                contextBackup = outermostContext,
+                // We must always have either seed elements or context
+                elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
+                // Use integer dirruns iff this is the outermost matcher
+                dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
+
+            if ( outermost ) {
+                outermostContext = context !== document && context;
+                cachedruns = matcherCachedRuns;
+            }
+
+            // Add elements passing elementMatchers directly to results
+            // Keep `i` a string if there are no elements so `matchedCount` will be "00" below
+            for ( ; (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;
+                        cachedruns = ++matcherCachedRuns;
+                    }
+                }
+
+                // 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, group /* 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 ( !group ) {
+            group = tokenize( selector );
+        }
+        i = group.length;
+        while ( i-- ) {
+            cached = matcherFromTokens( group[i] );
+            if ( cached[ expando ] ) {
+                setMatchers.push( cached );
+            } else {
+                elementMatchers.push( cached );
+            }
+        }
+
+        // Cache the compiled function
+        cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+    }
+    return cached;
+};
+
+function multipleContexts( selector, contexts, results ) {
+    var i = 0,
+        len = contexts.length;
+    for ( ; i < len; i++ ) {
+        Sizzle( selector, contexts[i], results );
+    }
+    return results;
+}
+
+function select( selector, context, results, seed ) {
+    var i, tokens, token, type, find,
+        match = tokenize( selector );
+
+    if ( !seed ) {
+        // Try to minimize operations if there is 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" &&
+                    context.nodeType === 9 && !documentIsXML &&
+                    Expr.relative[ tokens[1].type ] ) {
+
+                context = Expr.find["ID"]( token.matches[0].replace( runescape, funescape ), context )[0];
+                if ( !context ) {
+                    return results;
+                }
+
+                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 ) && 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, slice.call( seed, 0 ) );
+                            return results;
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Compile and execute a filtering function
+    // Provide `match` to avoid retokenization if we modified the selector above
+    compile( selector, match )(
+        seed,
+        context,
+        documentIsXML,
+        results,
+        rsibling.test( selector )
+    );
+    return results;
+}
+
+// Deprecated
+Expr.pseudos["nth"] = Expr.pseudos["eq"];
+
+// Easy API for creating new setFilters
+function setFilters() {}
+Expr.filters = setFilters.prototype = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+// Initialize with the default document
+setDocument();
+
+// Override sizzle attribute retrieval
+Sizzle.attr = jQuery.attr;
+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;
+
+
+})( window );
+var runtil = /Until$/,
+    rparentsprev = /^(?:parents|prev(?:Until|All))/,
+    isSimple = /^.[^:#\[\.,]*$/,
+    rneedsContext = jQuery.expr.match.needsContext,
+    // methods guaranteed to produce a unique set when starting from a unique set
+    guaranteedUnique = {
+        children: true,
+        contents: true,
+        next: true,
+        prev: true
+    };
+
+jQuery.fn.extend({
+    find: function( selector ) {
+        var i, ret, self,
+            len = this.length;
+
+        if ( typeof selector !== "string" ) {
+            self = this;
+            return this.pushStack( jQuery( selector ).filter(function() {
+                for ( i = 0; i < len; i++ ) {
+                    if ( jQuery.contains( self[ i ], this ) ) {
+                        return true;
+                    }
+                }
+            }) );
+        }
+
+        ret = [];
+        for ( i = 0; i < len; i++ ) {
+            jQuery.find( selector, this[ 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;
+        return ret;
+    },
+
+    has: function( target ) {
+        var i,
+            targets = jQuery( target, this ),
+            len = targets.length;
+
+        return this.filter(function() {
+            for ( i = 0; i < len; i++ ) {
+                if ( jQuery.contains( this, targets[i] ) ) {
+                    return true;
+                }
+            }
+        });
+    },
+
+    not: function( selector ) {
+        return this.pushStack( winnow(this, selector, false) );
+    },
+
+    filter: function( selector ) {
+        return this.pushStack( winnow(this, selector, true) );
+    },
+
+    is: function( selector ) {
+        return !!selector && (
+            typeof selector === "string" ?
+                // 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".
+                rneedsContext.test( selector ) ?
+                    jQuery( selector, this.context ).index( this[0] ) >= 0 :
+                    jQuery.filter( selector, this ).length > 0 :
+                this.filter( selector ).length > 0 );
+    },
+
+    closest: function( selectors, context ) {
+        var cur,
+            i = 0,
+            l = this.length,
+            ret = [],
+            pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
+                jQuery( selectors, context || this.context ) :
+                0;
+
+        for ( ; i < l; i++ ) {
+            cur = this[i];
+
+            while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
+                if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
+                    ret.push( cur );
+                    break;
+                }
+                cur = cur.parentNode;
+            }
+        }
+
+        return this.pushStack( ret.length > 1 ? jQuery.unique( ret ) : ret );
+    },
+
+    // Determine the position of an element within
+    // the matched set of elements
+    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 jQuery.inArray( this[0], jQuery( elem ) );
+        }
+
+        // Locate the position of the desired element
+        return jQuery.inArray(
+            // If it receives a jQuery object, the first element is used
+            elem.jquery ? elem[0] : elem, this );
+    },
+
+    add: function( selector, context ) {
+        var set = typeof selector === "string" ?
+                jQuery( selector, context ) :
+                jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
+            all = jQuery.merge( this.get(), set );
+
+        return this.pushStack( jQuery.unique(all) );
+    },
+
+    addBack: function( selector ) {
+        return this.add( selector == null ?
+            this.prevObject : this.prevObject.filter(selector)
+        );
+    }
+});
+
+jQuery.fn.andSelf = jQuery.fn.addBack;
+
+function sibling( cur, dir ) {
+    do {
+        cur = cur[ dir ];
+    } while ( cur && 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 jQuery.nodeName( elem, "iframe" ) ?
+            elem.contentDocument || elem.contentWindow.document :
+            jQuery.merge( [], elem.childNodes );
+    }
+}, function( name, fn ) {
+    jQuery.fn[ name ] = function( until, selector ) {
+        var ret = jQuery.map( this, fn, until );
+
+        if ( !runtil.test( name ) ) {
+            selector = until;
+        }
+
+        if ( selector && typeof selector === "string" ) {
+            ret = jQuery.filter( selector, ret );
+        }
+
+        ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
+
+        if ( this.length > 1 && rparentsprev.test( name ) ) {
+            ret = ret.reverse();
+        }
+
+        return this.pushStack( ret );
+    };
+});
+
+jQuery.extend({
+    filter: function( expr, elems, not ) {
+        if ( not ) {
+            expr = ":not(" + expr + ")";
+        }
+
+        return elems.length === 1 ?
+            jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
+            jQuery.find.matches(expr, elems);
+    },
+
+    dir: function( elem, dir, until ) {
+        var matched = [],
+            cur = elem[ dir ];
+
+        while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
+            if ( cur.nodeType === 1 ) {
+                matched.push( cur );
+            }
+            cur = cur[dir];
+        }
+        return matched;
+    },
+
+    sibling: function( n, elem ) {
+        var r = [];
+
+        for ( ; n; n = n.nextSibling ) {
+            if ( n.nodeType === 1 && n !== elem ) {
+                r.push( n );
+            }
+        }
+
+        return r;
+    }
+});
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, keep ) {
+
+    // Can't pass null or undefined to indexOf in Firefox 4
+    // Set to 0 to skip string check
+    qualifier = qualifier || 0;
+
+    if ( jQuery.isFunction( qualifier ) ) {
+        return jQuery.grep(elements, function( elem, i ) {
+            var retVal = !!qualifier.call( elem, i, elem );
+            return retVal === keep;
+        });
+
+    } else if ( qualifier.nodeType ) {
+        return jQuery.grep(elements, function( elem ) {
+            return ( elem === qualifier ) === keep;
+        });
+
+    } else if ( typeof qualifier === "string" ) {
+        var filtered = jQuery.grep(elements, function( elem ) {
+            return elem.nodeType === 1;
+        });
+
+        if ( isSimple.test( qualifier ) ) {
+            return jQuery.filter(qualifier, filtered, !keep);
+        } else {
+            qualifier = jQuery.filter( qualifier, filtered );
+        }
+    }
+
+    return jQuery.grep(elements, function( elem ) {
+        return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
+    });
+}
+function createSafeFragment( document ) {
+    var list = nodeNames.split( "|" ),
+        safeFrag = document.createDocumentFragment();
+
+    if ( safeFrag.createElement ) {
+        while ( list.length ) {
+            safeFrag.createElement(
+                list.pop()
+            );
+        }
+    }
+    return safeFrag;
+}
+
+var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
+        "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
+    rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
+    rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
+    rleadingWhitespace = /^\s+/,
+    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
+    rtagName = /<([\w:]+)/,
+    rtbody = /<tbody/i,
+    rhtml = /<|&#?\w+;/,
+    rnoInnerhtml = /<(?:script|style|link)/i,
+    manipulation_rcheckableType = /^(?:checkbox|radio)$/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 = {
+        option: [ 1, "<select multiple='multiple'>", "</select>" ],
+        legend: [ 1, "<fieldset>", "</fieldset>" ],
+        area: [ 1, "<map>", "</map>" ],
+        param: [ 1, "<object>", "</object>" ],
+        thead: [ 1, "<table>", "</table>" ],
+        tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+        col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
+        td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+        // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
+        // unless wrapped in a div with non-breaking characters in front of it.
+        _default: jQuery.support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>"  ]
+    },
+    safeFragment = createSafeFragment( document ),
+    fragmentDiv = safeFragment.appendChild( document.createElement("div") );
+
+wrapMap.optgroup = wrapMap.option;
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+jQuery.fn.extend({
+    text: function( value ) {
+        return jQuery.access( this, function( value ) {
+            return value === undefined ?
+                jQuery.text( this ) :
+                this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
+        }, null, value, arguments.length );
+    },
+
+    wrapAll: function( html ) {
+        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
+            var 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.firstChild && elem.firstChild.nodeType === 1 ) {
+                    elem = elem.firstChild;
+                }
+
+                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();
+    },
+
+    append: function() {
+        return this.domManip(arguments, true, function( elem ) {
+            if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+                this.appendChild( elem );
+            }
+        });
+    },
+
+    prepend: function() {
+        return this.domManip(arguments, true, function( elem ) {
+            if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+                this.insertBefore( elem, this.firstChild );
+            }
+        });
+    },
+
+    before: function() {
+        return this.domManip( arguments, false, function( elem ) {
+            if ( this.parentNode ) {
+                this.parentNode.insertBefore( elem, this );
+            }
+        });
+    },
+
+    after: function() {
+        return this.domManip( arguments, false, function( elem ) {
+            if ( this.parentNode ) {
+                this.parentNode.insertBefore( elem, this.nextSibling );
+            }
+        });
+    },
+
+    // keepData is for internal use only--do not document
+    remove: function( selector, keepData ) {
+        var elem,
+            i = 0;
+
+        for ( ; (elem = this[i]) != null; i++ ) {
+            if ( !selector || jQuery.filter( selector, [ elem ] ).length > 0 ) {
+                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++ ) {
+            // Remove element nodes and prevent memory leaks
+            if ( elem.nodeType === 1 ) {
+                jQuery.cleanData( getAll( elem, false ) );
+            }
+
+            // Remove any remaining nodes
+            while ( elem.firstChild ) {
+                elem.removeChild( elem.firstChild );
+            }
+
+            // If this is a select, ensure that it displays empty (#12336)
+            // Support: IE<9
+            if ( elem.options && jQuery.nodeName( elem, "select" ) ) {
+                elem.options.length = 0;
+            }
+        }
+
+        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 jQuery.access( this, function( value ) {
+            var elem = this[0] || {},
+                i = 0,
+                l = this.length;
+
+            if ( value === undefined ) {
+                return elem.nodeType === 1 ?
+                    elem.innerHTML.replace( rinlinejQuery, "" ) :
+                    undefined;
+            }
+
+            // See if we can take a shortcut and just use innerHTML
+            if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+                ( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
+                ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
+                !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
+
+                value = value.replace( rxhtmlTag, "<$1></$2>" );
+
+                try {
+                    for (; i < l; i++ ) {
+                        // Remove element nodes and prevent memory leaks
+                        elem = this[i] || {};
+                        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( value ) {
+        var isFunc = jQuery.isFunction( value );
+
+        // Make sure that the elements are removed from the DOM before they are inserted
+        // this can help fix replacing a parent with child elements
+        if ( !isFunc && typeof value !== "string" ) {
+            value = jQuery( value ).not( this ).detach();
+        }
+
+        return this.domManip( [ value ], true, function( elem ) {
+            var next = this.nextSibling,
+                parent = this.parentNode;
+
+            if ( parent ) {
+                jQuery( this ).remove();
+                parent.insertBefore( elem, next );
+            }
+        });
+    },
+
+    detach: function( selector ) {
+        return this.remove( selector, true );
+    },
+
+    domManip: function( args, table, callback ) {
+
+        // Flatten any nested arrays
+        args = core_concat.apply( [], args );
+
+        var first, node, hasScripts,
+            scripts, doc, fragment,
+            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" || jQuery.support.checkClone || !rchecked.test( value ) ) ) {
+            return this.each(function( index ) {
+                var self = set.eq( index );
+                if ( isFunction ) {
+                    args[0] = value.call( this, index, table ? self.html() : undefined );
+                }
+                self.domManip( args, table, callback );
+            });
+        }
+
+        if ( l ) {
+            fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
+            first = fragment.firstChild;
+
+            if ( fragment.childNodes.length === 1 ) {
+                fragment = first;
+            }
+
+            if ( first ) {
+                table = table && jQuery.nodeName( first, "tr" );
+                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 ) {
+                            jQuery.merge( scripts, getAll( node, "script" ) );
+                        }
+                    }
+
+                    callback.call(
+                        table && jQuery.nodeName( this[i], "table" ) ?
+                            findOrAppend( this[i], "tbody" ) :
+                            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 || "" ) &&
+                            !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
+
+                            if ( node.src ) {
+                                // Hope ajax is available...
+                                jQuery.ajax({
+                                    url: node.src,
+                                    type: "GET",
+                                    dataType: "script",
+                                    async: false,
+                                    global: false,
+                                    "throws": true
+                                });
+                            } else {
+                                jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) );
+                            }
+                        }
+                    }
+                }
+
+                // Fix #11809: Avoid leaking memory
+                fragment = first = null;
+            }
+        }
+
+        return this;
+    }
+});
+
+function findOrAppend( elem, tag ) {
+    return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+    var attr = elem.getAttributeNode("type");
+    elem.type = ( attr && attr.specified ) + "/" + 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 elem,
+        i = 0;
+    for ( ; (elem = elems[i]) != null; i++ ) {
+        jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) );
+    }
+}
+
+function cloneCopyEvent( src, dest ) {
+
+    if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
+        return;
+    }
+
+    var type, i, l,
+        oldData = jQuery._data( src ),
+        curData = jQuery._data( dest, oldData ),
+        events = oldData.events;
+
+    if ( events ) {
+        delete curData.handle;
+        curData.events = {};
+
+        for ( type in events ) {
+            for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+                jQuery.event.add( dest, type, events[ type ][ i ] );
+            }
+        }
+    }
+
+    // make the cloned public data object a copy from the original
+    if ( curData.data ) {
+        curData.data = jQuery.extend( {}, curData.data );
+    }
+}
+
+function fixCloneNodeIssues( src, dest ) {
+    var nodeName, e, data;
+
+    // We do not need to do anything for non-Elements
+    if ( dest.nodeType !== 1 ) {
+        return;
+    }
+
+    nodeName = dest.nodeName.toLowerCase();
+
+    // IE6-8 copies events bound via attachEvent when using cloneNode.
+    if ( !jQuery.support.noCloneEvent && dest[ jQuery.expando ] ) {
+        data = jQuery._data( dest );
+
+        for ( e in data.events ) {
+            jQuery.removeEvent( dest, e, data.handle );
+        }
+
+        // Event data gets referenced instead of copied if the expando gets copied too
+        dest.removeAttribute( jQuery.expando );
+    }
+
+    // IE blanks contents when cloning scripts, and tries to evaluate newly-set text
+    if ( nodeName === "script" && dest.text !== src.text ) {
+        disableScript( dest ).text = src.text;
+        restoreScript( dest );
+
+    // IE6-10 improperly clones children of object elements using classid.
+    // IE10 throws NoModificationAllowedError if parent is null, #12132.
+    } else if ( nodeName === "object" ) {
+        if ( dest.parentNode ) {
+            dest.outerHTML = src.outerHTML;
+        }
+
+        // This path appears unavoidable for IE9. When cloning an object
+        // element in IE9, the outerHTML strategy above is not sufficient.
+        // If the src has innerHTML and the destination does not,
+        // copy the src.innerHTML into the dest.innerHTML. #10324
+        if ( jQuery.support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) {
+            dest.innerHTML = src.innerHTML;
+        }
+
+    } else if ( nodeName === "input" && manipulation_rcheckableType.test( src.type ) ) {
+        // IE6-8 fails to persist the checked state of a cloned checkbox
+        // or radio button. Worse, IE6-7 fail to give the cloned element
+        // a checked appearance if the defaultChecked value isn't also set
+
+        dest.defaultChecked = dest.checked = src.checked;
+
+        // IE6-7 get confused and end up setting the value of a cloned
+        // checkbox/radio button to an empty string instead of "on"
+        if ( dest.value !== src.value ) {
+            dest.value = src.value;
+        }
+
+    // IE6-8 fails to return the selected option to the default selected
+    // state when cloning options
+    } else if ( nodeName === "option" ) {
+        dest.defaultSelected = dest.selected = src.defaultSelected;
+
+    // IE6-8 fails to set the defaultValue to the correct value when
+    // cloning other types of input fields
+    } else if ( nodeName === "input" || nodeName === "textarea" ) {
+        dest.defaultValue = src.defaultValue;
+    }
+}
+
+jQuery.each({
+    appendTo: "append",
+    prependTo: "prepend",
+    insertBefore: "before",
+    insertAfter: "after",
+    replaceAll: "replaceWith"
+}, function( name, original ) {
+    jQuery.fn[ name ] = function( selector ) {
+        var elems,
+            i = 0,
+            ret = [],
+            insert = jQuery( selector ),
+            last = insert.length - 1;
+
+        for ( ; i <= last; i++ ) {
+            elems = i === last ? this : this.clone(true);
+            jQuery( insert[i] )[ original ]( elems );
+
+            // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()
+            core_push.apply( ret, elems.get() );
+        }
+
+        return this.pushStack( ret );
+    };
+});
+
+function getAll( context, tag ) {
+    var elems, elem,
+        i = 0,
+        found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName( tag || "*" ) :
+            typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll( tag || "*" ) :
+            undefined;
+
+    if ( !found ) {
+        for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) {
+            if ( !tag || jQuery.nodeName( elem, tag ) ) {
+                found.push( elem );
+            } else {
+                jQuery.merge( found, getAll( elem, tag ) );
+            }
+        }
+    }
+
+    return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
+        jQuery.merge( [ context ], found ) :
+        found;
+}
+
+// Used in buildFragment, fixes the defaultChecked property
+function fixDefaultChecked( elem ) {
+    if ( manipulation_rcheckableType.test( elem.type ) ) {
+        elem.defaultChecked = elem.checked;
+    }
+}
+
+jQuery.extend({
+    clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+        var destElements, node, clone, i, srcElements,
+            inPage = jQuery.contains( elem.ownerDocument, elem );
+
+        if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
+            clone = elem.cloneNode( true );
+
+        // IE<=8 does not properly clone detached, unknown element nodes
+        } else {
+            fragmentDiv.innerHTML = elem.outerHTML;
+            fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
+        }
+
+        if ( (!jQuery.support.noCloneEvent || !jQuery.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 );
+
+            // Fix all IE cloning issues
+            for ( i = 0; (node = srcElements[i]) != null; ++i ) {
+                // Ensure that the destination node is not null; Fixes #9587
+                if ( destElements[i] ) {
+                    fixCloneNodeIssues( node, 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; (node = srcElements[i]) != null; i++ ) {
+                    cloneCopyEvent( node, destElements[i] );
+                }
+            } else {
+                cloneCopyEvent( elem, clone );
+            }
+        }
+
+        // Preserve script evaluation history
+        destElements = getAll( clone, "script" );
+        if ( destElements.length > 0 ) {
+            setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+        }
+
+        destElements = srcElements = node = null;
+
+        // Return the cloned set
+        return clone;
+    },
+
+    buildFragment: function( elems, context, scripts, selection ) {
+        var j, elem, contains,
+            tmp, tag, tbody, wrap,
+            l = elems.length,
+
+            // Ensure a safe fragment
+            safe = createSafeFragment( context ),
+
+            nodes = [],
+            i = 0;
+
+        for ( ; i < l; i++ ) {
+            elem = elems[ i ];
+
+            if ( elem || elem === 0 ) {
+
+                // Add nodes directly
+                if ( jQuery.type( elem ) === "object" ) {
+                    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 || safe.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;
+                    }
+
+                    // Manually add leading whitespace removed by IE
+                    if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
+                        nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) );
+                    }
+
+                    // Remove IE's autoinserted <tbody> from table fragments
+                    if ( !jQuery.support.tbody ) {
+
+                        // String was a <table>, *may* have spurious <tbody>
+                        elem = tag === "table" && !rtbody.test( elem ) ?
+                            tmp.firstChild :
+
+                            // String was a bare <thead> or <tfoot>
+                            wrap[1] === "<table>" && !rtbody.test( elem ) ?
+                                tmp :
+                                0;
+
+                        j = elem && elem.childNodes.length;
+                        while ( j-- ) {
+                            if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) {
+                                elem.removeChild( tbody );
+                            }
+                        }
+                    }
+
+                    jQuery.merge( nodes, tmp.childNodes );
+
+                    // Fix #12392 for WebKit and IE > 9
+                    tmp.textContent = "";
+
+                    // Fix #12392 for oldIE
+                    while ( tmp.firstChild ) {
+                        tmp.removeChild( tmp.firstChild );
+                    }
+
+                    // Remember the top-level container for proper cleanup
+                    tmp = safe.lastChild;
+                }
+            }
+        }
+
+        // Fix #11356: Clear elements from fragment
+        if ( tmp ) {
+            safe.removeChild( tmp );
+        }
+
+        // Reset defaultChecked for any radios and checkboxes
+        // about to be appended to the DOM in IE 6/7 (#8060)
+        if ( !jQuery.support.appendChecked ) {
+            jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked );
+        }
+
+        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( safe.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 );
+                    }
+                }
+            }
+        }
+
+        tmp = null;
+
+        return safe;
+    },
+
+    cleanData: function( elems, /* internal */ acceptData ) {
+        var elem, type, id, data,
+            i = 0,
+            internalKey = jQuery.expando,
+            cache = jQuery.cache,
+            deleteExpando = jQuery.support.deleteExpando,
+            special = jQuery.event.special;
+
+        for ( ; (elem = elems[i]) != null; i++ ) {
+
+            if ( acceptData || jQuery.acceptData( elem ) ) {
+
+                id = elem[ internalKey ];
+                data = id && cache[ id ];
+
+                if ( data ) {
+                    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 );
+                            }
+                        }
+                    }
+
+                    // Remove cache only if it was not already removed by jQuery.event.remove
+                    if ( cache[ id ] ) {
+
+                        delete cache[ id ];
+
+                        // IE does not allow us to delete expando properties from nodes,
+                        // nor does it have a removeAttribute function on Document nodes;
+                        // we must handle all of these cases
+                        if ( deleteExpando ) {
+                            delete elem[ internalKey ];
+
+                        } else if ( typeof elem.removeAttribute !== core_strundefined ) {
+                            elem.removeAttribute( internalKey );
+
+                        } else {
+                            elem[ internalKey ] = null;
+                        }
+
+                        core_deletedIds.push( id );
+                    }
+                }
+            }
+        }
+    }
+});
+var iframe, getStyles, curCSS,
+    ralpha = /alpha\([^)]*\)/i,
+    ropacity = /opacity\s*=\s*([^)]*)/,
+    rposition = /^(top|right|bottom|left)$/,
+    // 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]).+)/,
+    rmargin = /^margin/,
+    rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
+    rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
+    rrelNum = new RegExp( "^([+-])=(" + core_pnum + ")", "i" ),
+    elemdisplay = { BODY: "block" },
+
+    cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+    cssNormalTransform = {
+        letterSpacing: 0,
+        fontWeight: 400
+    },
+
+    cssExpand = [ "Top", "Right", "Bottom", "Left" ],
+    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.charAt(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 isHidden( 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 );
+}
+
+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 ] = jQuery._data( 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 ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
+            }
+        } else {
+
+            if ( !values[ index ] ) {
+                hidden = isHidden( elem );
+
+                if ( display && display !== "none" || !hidden ) {
+                    jQuery._data( 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.fn.extend({
+    css: function( name, value ) {
+        return jQuery.access( this, function( elem, name, value ) {
+            var len, styles,
+                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 ) {
+        var bool = typeof state === "boolean";
+
+        return this.each(function() {
+            if ( bool ? state : isHidden( this ) ) {
+                jQuery( this ).show();
+            } else {
+                jQuery( this ).hide();
+            }
+        });
+    }
+});
+
+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;
+                }
+            }
+        }
+    },
+
+    // Exclude the following css properties to add px
+    cssNumber: {
+        "columnCount": true,
+        "fillOpacity": true,
+        "fontWeight": true,
+        "lineHeight": true,
+        "opacity": 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: {
+        // normalize float css property
+        "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
+    },
+
+    // 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
+        // followed by the unprefixed version
+        hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+        // Check if we're setting a value
+        if ( value !== undefined ) {
+            type = typeof value;
+
+            // convert relative number strings (+= 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 NaN and null values aren't set. See: #7116
+            if ( value == null || type === "number" && isNaN( value ) ) {
+                return;
+            }
+
+            // If a number was passed in, add 'px' to the (except for certain CSS properties)
+            if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
+                value += "px";
+            }
+
+            // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,
+            // but it would mean to define eight (for every problematic property) identical functions
+            if ( !jQuery.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 ) {
+
+                // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
+                // Fixes bug #5509
+                try {
+                    style[ name ] = value;
+                } catch(e) {}
+            }
+
+        } 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 num, val, 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 ) );
+
+        // gets hook for the prefixed version
+        // followed by the unprefixed version
+        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 ];
+        }
+
+        // Return, converting to number 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;
+    },
+
+    // A method for quickly swapping in/out CSS properties to get correct calculations
+    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;
+    }
+});
+
+// NOTE: we've included the "window" in window.getComputedStyle
+// because jsdom on node.js will break without it.
+if ( window.getComputedStyle ) {
+    getStyles = function( elem ) {
+        return window.getComputedStyle( elem, null );
+    };
+
+    curCSS = function( elem, name, _computed ) {
+        var width, minWidth, maxWidth,
+            computed = _computed || getStyles( elem ),
+
+            // getPropertyValue is only needed for .css('filter') in IE9, see #12537
+            ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined,
+            style = elem.style;
+
+        if ( computed ) {
+
+            if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
+                ret = jQuery.style( elem, name );
+            }
+
+            // A tribute to the "awesome hack by Dean Edwards"
+            // Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
+            // Safari 5.1.7 (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;
+    };
+} else if ( document.documentElement.currentStyle ) {
+    getStyles = function( elem ) {
+        return elem.currentStyle;
+    };
+
+    curCSS = function( elem, name, _computed ) {
+        var left, rs, rsLeft,
+            computed = _computed || getStyles( elem ),
+            ret = computed ? computed[ name ] : undefined,
+            style = elem.style;
+
+        // Avoid setting ret to empty string here
+        // so we don't default to auto
+        if ( ret == null && style && style[ name ] ) {
+            ret = style[ name ];
+        }
+
+        // From the awesome hack by Dean Edwards
+        // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
+
+        // If we're not dealing with a regular pixel number
+        // but a number that has a weird ending, we need to convert it to pixels
+        // but not position css attributes, as those are proportional to the parent element instead
+        // and we can't measure the parent instead because it might trigger a "stacking dolls" problem
+        if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
+
+            // Remember the original values
+            left = style.left;
+            rs = elem.runtimeStyle;
+            rsLeft = rs && rs.left;
+
+            // Put in the new values to get a computed value out
+            if ( rsLeft ) {
+                rs.left = elem.currentStyle.left;
+            }
+            style.left = name === "fontSize" ? "1em" : ret;
+            ret = style.pixelLeft + "px";
+
+            // Revert the changed values
+            style.left = left;
+            if ( rsLeft ) {
+                rs.left = rsLeft;
+            }
+        }
+
+        return ret === "" ? "auto" : ret;
+    };
+}
+
+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.support.boxSizing && 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;
+        }
+
+        // we need the check for style in case a browser which returns unreliable values
+        // for getComputedStyle silently falls back to the reliable elem.style
+        valueIsBorderBox = isBorderBox && ( jQuery.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";
+}
+
+// Try to determine the default display value of an element
+function css_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'/>")
+                .css( "cssText", "display:block !important" )
+            ).appendTo( doc.documentElement );
+
+            // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
+            doc = ( iframe[0].contentWindow || iframe[0].contentDocument ).document;
+            doc.write("<!doctype html><html><body>");
+            doc.close();
+
+            display = actualDisplay( nodeName, doc );
+            iframe.detach();
+        }
+
+        // Store the correct default display
+        elemdisplay[ nodeName ] = display;
+    }
+
+    return display;
+}
+
+// Called ONLY from within css_defaultDisplay
+function actualDisplay( name, doc ) {
+    var elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
+        display = jQuery.css( elem[0], "display" );
+    elem.remove();
+    return display;
+}
+
+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
+                // however, it must have a current display style that would benefit from this
+                return elem.offsetWidth === 0 && rdisplayswap.test( jQuery.css( elem, "display" ) ) ?
+                    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.support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+                    styles
+                ) : 0
+            );
+        }
+    };
+});
+
+if ( !jQuery.support.opacity ) {
+    jQuery.cssHooks.opacity = {
+        get: function( elem, computed ) {
+            // IE uses filters for opacity
+            return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
+                ( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
+                computed ? "1" : "";
+        },
+
+        set: function( elem, value ) {
+            var style = elem.style,
+                currentStyle = elem.currentStyle,
+                opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
+                filter = currentStyle && currentStyle.filter || style.filter || "";
+
+            // IE has trouble with opacity if it does not have layout
+            // Force it by setting the zoom level
+            style.zoom = 1;
+
+            // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
+            // if value === "", then remove inline opacity #12685
+            if ( ( value >= 1 || value === "" ) &&
+                    jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
+                    style.removeAttribute ) {
+
+                // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
+                // if "filter:" is present at all, clearType is disabled, we want to avoid this
+                // style.removeAttribute is IE Only, but so apparently is this code path...
+                style.removeAttribute( "filter" );
+
+                // if there is no filter style applied in a css rule or unset inline opacity, we are done
+                if ( value === "" || currentStyle && !currentStyle.filter ) {
+                    return;
+                }
+            }
+
+            // otherwise, set new filter values
+            style.filter = ralpha.test( filter ) ?
+                filter.replace( ralpha, opacity ) :
+                filter + " " + opacity;
+        }
+    };
+}
+
+// These hooks cannot be added until DOM ready because the support test
+// for it is not run until after DOM ready
+jQuery(function() {
+    if ( !jQuery.support.reliableMarginRight ) {
+        jQuery.cssHooks.marginRight = {
+            get: function( elem, computed ) {
+                if ( computed ) {
+                    // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
+                    // Work around by temporarily setting element display to inline-block
+                    return jQuery.swap( elem, { "display": "inline-block" },
+                        curCSS, [ elem, "marginRight" ] );
+                }
+            }
+        };
+    }
+
+    // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+    // getComputedStyle returns percent when specified for top/left/bottom/right
+    // rather than make the css module depend on the offset module, we just check for it here
+    if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
+        jQuery.each( [ "top", "left" ], function( i, prop ) {
+            jQuery.cssHooks[ prop ] = {
+                get: 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;
+                    }
+                }
+            };
+        });
+    }
+
+});
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+    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.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
+    };
+
+    jQuery.expr.filters.visible = function( elem ) {
+        return !jQuery.expr.filters.hidden( elem );
+    };
+}
+
+// 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;
+    }
+});
+var r20 = /%20/g,
+    rbracket = /\[\]$/,
+    rCRLF = /\r?\n/g,
+    rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+    rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+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 || !manipulation_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();
+    }
+});
+
+//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, "+" );
+};
+
+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 );
+    }
+}
+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.hover = function( fnOver, fnOut ) {
+    return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
+};
+var
+    // Document location
+    ajaxLocParts,
+    ajaxLocation,
+    ajax_nonce = jQuery.now(),
+
+    ajax_rquery = /\?/,
+    rhash = /#.*$/,
+    rts = /([?&])_=[^&]*/,
+    rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
+    // #7653, #8125, #8152: local protocol detection
+    rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+    rnoContent = /^(?:GET|HEAD)$/,
+    rprotocol = /^\/\//,
+    rurl = /^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
+
+    // Keep a copy of the old load method
+    _load = jQuery.fn.load,
+
+    /* 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("*");
+
+// #8138, IE may throw an exception when accessing
+// a field from window.location if document.domain has been set
+try {
+    ajaxLocation = location.href;
+} catch( e ) {
+    // Use the href attribute of an A element
+    // since IE will modify it given document.location
+    ajaxLocation = document.createElement( "a" );
+    ajaxLocation.href = "";
+    ajaxLocation = ajaxLocation.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( core_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 deep, key,
+        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;
+}
+
+jQuery.fn.load = function( url, params, callback ) {
+    if ( typeof url !== "string" && _load ) {
+        return _load.apply( this, arguments );
+    }
+
+    var selector, response, type,
+        self = this,
+        off = url.indexOf(" ");
+
+    if ( off >= 0 ) {
+        selector = url.slice( off, url.length );
+        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.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.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"
+        },
+
+        // Data converters
+        // Keys separate source (or catchall "*") and destination types with a single space
+        converters: {
+
+            // Convert anything to text
+            "* text": window.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 // Cross-domain detection vars
+            parts,
+            // Loop variable
+            i,
+            // URL without anti-cache param
+            cacheURL,
+            // Response headers as string
+            responseHeadersString,
+            // timeout handle
+            timeoutTimer,
+
+            // To know if global events are to be dispatched
+            fireGlobals,
+
+            transport,
+            // Response headers
+            responseHeaders,
+            // 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 (#5866: IE7 issue with protocol-less urls)
+        // 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( core_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
+        fireGlobals = 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 += ( ajax_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_=" + ajax_nonce++ ) :
+
+                    // Otherwise add one to the end
+                    cacheURL + ( ajax_rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ajax_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;
+
+            // Get response data
+            if ( responses ) {
+                response = ajaxHandleResponses( s, jqXHR, responses );
+            }
+
+            // If successful, handle type chaining
+            if ( status >= 200 && status < 300 || status === 304 ) {
+
+                // 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 ) {
+                    isSuccess = true;
+                    statusText = "nocontent";
+
+                // if not modified
+                } else if ( status === 304 ) {
+                    isSuccess = true;
+                    statusText = "notmodified";
+
+                // If we have data, let's convert it
+                } else {
+                    isSuccess = ajaxConvert( s, response );
+                    statusText = isSuccess.state;
+                    success = isSuccess.data;
+                    error = isSuccess.error;
+                    isSuccess = !error;
+                }
+            } else {
+                // We extract error from statusText
+                // then normalize statusText and status 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;
+    },
+
+    getScript: function( url, callback ) {
+        return jQuery.get( url, undefined, callback, "script" );
+    },
+
+    getJSON: function( url, data, callback ) {
+        return jQuery.get( url, data, callback, "json" );
+    }
+});
+
+/* Handles responses to an ajax request:
+ * - sets all responseXXX fields accordingly
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+    var firstDataType, ct, finalDataType, type,
+        contents = s.contents,
+        dataTypes = s.dataTypes,
+        responseFields = s.responseFields;
+
+    // Fill responseXXX fields
+    for ( type in responseFields ) {
+        if ( type in responses ) {
+            jqXHR[ responseFields[type] ] = responses[ type ];
+        }
+    }
+
+    // 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
+function ajaxConvert( s, response ) {
+    var conv2, current, conv, tmp,
+        converters = {},
+        i = 0,
+        // Work with a copy of dataTypes in case we need to modify it for conversion
+        dataTypes = s.dataTypes.slice(),
+        prev = dataTypes[ 0 ];
+
+    // Apply the dataFilter if provided
+    if ( s.dataFilter ) {
+        response = s.dataFilter( response, s.dataType );
+    }
+
+    // Create converters map with lowercased keys
+    if ( dataTypes[ 1 ] ) {
+        for ( conv in s.converters ) {
+            converters[ conv.toLowerCase() ] = s.converters[ conv ];
+        }
+    }
+
+    // Convert to each sequential dataType, tolerating list modification
+    for ( ; (current = dataTypes[++i]); ) {
+
+        // There's only work to do if current dataType is non-auto
+        if ( current !== "*" ) {
+
+            // Convert response if prev dataType is non-auto and differs from current
+            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.splice( i--, 0, current );
+                                }
+
+                                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 };
+                        }
+                    }
+                }
+            }
+
+            // Update prev for next iteration
+            prev = current;
+        }
+    }
+
+    return { state: "success", data: response };
+}
+// 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 global
+jQuery.ajaxPrefilter( "script", function( s ) {
+    if ( s.cache === undefined ) {
+        s.cache = false;
+    }
+    if ( s.crossDomain ) {
+        s.type = "GET";
+        s.global = false;
+    }
+});
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function(s) {
+
+    // This transport only deals with cross domain requests
+    if ( s.crossDomain ) {
+
+        var script,
+            head = document.head || jQuery("head")[0] || document.documentElement;
+
+        return {
+
+            send: function( _, callback ) {
+
+                script = document.createElement("script");
+
+                script.async = true;
+
+                if ( s.scriptCharset ) {
+                    script.charset = s.scriptCharset;
+                }
+
+                script.src = s.url;
+
+                // Attach handlers for all browsers
+                script.onload = script.onreadystatechange = function( _, isAbort ) {
+
+                    if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
+
+                        // Handle memory leak in IE
+                        script.onload = script.onreadystatechange = null;
+
+                        // Remove the script
+                        if ( script.parentNode ) {
+                            script.parentNode.removeChild( script );
+                        }
+
+                        // Dereference the script
+                        script = null;
+
+                        // Callback if not abort
+                        if ( !isAbort ) {
+                            callback( 200, "success" );
+                        }
+                    }
+                };
+
+                // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending
+                // Use native DOM manipulation to avoid our domManip AJAX trickery
+                head.insertBefore( script, head.firstChild );
+            },
+
+            abort: function() {
+                if ( script ) {
+                    script.onload( undefined, true );
+                }
+            }
+        };
+    }
+});
+var oldCallbacks = [],
+    rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup({
+    jsonp: "callback",
+    jsonpCallback: function() {
+        var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( ajax_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 += ( ajax_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";
+    }
+});
+var xhrCallbacks, xhrSupported,
+    xhrId = 0,
+    // #5280: Internet Explorer will keep connections alive if we don't abort on unload
+    xhrOnUnloadAbort = window.ActiveXObject && function() {
+        // Abort all pending requests
+        var key;
+        for ( key in xhrCallbacks ) {
+            xhrCallbacks[ key ]( undefined, true );
+        }
+    };
+
+// Functions to create xhrs
+function createStandardXHR() {
+    try {
+        return new window.XMLHttpRequest();
+    } catch( e ) {}
+}
+
+function createActiveXHR() {
+    try {
+        return new window.ActiveXObject("Microsoft.XMLHTTP");
+    } catch( e ) {}
+}
+
+// Create the request object
+// (This is still attached to ajaxSettings for backward compatibility)
+jQuery.ajaxSettings.xhr = window.ActiveXObject ?
+    /* Microsoft failed to properly
+     * implement the XMLHttpRequest in IE7 (can't request local files),
+     * so we use the ActiveXObject when it is available
+     * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
+     * we need a fallback.
+     */
+    function() {
+        return !this.isLocal && createStandardXHR() || createActiveXHR();
+    } :
+    // For all other browsers, use the standard XMLHttpRequest object
+    createStandardXHR;
+
+// Determine support properties
+xhrSupported = jQuery.ajaxSettings.xhr();
+jQuery.support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+xhrSupported = jQuery.support.ajax = !!xhrSupported;
+
+// Create transport if the browser can provide an xhr
+if ( xhrSupported ) {
+
+    jQuery.ajaxTransport(function( s ) {
+        // Cross domain only allowed if supported through XMLHttpRequest
+        if ( !s.crossDomain || jQuery.support.cors ) {
+
+            var callback;
+
+            return {
+                send: function( headers, complete ) {
+
+                    // Get a new xhr
+                    var handle, i,
+                        xhr = s.xhr();
+
+                    // Open the socket
+                    // Passing null username, generates a login popup on Opera (#2865)
+                    if ( s.username ) {
+                        xhr.open( s.type, s.url, s.async, s.username, s.password );
+                    } else {
+                        xhr.open( s.type, s.url, s.async );
+                    }
+
+                    // Apply custom fields if provided
+                    if ( s.xhrFields ) {
+                        for ( i in s.xhrFields ) {
+                            xhr[ i ] = s.xhrFields[ i ];
+                        }
+                    }
+
+                    // Override mime type if needed
+                    if ( s.mimeType && xhr.overrideMimeType ) {
+                        xhr.overrideMimeType( s.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 ( !s.crossDomain && !headers["X-Requested-With"] ) {
+                        headers["X-Requested-With"] = "XMLHttpRequest";
+                    }
+
+                    // Need an extra try/catch for cross domain requests in Firefox 3
+                    try {
+                        for ( i in headers ) {
+                            xhr.setRequestHeader( i, headers[ i ] );
+                        }
+                    } catch( err ) {}
+
+                    // Do send the request
+                    // This may raise an exception which is actually
+                    // handled in jQuery.ajax (so no try/catch here)
+                    xhr.send( ( s.hasContent && s.data ) || null );
+
+                    // Listener
+                    callback = function( _, isAbort ) {
+                        var status, responseHeaders, statusText, responses;
+
+                        // Firefox throws exceptions when accessing properties
+                        // of an xhr when a network error occurred
+                        // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
+                        try {
+
+                            // Was never called and is aborted or complete
+                            if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
+
+                                // Only called once
+                                callback = undefined;
+
+                                // Do not keep as active anymore
+                                if ( handle ) {
+                                    xhr.onreadystatechange = jQuery.noop;
+                                    if ( xhrOnUnloadAbort ) {
+                                        delete xhrCallbacks[ handle ];
+                                    }
+                                }
+
+                                // If it's an abort
+                                if ( isAbort ) {
+                                    // Abort it manually if needed
+                                    if ( xhr.readyState !== 4 ) {
+                                        xhr.abort();
+                                    }
+                                } else {
+                                    responses = {};
+                                    status = xhr.status;
+                                    responseHeaders = xhr.getAllResponseHeaders();
+
+                                    // When requesting binary data, IE6-9 will throw an exception
+                                    // on any attempt to access responseText (#11426)
+                                    if ( typeof xhr.responseText === "string" ) {
+                                        responses.text = xhr.responseText;
+                                    }
+
+                                    // Firefox throws an exception when accessing
+                                    // statusText for faulty cross-domain requests
+                                    try {
+                                        statusText = xhr.statusText;
+                                    } catch( e ) {
+                                        // We normalize with Webkit giving an empty statusText
+                                        statusText = "";
+                                    }
+
+                                    // Filter status for non standard behaviors
+
+                                    // If the request is local and we have data: assume a success
+                                    // (success with no data won't get notified, that's the best we
+                                    // can do given current implementations)
+                                    if ( !status && s.isLocal && !s.crossDomain ) {
+                                        status = responses.text ? 200 : 404;
+                                    // IE - #1450: sometimes returns 1223 when it should be 204
+                                    } else if ( status === 1223 ) {
+                                        status = 204;
+                                    }
+                                }
+                            }
+                        } catch( firefoxAccessException ) {
+                            if ( !isAbort ) {
+                                complete( -1, firefoxAccessException );
+                            }
+                        }
+
+                        // Call complete if needed
+                        if ( responses ) {
+                            complete( status, statusText, responses, responseHeaders );
+                        }
+                    };
+
+                    if ( !s.async ) {
+                        // if we're in sync mode we fire the callback
+                        callback();
+                    } else if ( xhr.readyState === 4 ) {
+                        // (IE6 & IE7) if it's in cache and has been
+                        // retrieved directly we need to fire the callback
+                        setTimeout( callback );
+                    } else {
+                        handle = ++xhrId;
+                        if ( xhrOnUnloadAbort ) {
+                            // Create the active xhrs callbacks list if needed
+                            // and attach the unload handler
+                            if ( !xhrCallbacks ) {
+                                xhrCallbacks = {};
+                                jQuery( window ).unload( xhrOnUnloadAbort );
+                            }
+                            // Add to list of active xhrs callbacks
+                            xhrCallbacks[ handle ] = callback;
+                        }
+                        xhr.onreadystatechange = callback;
+                    }
+                },
+
+                abort: function() {
+                    if ( callback ) {
+                        callback( undefined, true );
+                    }
+                }
+            };
+        }
+    });
+}
+var fxNow, timerId,
+    rfxtypes = /^(?:toggle|show|hide)$/,
+    rfxnum = new RegExp( "^(?:([+-])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
+    rrun = /queueHooks$/,
+    animationPrefilters = [ defaultPrefilter ],
+    tweeners = {
+        "*": [function( prop, value ) {
+            var end, unit,
+                tween = this.createTween( prop, value ),
+                parts = rfxnum.exec( value ),
+                target = tween.cur(),
+                start = +target || 0,
+                scale = 1,
+                maxIterations = 20;
+
+            if ( parts ) {
+                end = +parts[2];
+                unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+
+                // We need to compute starting value
+                if ( unit !== "px" && start ) {
+                    // Iteratively approximate from a nonzero starting point
+                    // Prefer the current property, because this process will be trivial if it uses the same units
+                    // Fallback to end or a simple constant
+                    start = jQuery.css( tween.elem, prop, true ) || end || 1;
+
+                    do {
+                        // If previous iteration zeroed out, double until we get *something*
+                        // Use a string for doubling factor 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()
+                    // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
+                    } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
+                }
+
+                tween.unit = unit;
+                tween.start = start;
+                // If a +=/-= token was provided, we're doing a relative animation
+                tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
+            }
+            return tween;
+        }]
+    };
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+    setTimeout(function() {
+        fxNow = undefined;
+    });
+    return ( fxNow = jQuery.now() );
+}
+
+function createTweens( animation, props ) {
+    jQuery.each( props, function( prop, value ) {
+        var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
+            index = 0,
+            length = collection.length;
+        for ( ; index < length; index++ ) {
+            if ( collection[ index ].call( animation, prop, value ) ) {
+
+                // we're done with this property
+                return;
+            }
+        }
+    });
+}
+
+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 ),
+                // 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;
+        }
+    }
+
+    createTweens( animation, props );
+
+    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 );
+}
+
+function propFilter( props, specialEasing ) {
+    var value, name, index, easing, 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 wont overwrite keys already present.
+            // also - reusing 'index' from above 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;
+        }
+    }
+}
+
+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 );
+        }
+    }
+});
+
+function defaultPrefilter( elem, props, opts ) {
+    /*jshint validthis:true */
+    var prop, index, length,
+        value, dataShow, toggle,
+        tween, hooks, oldfire,
+        anim = this,
+        style = elem.style,
+        orig = {},
+        handled = [],
+        hidden = elem.nodeType && isHidden( elem );
+
+    // 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() {
+            // doing this makes sure that the complete handler will be 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 IE does 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
+        if ( jQuery.css( elem, "display" ) === "inline" &&
+                jQuery.css( elem, "float" ) === "none" ) {
+
+            // inline-level elements accept inline-block;
+            // block-level elements need to be inline with layout
+            if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
+                style.display = "inline-block";
+
+            } else {
+                style.zoom = 1;
+            }
+        }
+    }
+
+    if ( opts.overflow ) {
+        style.overflow = "hidden";
+        if ( !jQuery.support.shrinkWrapBlocks ) {
+            anim.always(function() {
+                style.overflow = opts.overflow[ 0 ];
+                style.overflowX = opts.overflow[ 1 ];
+                style.overflowY = opts.overflow[ 2 ];
+            });
+        }
+    }
+
+
+    // show/hide pass
+    for ( index in props ) {
+        value = props[ index ];
+        if ( rfxtypes.exec( value ) ) {
+            delete props[ index ];
+            toggle = toggle || value === "toggle";
+            if ( value === ( hidden ? "hide" : "show" ) ) {
+                continue;
+            }
+            handled.push( index );
+        }
+    }
+
+    length = handled.length;
+    if ( length ) {
+        dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
+        if ( "hidden" in dataShow ) {
+            hidden = dataShow.hidden;
+        }
+
+        // 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;
+            jQuery._removeData( elem, "fxshow" );
+            for ( prop in orig ) {
+                jQuery.style( elem, prop, orig[ prop ] );
+            }
+        });
+        for ( index = 0 ; index < length ; index++ ) {
+            prop = handled[ index ];
+            tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
+            orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
+
+            if ( !( prop in dataShow ) ) {
+                dataShow[ prop ] = tween.start;
+                if ( hidden ) {
+                    tween.end = tween.start;
+                    tween.start = prop === "width" || prop === "height" ? 1 : 0;
+                }
+            }
+        }
+    }
+}
+
+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
+            // so, 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 its
+            // 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;
+            }
+        }
+    }
+};
+
+// Remove in 2.0 - this supports IE8's 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.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 );
+    };
+});
+
+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 );
+                doAnimation.finish = function() {
+                    anim.stop( true );
+                };
+                // Empty animations, or finishing resolves immediately
+                if ( empty || jQuery._data( 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 = jQuery._data( 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 = jQuery._data( 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.cur && hooks.cur.finish ) {
+                hooks.cur.finish.call( this );
+            }
+
+            // 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;
+        });
+    }
+});
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+    var which,
+        attrs = { height: type },
+        i = 0;
+
+    // if we include width, step value is 1 to do all cssExpand values,
+    // if we don't include width, 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;
+}
+
+// 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.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.easing = {
+    linear: function( p ) {
+        return p;
+    },
+    swing: function( p ) {
+        return 0.5 - Math.cos( p*Math.PI ) / 2;
+    }
+};
+
+jQuery.timers = [];
+jQuery.fx = Tween.prototype.init;
+jQuery.fx.tick = function() {
+    var timer,
+        timers = jQuery.timers,
+        i = 0;
+
+    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 ) {
+    if ( timer() && jQuery.timers.push( timer ) ) {
+        jQuery.fx.start();
+    }
+};
+
+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
+};
+
+// Back Compat <1.8 extension point
+jQuery.fx.step = {};
+
+if ( jQuery.expr && jQuery.expr.filters ) {
+    jQuery.expr.filters.animated = function( elem ) {
+        return jQuery.grep(jQuery.timers, function( fn ) {
+            return elem === fn.elem;
+        }).length;
+    };
+}
+jQuery.fn.offset = function( options ) {
+    if ( arguments.length ) {
+        return options === undefined ?
+            this :
+            this.each(function( i ) {
+                jQuery.offset.setOffset( this, options, i );
+            });
+    }
+
+    var docElem, win,
+        box = { top: 0, left: 0 },
+        elem = this[ 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;
+    }
+
+    // If we don't have gBCR, just use 0,0 rather than error
+    // BlackBerry 5, iOS 3 (original iPhone)
+    if ( typeof elem.getBoundingClientRect !== core_strundefined ) {
+        box = elem.getBoundingClientRect();
+    }
+    win = getWindow( doc );
+    return {
+        top: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),
+        left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )
+    };
+};
+
+jQuery.offset = {
+
+    setOffset: function( elem, options, i ) {
+        var position = jQuery.css( elem, "position" );
+
+        // set position first, in-case top/left are set even on static elem
+        if ( position === "static" ) {
+            elem.style.position = "relative";
+        }
+
+        var curElem = jQuery( elem ),
+            curOffset = curElem.offset(),
+            curCSSTop = jQuery.css( elem, "top" ),
+            curCSSLeft = jQuery.css( elem, "left" ),
+            calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
+            props = {}, curPosition = {}, curTop, curLeft;
+
+        // 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({
+
+    position: function() {
+        if ( !this[ 0 ] ) {
+            return;
+        }
+
+        var offsetParent, offset,
+            parentOffset = { top: 0, left: 0 },
+            elem = this[ 0 ];
+
+        // fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent
+        if ( jQuery.css( elem, "position" ) === "fixed" ) {
+            // we assume that getBoundingClientRect is available 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
+        // note: when an element has margin: auto the offsetLeft and marginLeft
+        // are the same in Safari causing offset.left to incorrectly be 0
+        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 || document.documentElement;
+            while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position") === "static" ) ) {
+                offsetParent = offsetParent.offsetParent;
+            }
+            return offsetParent || document.documentElement;
+        });
+    }
+});
+
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
+    var top = /Y/.test( prop );
+
+    jQuery.fn[ method ] = function( val ) {
+        return jQuery.access( this, function( elem, method, val ) {
+            var win = getWindow( elem );
+
+            if ( val === undefined ) {
+                return win ? (prop in win) ? win[ prop ] :
+                    win.document.documentElement[ method ] :
+                    elem[ method ];
+            }
+
+            if ( win ) {
+                win.scrollTo(
+                    !top ? val : jQuery( win ).scrollLeft(),
+                    top ? val : jQuery( win ).scrollTop()
+                );
+
+            } else {
+                elem[ method ] = val;
+            }
+        }, method, val, arguments.length, null );
+    };
+});
+
+function getWindow( elem ) {
+    return jQuery.isWindow( elem ) ?
+        elem :
+        elem.nodeType === 9 ?
+            elem.defaultView || elem.parentWindow :
+            false;
+}
+// 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 jQuery.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
+                    // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
+                    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 );
+        };
+    });
+});
+// Limit scope pollution from any deprecated API
+// (function() {
+
+// })();
+// Expose jQuery to the global object
+window.jQuery = window.$ = jQuery;
+
+// Expose jQuery as an AMD module, but only for AMD loaders that
+// understand the issues with loading multiple versions of jQuery
+// in a page that all might call define(). The loader will indicate
+// they have special allowances for multiple jQuery versions by
+// specifying define.amd.jQuery = true. Register as a named module,
+// since jQuery can be concatenated with other files that may use define,
+// but not use 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.
+if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
+    define( "jquery", [], function () { return jQuery; } );
+}
+
+})( window );
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/resources/js/log.js b/afb-client/bower_components/tether/examples/resources/js/log.js
new file mode 100644
index 0000000..6acd4fd
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/resources/js/log.js
@@ -0,0 +1,134 @@
+(function() {
+  var ffSupport, formats, getOrderedMatches, hasMatches, isFF, isIE, isOpera, isSafari, log, makeArray, operaSupport, safariSupport, stringToArgs, _log;
+  if (!(window.console && window.console.log)) {
+    return;
+  }
+  log = function() {
+    var args;
+    args = [];
+    makeArray(arguments).forEach(function(arg) {
+      if (typeof arg === 'string') {
+        return args = args.concat(stringToArgs(arg));
+      } else {
+        return args.push(arg);
+      }
+    });
+    return _log.apply(window, args);
+  };
+  _log = function() {
+    return console.log.apply(console, makeArray(arguments));
+  };
+  makeArray = function(arrayLikeThing) {
+    return Array.prototype.slice.call(arrayLikeThing);
+  };
+  formats = [
+    {
+      regex: /\*([^\*]+)\*/,
+      replacer: function(m, p1) {
+        return "%c" + p1 + "%c";
+      },
+      styles: function() {
+        return ['font-style: italic', ''];
+      }
+    }, {
+      regex: /\_([^\_]+)\_/,
+      replacer: function(m, p1) {
+        return "%c" + p1 + "%c";
+      },
+      styles: function() {
+        return ['font-weight: bold', ''];
+      }
+    }, {
+      regex: /\`([^\`]+)\`/,
+      replacer: function(m, p1) {
+        return "%c" + p1 + "%c";
+      },
+      styles: function() {
+        return ['background: rgb(255, 255, 219); padding: 1px 5px; border: 1px solid rgba(0, 0, 0, 0.1)', ''];
+      }
+    }, {
+      regex: /\[c\=(?:\"|\')?((?:(?!(?:\"|\')\]).)*)(?:\"|\')?\]((?:(?!\[c\]).)*)\[c\]/,
+      replacer: function(m, p1, p2) {
+        return "%c" + p2 + "%c";
+      },
+      styles: function(match) {
+        return [match[1], ''];
+      }
+    }
+  ];
+  hasMatches = function(str) {
+    var _hasMatches;
+    _hasMatches = false;
+    formats.forEach(function(format) {
+      if (format.regex.test(str)) {
+        return _hasMatches = true;
+      }
+    });
+    return _hasMatches;
+  };
+  getOrderedMatches = function(str) {
+    var matches;
+    matches = [];
+    formats.forEach(function(format) {
+      var match;
+      match = str.match(format.regex);
+      if (match) {
+        return matches.push({
+          format: format,
+          match: match
+        });
+      }
+    });
+    return matches.sort(function(a, b) {
+      return a.match.index - b.match.index;
+    });
+  };
+  stringToArgs = function(str) {
+    var firstMatch, matches, styles;
+    styles = [];
+    while (hasMatches(str)) {
+      matches = getOrderedMatches(str);
+      firstMatch = matches[0];
+      str = str.replace(firstMatch.format.regex, firstMatch.format.replacer);
+      styles = styles.concat(firstMatch.format.styles(firstMatch.match));
+    }
+    return [str].concat(styles);
+  };
+  isSafari = function() {
+    return /Safari/.test(navigator.userAgent) && /Apple Computer/.test(navigator.vendor);
+  };
+  isOpera = function() {
+    return /OPR/.test(navigator.userAgent) && /Opera/.test(navigator.vendor);
+  };
+  isFF = function() {
+    return /Firefox/.test(navigator.userAgent);
+  };
+  isIE = function() {
+    return /MSIE/.test(navigator.userAgent);
+  };
+  safariSupport = function() {
+    var m;
+    m = navigator.userAgent.match(/AppleWebKit\/(\d+)\.(\d+)(\.|\+|\s)/);
+    if (!m) {
+      return false;
+    }
+    return 537.38 <= parseInt(m[1], 10) + (parseInt(m[2], 10) / 100);
+  };
+  operaSupport = function() {
+    var m;
+    m = navigator.userAgent.match(/OPR\/(\d+)\./);
+    if (!m) {
+      return false;
+    }
+    return 15 <= parseInt(m[1], 10);
+  };
+  ffSupport = function() {
+    return window.console.firebug || window.console.exception;
+  };
+  if (isIE() || (isFF() && !ffSupport()) || (isOpera() && !operaSupport()) || (isSafari() && !safariSupport())) {
+    window.log = _log;
+  } else {
+    window.log = log;
+  }
+  window.log.l = _log;
+}).call(this);
\ No newline at end of file
diff --git a/afb-client/bower_components/tether/examples/scroll/index.html b/afb-client/bower_components/tether/examples/scroll/index.html
new file mode 100644
index 0000000..40b0a61
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/scroll/index.html
@@ -0,0 +1,922 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+    </head>
+    <body>
+
+    <div class="instructions">Scroll the page</div>
+
+    <h2>THE END OF THE TETHER</h2>
+
+    <p>By Joseph Conrad</p>
+
+    <h3>Chapter I</h3>
+
+    <p>For a long time after the course of the steamer <em>Sofala</em> had been
+    altered for the land, the low swampy coast had retained its appearance
+    of a mere smudge of darkness beyond a belt of glitter. The sunrays
+    seemed to fall violently upon the calm sea--seemed to shatter themselves
+    upon an adamantine surface into sparkling dust, into a dazzling vapor
+    of light that blinded the eye and wearied the brain with its unsteady
+    brightness.</p>
+
+    <p>Captain Whalley did not look at it. When his Serang, approaching the
+    roomy cane arm-chair which he filled capably, had informed him in a low
+    voice that the course was to be altered, he had risen at once and had
+    remained on his feet, face forward, while the head of his ship swung
+    through a quarter of a circle. He had not uttered a single word, not
+    even the word to steady the helm. It was the Serang, an elderly, alert,
+    little Malay, with a very dark skin, who murmured the order to the
+    helmsman. And then slowly Captain Whalley sat down again in the
+    arm-chair on the bridge and fixed his eyes on the deck between his feet.</p>
+
+    <p>He could not hope to see anything new upon this lane of the sea. He had
+    been on these coasts for the last three years. From Low Cape to Malantan
+    the distance was fifty miles, six hours' steaming for the old ship with
+    the tide, or seven against. Then you steered straight for the land, and
+    by-and-by three palms would appear on the sky, tall and slim, and with
+    their disheveled heads in a bunch, as if in confidential criticism of
+    the dark mangroves. The Sofala would be headed towards the somber
+    strip of the coast, which at a given moment, as the ship closed with
+    it obliquely, would show several clean shining fractures--the brimful
+    estuary of a river. Then on through a brown liquid, three parts water
+    and one part black earth, on and on between the low shores, three parts
+    black earth and one part brackish water, the Sofala would plow her way
+    up-stream, as she had done once every month for these seven years or
+    more, long before he was aware of her existence, long before he had ever
+    thought of having anything to do with her and her invariable voyages.
+    The old ship ought to have known the road better than her men, who had
+    not been kept so long at it without a change; better than the faithful
+    Serang, whom he had brought over from his last ship to keep the
+    captain's watch; better than he himself, who had been her captain for
+    the last three years only. She could always be depended upon to make her
+    courses. Her compasses were never out. She was no trouble at all to
+    take about, as if her great age had given her knowledge, wisdom, and
+    steadiness. She made her landfalls to a degree of the bearing, and
+    almost to a minute of her allowed time. At any moment, as he sat on
+    the bridge without looking up, or lay sleepless in his bed, simply by
+    reckoning the days and the hours he could tell where he was--the precise
+    spot of the beat. He knew it well too, this monotonous huckster's
+    round, up and down the Straits; he knew its order and its sights and its
+    people. Malacca to begin with, in at daylight and out at dusk, to cross
+    over with a rigid phosphorescent wake this highway of the Far East.
+    Darkness and gleams on the water, clear stars on a black sky, perhaps
+    the lights of a home steamer keeping her unswerving course in the
+    middle, or maybe the elusive shadow of a native craft with her mat sails
+    flitting by silently--and the low land on the other side in sight
+    at daylight. At noon the three palms of the next place of call, up a
+    sluggish river. The only white man residing there was a retired young
+    sailor, with whom he had become friendly in the course of many voyages.
+    Sixty miles farther on there was another place of call, a deep bay with
+    only a couple of houses on the beach. And so on, in and out, picking
+    up coastwise cargo here and there, and finishing with a hundred miles'
+    steady steaming through the maze of an archipelago of small islands up
+    to a large native town at the end of the beat. There was a three days'
+    rest for the old ship before he started her again in inverse order,
+    seeing the same shores from another bearing, hearing the same voices
+    in the same places, back again to the Sofala's port of registry on
+    the great highway to the East, where he would take up a berth nearly
+    opposite the big stone pile of the harbor office till it was time to
+    start again on the old round of 1600 miles and thirty days. Not a very
+    enterprising life, this, for Captain Whalley, Henry Whalley, otherwise
+    Dare-devil Harry--Whalley of the Condor, a famous clipper in her day.
+    No. Not a very enterprising life for a man who had served famous firms,
+    who had sailed famous ships (more than one or two of them his own); who
+    had made famous passages, had been the pioneer of new routes and new
+    trades; who had steered across the unsurveyed tracts of the South Seas,
+    and had seen the sun rise on uncharted islands. Fifty years at sea, and
+    forty out in the East ("a pretty thorough apprenticeship," he used
+    to remark smilingly), had made him honorably known to a generation of
+    shipowners and merchants in all the ports from Bombay clear over to
+    where the East merges into the West upon the coast of the two Americas.
+    His fame remained writ, not very large but plain enough, on the
+    Admiralty charts. Was there not somewhere between Australia and China a
+    Whalley Island and a Condor Reef? On that dangerous coral formation the
+    celebrated clipper had hung stranded for three days, her captain and
+    crew throwing her cargo overboard with one hand and with the other, as
+    it were, keeping off her a flotilla of savage war-canoes. At that time
+    neither the island nor the reef had any official existence. Later the
+    officers of her Majesty's steam vessel Fusilier, dispatched to make a
+    survey of the route, recognized in the adoption of these two names the
+    enterprise of the man and the solidity of the ship. Besides, as anyone
+    who cares may see, the "General Directory," vol. ii. p. 410, begins the
+    description of the "Malotu or Whalley Passage" with the words: "This
+    advantageous route, first discovered in 1850 by Captain Whalley in the
+    ship Condor," &amp;c., and ends by recommending it warmly to sailing vessels
+    leaving the China ports for the south in the months from December to
+    April inclusive.</p>
+
+    <p>This was the clearest gain he had out of life. Nothing could rob him
+    of this kind of fame. The piercing of the Isthmus of Suez, like the
+    breaking of a dam, had let in upon the East a flood of new ships, new
+    men, new methods of trade. It had changed the face of the Eastern seas
+    and the very spirit of their life; so that his early experiences meant
+    nothing whatever to the new generation of seamen.</p>
+
+    <p>In those bygone days he had handled many thousands of pounds of his
+    employers' money and of his own; he had attended faithfully, as by law
+    a shipmaster is expected to do, to the conflicting interests of owners,
+    charterers, and underwriters. He had never lost a ship or consented to
+    a shady transaction; and he had lasted well, outlasting in the end the
+    conditions that had gone to the making of his name. He had buried his
+    wife (in the Gulf of Petchili), had married off his daughter to the man
+    of her unlucky choice, and had lost more than an ample competence in the
+    crash of the notorious Travancore and Deccan Banking Corporation, whose
+    downfall had shaken the East like an earthquake. And he was sixty-five
+    years old.</p>
+
+    <h3>Chapter II</h3>
+
+    <p>His age sat lightly enough on him; and of his ruin he was not ashamed.
+    He had not been alone to believe in the stability of the Banking
+    Corporation. Men whose judgment in matters of finance was as expert as
+    his seamanship had commended the prudence of his investments, and had
+    themselves lost much money in the great failure. The only difference
+    between him and them was that he had lost his all. And yet not his all.
+    There had remained to him from his lost fortune a very pretty little
+    bark, Fair Maid, which he had bought to occupy his leisure of a retired
+    sailor--"to play with," as he expressed it himself.</p>
+
+    <p>He had formally declared himself tired of the sea the year preceding his
+    daughter's marriage. But after the young couple had gone to settle in
+    Melbourne he found out that he could not make himself happy on shore. He
+    was too much of a merchant sea-captain for mere yachting to satisfy him.
+    He wanted the illusion of affairs; and his acquisition of the Fair
+    Maid preserved the continuity of his life. He introduced her to his
+    acquaintances in various ports as "my last command." When he grew too
+    old to be trusted with a ship, he would lay her up and go ashore to be
+    buried, leaving directions in his will to have the bark towed out and
+    scuttled decently in deep water on the day of the funeral. His daughter
+    would not grudge him the satisfaction of knowing that no stranger would
+    handle his last command after him. With the fortune he was able to leave
+    her, the value of a 500-ton bark was neither here nor there. All this
+    would be said with a jocular twinkle in his eye: the vigorous old man
+    had too much vitality for the sentimentalism of regret; and a little
+    wistfully withal, because he was at home in life, taking a genuine
+    pleasure in its feelings and its possessions; in the dignity of his
+    reputation and his wealth, in his love for his daughter, and in his
+    satisfaction with the ship--the plaything of his lonely leisure.</p>
+
+    <p>He had the cabin arranged in accordance with his simple ideal of comfort
+    at sea. A big bookcase (he was a great reader) occupied one side of his
+    stateroom; the portrait of his late wife, a flat bituminous oil-painting
+    representing the profile and one long black ringlet of a young woman,
+    faced his bed-place. Three chronometers ticked him to sleep and greeted
+    him on waking with the tiny competition of their beats. He rose at five
+    every day. The officer of the morning watch, drinking his early cup
+    of coffee aft by the wheel, would hear through the wide orifice of the
+    copper ventilators all the splashings, blowings, and splutterings of
+    his captain's toilet. These noises would be followed by a sustained
+    deep murmur of the Lord's Prayer recited in a loud earnest voice. Five
+    minutes afterwards the head and shoulders of Captain Whalley emerged
+    out of the companion-hatchway. Invariably he paused for a while on the
+    stairs, looking all round at the horizon; upwards at the trim of the
+    sails; inhaling deep draughts of the fresh air. Only then he would step
+    out on the poop, acknowledging the hand raised to the peak of the cap
+    with a majestic and benign "Good morning to you." He walked the deck
+    till eight scrupulously. Sometimes, not above twice a year, he had to
+    use a thick cudgel-like stick on account of a stiffness in the hip--a
+    slight touch of rheumatism, he supposed. Otherwise he knew nothing of
+    the ills of the flesh. At the ringing of the breakfast bell he went
+    below to feed his canaries, wind up the chronometers, and take the
+    head of the table. From there he had before his eyes the big carbon
+    photographs of his daughter, her husband, and two fat-legged babies
+    --his grandchildren--set in black frames into the maplewood bulkheads
+    of the cuddy. After breakfast he dusted the glass over these portraits
+    himself with a cloth, and brushed the oil painting of his wife with a
+    plumate kept suspended from a small brass hook by the side of the heavy
+    gold frame. Then with the door of his stateroom shut, he would sit down
+    on the couch under the portrait to read a chapter out of a thick pocket
+    Bible--her Bible. But on some days he only sat there for half an hour
+    with his finger between the leaves and the closed book resting on his
+    knees. Perhaps he had remembered suddenly how fond of boat-sailing she
+    used to be.</p>
+
+    <p>She had been a real shipmate and a true woman too. It was like an
+    article of faith with him that there never had been, and never could be,
+    a brighter, cheerier home anywhere afloat or ashore than his home under
+    the poop-deck of the Condor, with the big main cabin all white and gold,
+    garlanded as if for a perpetual festival with an unfading wreath. She
+    had decorated the center of every panel with a cluster of home flowers.
+    It took her a twelvemonth to go round the cuddy with this labor of love.
+    To him it had remained a marvel of painting, the highest achievement of
+    taste and skill; and as to old Swinburne, his mate, every time he
+    came down to his meals he stood transfixed with admiration before the
+    progress of the work. You could almost smell these roses, he declared,
+    sniffing the faint flavor of turpentine which at that time pervaded the
+    saloon, and (as he confessed afterwards) made him somewhat less hearty
+    than usual in tackling his food. But there was nothing of the sort to
+    interfere with his enjoyment of her singing. "Mrs. Whalley is a regular
+    out-and-out nightingale, sir," he would pronounce with a judicial air
+    after listening profoundly over the skylight to the very end of the
+    piece. In fine weather, in the second dog-watch, the two men could hear
+    her trills and roulades going on to the accompaniment of the piano in
+    the cabin. On the very day they got engaged he had written to London
+    for the instrument; but they had been married for over a year before it
+    reached them, coming out round the Cape. The big case made part of the
+    first direct general cargo landed in Hong-kong harbor--an event that to
+    the men who walked the busy quays of to-day seemed as hazily remote as
+    the dark ages of history. But Captain Whalley could in a half hour of
+    solitude live again all his life, with its romance, its idyl, and its
+    sorrow. He had to close her eyes himself. She went away from under the
+    ensign like a sailor's wife, a sailor herself at heart. He had read
+    the service over her, out of her own prayer-book, without a break in his
+    voice. When he raised his eyes he could see old Swinburne facing him
+    with his cap pressed to his breast, and his rugged, weather-beaten,
+    impassive face streaming with drops of water like a lump of chipped red
+    granite in a shower. It was all very well for that old sea-dog to cry.
+    He had to read on to the end; but after the splash he did not remember
+    much of what happened for the next few days. An elderly sailor of the
+    crew, deft at needlework, put together a mourning frock for the child
+    out of one of her black skirts.</p>
+
+    <p>He was not likely to forget; but you cannot dam up life like a sluggish
+    stream. It will break out and flow over a man's troubles, it will close
+    upon a sorrow like the sea upon a dead body, no matter how much love has
+    gone to the bottom. And the world is not bad. People had been very
+    kind to him; especially Mrs. Gardner, the wife of the senior partner
+    in Gardner, Patteson, &amp; Co., the owners of the Condor. It was she who
+    volunteered to look after the little one, and in due course took her to
+    England (something of a journey in those days, even by the overland
+    mail route) with her own girls to finish her education. It was ten years
+    before he saw her again.</p>
+
+    <p>As a little child she had never been frightened of bad weather; she
+    would beg to be taken up on deck in the bosom of his oilskin coat to
+    watch the big seas hurling themselves upon the Condor. The swirl and
+    crash of the waves seemed to fill her small soul with a breathless
+    delight. "A good boy spoiled," he used to say of her in joke. He had
+    named her Ivy because of the sound of the word, and obscurely fascinated
+    by a vague association of ideas. She had twined herself tightly round
+    his heart, and he intended her to cling close to her father as to a
+    tower of strength; forgetting, while she was little, that in the nature
+    of things she would probably elect to cling to someone else. But
+    he loved life well enough for even that event to give him a certain
+    satisfaction, apart from his more intimate feeling of loss.</p>
+
+    <p>After he had purchased the Fair Maid to occupy his loneliness, he
+    hastened to accept a rather unprofitable freight to Australia simply for
+    the opportunity of seeing his daughter in her own home. What made him
+    dissatisfied there was not to see that she clung now to somebody else,
+    but that the prop she had selected seemed on closer examination "a
+    rather poor stick"--even in the matter of health. He disliked his
+    son-in-law's studied civility perhaps more than his method of
+    handling the sum of money he had given Ivy at her marriage. But of his
+    apprehensions he said nothing. Only on the day of his departure, with
+    the hall-door open already, holding her hands and looking steadily into
+    her eyes, he had said, "You know, my dear, all I have is for you and the
+    chicks. Mind you write to me openly." She had answered him by an almost
+    imperceptible movement of her head. She resembled her mother in
+    the color of her eyes, and in character--and also in this, that she
+    understood him without many words.</p>
+
+    <p>Sure enough she had to write; and some of these letters made Captain
+    Whalley lift his white eye-brows. For the rest he considered he was
+    reaping the true reward of his life by being thus able to produce on
+    demand whatever was needed. He had not enjoyed himself so much in a
+    way since his wife had died. Characteristically enough his son-in-law's
+    punctuality in failure caused him at a distance to feel a sort of
+    kindness towards the man. The fellow was so perpetually being jammed on
+    a lee shore that to charge it all to his reckless navigation would be
+    manifestly unfair. No, no! He knew well what that meant. It was bad
+    luck. His own had been simply marvelous, but he had seen in his life too
+    many good men--seamen and others--go under with the sheer weight of bad
+    luck not to recognize the fatal signs. For all that, he was cogitating
+    on the best way of tying up very strictly every penny he had to leave,
+    when, with a preliminary rumble of rumors (whose first sound reached
+    him in Shanghai as it happened), the shock of the big failure came;
+    and, after passing through the phases of stupor, of incredulity, of
+    indignation, he had to accept the fact that he had nothing to speak of
+    to leave.</p>
+
+    <p>Upon that, as if he had only waited for this catastrophe, the unlucky
+    man, away there in Melbourne, gave up his unprofitable game, and sat
+    down--in an invalid's bath-chair at that too. "He will never walk
+    again," wrote the wife. For the first time in his life Captain Whalley
+    was a bit staggered.</p>
+
+    <p>The Fair Maid had to go to work in bitter earnest now. It was no longer
+    a matter of preserving alive the memory of Dare-devil Harry Whalley in
+    the Eastern Seas, or of keeping an old man in pocket-money and clothes,
+    with, perhaps, a bill for a few hundred first-class cigars thrown in at
+    the end of the year. He would have to buckle-to, and keep her going hard
+    on a scant allowance of gilt for the ginger-bread scrolls at her stem
+    and stern.</p>
+
+    <p>This necessity opened his eyes to the fundamental changes of the world.
+    Of his past only the familiar names remained, here and there, but
+    the things and the men, as he had known them, were gone. The name of
+    Gardner, Patteson, &amp; Co. was still displayed on the walls of warehouses
+    by the waterside, on the brass plates and window-panes in the business
+    quarters of more than one Eastern port, but there was no longer a
+    Gardner or a Patteson in the firm. There was no longer for Captain
+    Whalley an arm-chair and a welcome in the private office, with a bit of
+    business ready to be put in the way of an old friend, for the sake of
+    bygone services. The husbands of the Gardner girls sat behind the desks
+    in that room where, long after he had left the employ, he had kept his
+    right of entrance in the old man's time. Their ships now had yellow
+    funnels with black tops, and a time-table of appointed routes like a
+    confounded service of tramways. The winds of December and June were all
+    one to them; their captains (excellent young men he doubted not) were,
+    to be sure, familiar with Whalley Island, because of late years the
+    Government had established a white fixed light on the north end (with
+    a red danger sector over the Condor Reef), but most of them would have
+    been extremely surprised to hear that a flesh-and-blood Whalley still
+    existed--an old man going about the world trying to pick up a cargo here
+    and there for his little bark.</p>
+
+    <p>And everywhere it was the same. Departed the men who would have nodded
+    appreciatively at the mention of his name, and would have thought
+    themselves bound in honor to do something for Dare-devil Harry Whalley.
+    Departed the opportunities which he would have known how to seize; and
+    gone with them the white-winged flock of clippers that lived in the
+    boisterous uncertain life of the winds, skimming big fortunes out of
+    the foam of the sea. In a world that pared down the profits to an
+    irreducible minimum, in a world that was able to count its disengaged
+    tonnage twice over every day, and in which lean charters were snapped up
+    by cable three months in advance, there were no chances of fortune for
+    an individual wandering haphazard with a little bark--hardly indeed any
+    room to exist.</p>
+
+    <p>He found it more difficult from year to year. He suffered greatly from
+    the smallness of remittances he was able to send his daughter. Meantime
+    he had given up good cigars, and even in the matter of inferior cheroots
+    limited himself to six a day. He never told her of his difficulties, and
+    she never enlarged upon her struggle to live. Their confidence in each
+    other needed no explanations, and their perfect understanding endured
+    without protestations of gratitude or regret. He would have been shocked
+    if she had taken it into her head to thank him in so many words, but
+    he found it perfectly natural that she should tell him she needed two
+    hundred pounds.</p>
+
+    <p>He had come in with the Fair Maid in ballast to look for a freight in
+    the Sofala's port of registry, and her letter met him there. Its tenor
+    was that it was no use mincing matters. Her only resource was in opening
+    a boarding-house, for which the prospects, she judged, were good. Good
+    enough, at any rate, to make her tell him frankly that with two hundred
+    pounds she could make a start. He had torn the envelope open, hastily,
+    on deck, where it was handed to him by the ship-chandler's runner, who
+    had brought his mail at the moment of anchoring. For the second time
+    in his life he was appalled, and remained stock-still at the cabin door
+    with the paper trembling between his fingers. Open a boarding-house! Two
+    hundred pounds for a start! The only resource! And he did not know where
+    to lay his hands on two hundred pence.</p>
+
+    <p>All that night Captain Whalley walked the poop of his anchored ship, as
+    though he had been about to close with the land in thick weather, and
+    uncertain of his position after a run of many gray days without a sight
+    of sun, moon, or stars. The black night twinkled with the guiding lights
+    of seamen and the steady straight lines of lights on shore; and all
+    around the Fair Maid the riding lights of ships cast trembling trails
+    upon the water of the roadstead. Captain Whalley saw not a gleam
+    anywhere till the dawn broke and he found out that his clothing was
+    soaked through with the heavy dew.</p>
+
+    <p>His ship was awake. He stopped short, stroked his wet beard, and
+    descended the poop ladder backwards, with tired feet. At the sight
+    of him the chief officer, lounging about sleepily on the quarterdeck,
+    remained open-mouthed in the middle of a great early-morning yawn.</p>
+
+    <p>"Good morning to you," pronounced Captain Whalley solemnly, passing into
+    the cabin. But he checked himself in the doorway, and without looking
+    back, "By the bye," he said, "there should be an empty wooden case put
+    away in the lazarette. It has not been broken up--has it?"</p>
+
+    <p>The mate shut his mouth, and then asked as if dazed, "What empty case,
+    sir?"</p>
+
+    <p>"A big flat packing-case belonging to that painting in my room. Let it
+    be taken up on deck and tell the carpenter to look it over. I may want
+    to use it before long."</p>
+
+    <p>The chief officer did not stir a limb till he had heard the door of the
+    captain's state-room slam within the cuddy. Then he beckoned aft the
+    second mate with his forefinger to tell him that there was something "in
+    the wind."</p>
+
+    <p>When the bell rang Captain Whalley's authoritative voice boomed out
+    through a closed door, "Sit down and don't wait for me." And his
+    impressed officers took their places, exchanging looks and whispers
+    across the table. What! No breakfast? And after apparently knocking
+    about all night on deck, too! Clearly, there was something in the wind.
+    In the skylight above their heads, bowed earnestly over the plates,
+    three wire cages rocked and rattled to the restless jumping of the
+    hungry canaries; and they could detect the sounds of their "old
+    man's" deliberate movements within his state-room. Captain Whalley was
+    methodically winding up the chronometers, dusting the portrait of
+    his late wife, getting a clean white shirt out of the drawers, making
+    himself ready in his punctilious unhurried manner to go ashore. He could
+    not have swallowed a single mouthful of food that morning. He had made
+    up his mind to sell the Fair Maid.</p>
+
+    <h3>Chapter III</h3>
+
+    <p>Just at that time the Japanese were casting far and wide for ships
+    of European build, and he had no difficulty in finding a purchaser, a
+    speculator who drove a hard bargain, but paid cash down for the Fair
+    Maid, with a view to a profitable resale. Thus it came about that
+    Captain Whalley found himself on a certain afternoon descending the
+    steps of one of the most important post-offices of the East with a slip
+    of bluish paper in his hand. This was the receipt of a registered letter
+    enclosing a draft for two hundred pounds, and addressed to Melbourne.
+    Captain Whalley pushed the paper into his waistcoat-pocket, took his
+    stick from under his arm, and walked down the street.</p>
+
+    <p>It was a recently opened and untidy thoroughfare with rudimentary
+    side-walks and a soft layer of dust cushioning the whole width of
+    the road. One end touched the slummy street of Chinese shops near the
+    harbor, the other drove straight on, without houses, for a couple of
+    miles, through patches of jungle-like vegetation, to the yard gates
+    of the new Consolidated Docks Company. The crude frontages of the new
+    Government buildings alternated with the blank fencing of vacant plots,
+    and the view of the sky seemed to give an added spaciousness to the
+    broad vista. It was empty and shunned by natives after business
+    hours, as though they had expected to see one of the tigers from the
+    neighborhood of the New Waterworks on the hill coming at a loping canter
+    down the middle to get a Chinese shopkeeper for supper. Captain Whalley
+    was not dwarfed by the solitude of the grandly planned street. He
+    had too fine a presence for that. He was only a lonely figure walking
+    purposefully, with a great white beard like a pilgrim, and with a thick
+    stick that resembled a weapon. On one side the new Courts of Justice had
+    a low and unadorned portico of squat columns half concealed by a few old
+    trees left in the approach. On the other the pavilion wings of the
+    new Colonial Treasury came out to the line of the street. But Captain
+    Whalley, who had now no ship and no home, remembered in passing that
+    on that very site when he first came out from England there had stood a
+    fishing village, a few mat huts erected on piles between a muddy tidal
+    creek and a miry pathway that went writhing into a tangled wilderness
+    without any docks or waterworks.</p>
+
+    <p>No ship--no home. And his poor Ivy away there had no home either. A
+    boarding-house is no sort of home though it may get you a living. His
+    feelings were horribly rasped by the idea of the boarding-house. In his
+    rank of life he had that truly aristocratic temperament characterized by
+    a scorn of vulgar gentility and by prejudiced views as to the derogatory
+    nature of certain occupations. For his own part he had always preferred
+    sailing merchant ships (which is a straightforward occupation) to buying
+    and selling merchandise, of which the essence is to get the better of
+    somebody in a bargain--an undignified trial of wits at best. His father
+    had been Colonel Whalley (retired) of the H. E. I. Company's service,
+    with very slender means besides his pension, but with distinguished
+    connections. He could remember as a boy how frequently waiters at the
+    inns, country tradesmen and small people of that sort, used to "My lord"
+    the old warrior on the strength of his appearance.</p>
+
+    <p>Captain Whalley himself (he would have entered the Navy if his father
+    had not died before he was fourteen) had something of a grand air which
+    would have suited an old and glorious admiral; but he became lost like
+    a straw in the eddy of a brook amongst the swarm of brown and yellow
+    humanity filling a thoroughfare, that by contrast with the vast and
+    empty avenue he had left seemed as narrow as a lane and absolutely
+    riotous with life. The walls of the houses were blue; the shops of the
+    Chinamen yawned like cavernous lairs; heaps of nondescript merchandise
+    overflowed the gloom of the long range of arcades, and the fiery
+    serenity of sunset took the middle of the street from end to end with a
+    glow like the reflection of a fire. It fell on the bright colors and the
+    dark faces of the bare-footed crowd, on the pallid yellow backs of the
+    half-naked jostling coolies, on the accouterments of a tall Sikh trooper
+    with a parted beard and fierce mustaches on sentry before the gate of
+    the police compound. Looming very big above the heads in a red haze of
+    dust, the tightly packed car of the cable tramway navigated cautiously
+    up the human stream, with the incessant blare of its horn, in the manner
+    of a steamer groping in a fog.</p>
+
+    <p>Captain Whalley emerged like a diver on the other side, and in the
+    desert shade between the walls of closed warehouses removed his hat to
+    cool his brow. A certain disrepute attached to the calling of a
+    landlady of a boarding-house. These women were said to be rapacious,
+    unscrupulous, untruthful; and though he contemned no class of his
+    fellow-creatures--God forbid!--these were suspicions to which it was
+    unseemly that a Whalley should lay herself open. He had not expostulated
+    with her, however. He was confident she shared his feelings; he was
+    sorry for her; he trusted her judgment; he considered it a merciful
+    dispensation that he could help her once more,--but in his aristocratic
+    heart of hearts he would have found it more easy to reconcile himself to
+    the idea of her turning seamstress. Vaguely he remembered reading years
+    ago a touching piece called the "Song of the Shirt." It was all very
+    well making songs about poor women. The granddaughter of Colonel
+    Whalley, the landlady of a boarding-house! Pooh! He replaced his hat,
+    dived into two pockets, and stopping a moment to apply a flaring match
+    to the end of a cheap cheroot, blew an embittered cloud of smoke at a
+    world that could hold such surprises.</p>
+
+    <p>Of one thing he was certain--that she was the own child of a clever
+    mother. Now he had got over the wrench of parting with his ship, he
+    perceived clearly that such a step had been unavoidable. Perhaps he had
+    been growing aware of it all along with an unconfessed knowledge. But
+    she, far away there, must have had an intuitive perception of it, with
+    the pluck to face that truth and the courage to speak out--all the
+    qualities which had made her mother a woman of such excellent counsel.</p>
+
+    <p>It would have had to come to that in the end! It was fortunate she had
+    forced his hand. In another year or two it would have been an utterly
+    barren sale. To keep the ship going he had been involving himself deeper
+    every year. He was defenseless before the insidious work of adversity,
+    to whose more open assaults he could present a firm front; like a
+    cliff that stands unmoved the open battering of the sea, with a lofty
+    ignorance of the treacherous backwash undermining its base. As it was,
+    every liability satisfied, her request answered, and owing no man a
+    penny, there remained to him from the proceeds a sum of five hundred
+    pounds put away safely. In addition he had upon his person some forty
+    odd dollars--enough to pay his hotel bill, providing he did not linger
+    too long in the modest bedroom where he had taken refuge.</p>
+
+    <p>Scantily furnished, and with a waxed floor, it opened into one of
+    the side-verandas. The straggling building of bricks, as airy as a
+    bird-cage, resounded with the incessant flapping of rattan screens
+    worried by the wind between the white-washed square pillars of the
+    sea-front. The rooms were lofty, a ripple of sunshine flowed over the
+    ceilings; and the periodical invasions of tourists from some passenger
+    steamer in the harbor flitted through the wind-swept dusk of the
+    apartments with the tumult of their unfamiliar voices and impermanent
+    presences, like relays of migratory shades condemned to speed headlong
+    round the earth without leaving a trace. The babble of their irruptions
+    ebbed out as suddenly as it had arisen; the draughty corridors and
+    the long chairs of the verandas knew their sight-seeing hurry or
+    their prostrate repose no more; and Captain Whalley, substantial and
+    dignified, left well-nigh alone in the vast hotel by each light-hearted
+    skurry, felt more and more like a stranded tourist with no aim in view,
+    like a forlorn traveler without a home. In the solitude of his room he
+    smoked thoughtfully, gazing at the two sea-chests which held all that he
+    could call his own in this world. A thick roll of charts in a sheath
+    of sailcloth leaned in a corner; the flat packing-case containing the
+    portrait in oils and the three carbon photographs had been pushed under
+    the bed. He was tired of discussing terms, of assisting at surveys, of
+    all the routine of the business. What to the other parties was merely
+    the sale of a ship was to him a momentous event involving a radically
+    new view of existence. He knew that after this ship there would be no
+    other; and the hopes of his youth, the exercise of his abilities, every
+    feeling and achievement of his manhood, had been indissolubly connected
+    with ships. He had served ships; he had owned ships; and even the years
+    of his actual retirement from the sea had been made bearable by the idea
+    that he had only to stretch out his hand full of money to get a ship. He
+    had been at liberty to feel as though he were the owner of all the
+    ships in the world. The selling of this one was weary work; but when
+    she passed from him at last, when he signed the last receipt, it was as
+    though all the ships had gone out of the world together, leaving him on
+    the shore of inaccessible oceans with seven hundred pounds in his hands.</p>
+
+    <p>Striding firmly, without haste, along the quay, Captain Whalley averted
+    his glances from the familiar roadstead. Two generations of seamen born
+    since his first day at sea stood between him and all these ships at the
+    anchorage. His own was sold, and he had been asking himself, What next?</p>
+
+    <p>From the feeling of loneliness, of inward emptiness,--and of loss
+    too, as if his very soul had been taken out of him forcibly,--there had
+    sprung at first a desire to start right off and join his daughter.
+    "Here are the last pence," he would say to her; "take them, my dear. And
+    here's your old father: you must take him too."</p>
+
+    <p>His soul recoiled, as if afraid of what lay hidden at the bottom of
+    this impulse. Give up! Never! When one is thoroughly weary all sorts of
+    nonsense come into one's head. A pretty gift it would have been for a
+    poor woman--this seven hundred pounds with the incumbrance of a hale old
+    fellow more than likely to last for years and years to come. Was he not
+    as fit to die in harness as any of the youngsters in charge of these
+    anchored ships out yonder? He was as solid now as ever he had been. But
+    as to who would give him work to do, that was another matter. Were he,
+    with his appearance and antecedents, to go about looking for a junior's
+    berth, people, he was afraid, would not take him seriously; or else if
+    he succeeded in impressing them, he would maybe obtain their pity, which
+    would be like stripping yourself naked to be kicked. He was not anxious
+    to give himself away for less than nothing. He had no use for anybody's
+    pity. On the other hand, a command--the only thing he could try for with
+    due regard for common decency--was not likely to be lying in wait
+    for him at the corner of the next street. Commands don't go a-begging
+    nowadays. Ever since he had come ashore to carry out the business of
+    the sale he had kept his ears open, but had heard no hint of one being
+    vacant in the port. And even if there had been one, his successful past
+    itself stood in his way. He had been his own employer too long. The only
+    credential he could produce was the testimony of his whole life. What
+    better recommendation could anyone require? But vaguely he felt that
+    the unique document would be looked upon as an archaic curiosity of the
+    Eastern waters, a screed traced in obsolete words--in a half-forgotten
+    language.</p>
+
+    <h3>Chapter IV</h3>
+
+    <p>Revolving these thoughts, he strolled on near the railings of the quay,
+    broad-chested, without a stoop, as though his big shoulders had never
+    felt the burden of the loads that must be carried between the cradle
+    and the grave. No single betraying fold or line of care disfigured the
+    reposeful modeling of his face. It was full and untanned; and the upper
+    part emerged, massively quiet, out of the downward flow of silvery hair,
+    with the striking delicacy of its clear complexion and the powerful
+    width of the forehead. The first cast of his glance fell on you candid
+    and swift, like a boy's; but because of the ragged snowy thatch of the
+    eyebrows the affability of his attention acquired the character of a
+    dark and searching scrutiny. With age he had put on flesh a little, had
+    increased his girth like an old tree presenting no symptoms of decay;
+    and even the opulent, lustrous ripple of white hairs upon his chest
+    seemed an attribute of unquenchable vitality and vigor.</p>
+
+    <p>Once rather proud of his great bodily strength, and even of his personal
+    appearance, conscious of his worth, and firm in his rectitude, there had
+    remained to him, like the heritage of departed prosperity, the tranquil
+    bearing of a man who had proved himself fit in every sort of way for the
+    life of his choice. He strode on squarely under the projecting brim of
+    an ancient Panama hat. It had a low crown, a crease through its whole
+    diameter, a narrow black ribbon. Imperishable and a little discolored,
+    this headgear made it easy to pick him out from afar on thronged wharves
+    and in the busy streets. He had never adopted the comparatively modern
+    fashion of pipeclayed cork helmets. He disliked the form; and he hoped
+    he could manage to keep a cool head to the end of his life without all
+    these contrivances for hygienic ventilation. His hair was cropped close,
+    his linen always of immaculate whiteness; a suit of thin gray flannel,
+    worn threadbare but scrupulously brushed, floated about his burly limbs,
+    adding to his bulk by the looseness of its cut. The years had mellowed
+    the good-humored, imperturbable audacity of his prime into a temper
+    carelessly serene; and the leisurely tapping of his iron-shod stick
+    accompanied his footfalls with a self-confident sound on the flagstones.
+    It was impossible to connect such a fine presence and this unruffled
+    aspect with the belittling troubles of poverty; the man's whole
+    existence appeared to pass before you, facile and large, in the freedom
+    of means as ample as the clothing of his body.</p>
+
+    <p>The irrational dread of having to break into his five hundred pounds for
+    personal expenses in the hotel disturbed the steady poise of his mind.
+    There was no time to lose. The bill was running up. He nourished the
+    hope that this five hundred would perhaps be the means, if everything
+    else failed, of obtaining some work which, keeping his body and soul
+    together (not a matter of great outlay), would enable him to be of use
+    to his daughter. To his mind it was her own money which he employed, as
+    it were, in backing her father and solely for her benefit. Once at work,
+    he would help her with the greater part of his earnings; he was good for
+    many years yet, and this boarding-house business, he argued to himself,
+    whatever the prospects, could not be much of a gold-mine from the first
+    start. But what work? He was ready to lay hold of anything in an honest
+    way so that it came quickly to his hand; because the five hundred pounds
+    must be preserved intact for eventual use. That was the great point.
+    With the entire five hundred one felt a substance at one's back; but
+    it seemed to him that should he let it dwindle to four-fifty or even
+    four-eighty, all the efficiency would be gone out of the money, as though
+    there were some magic power in the round figure. But what sort of work?</p>
+
+    <p>Confronted by that haunting question as by an uneasy ghost, for whom he
+    had no exorcising formula, Captain Whalley stopped short on the apex
+    of a small bridge spanning steeply the bed of a canalized creek with
+    granite shores. Moored between the square blocks a seagoing Malay prau
+    floated half hidden under the arch of masonry, with her spars lowered
+    down, without a sound of life on board, and covered from stem to stern
+    with a ridge of palm-leaf mats. He had left behind him the overheated
+    pavements bordered by the stone frontages that, like the sheer face of
+    cliffs, followed the sweep of the quays; and an unconfined spaciousness
+    of orderly and sylvan aspect opened before him its wide plots of rolled
+    grass, like pieces of green carpet smoothly pegged out, its long ranges
+    of trees lined up in colossal porticos of dark shafts roofed with a
+    vault of branches.</p>
+
+    <p>Some of these avenues ended at the sea. It was a terraced shore; and
+    beyond, upon the level expanse, profound and glistening like the gaze
+    of a dark-blue eye, an oblique band of stippled purple lengthened itself
+    indefinitely through the gap between a couple of verdant twin islets.
+    The masts and spars of a few ships far away, hull down in the outer
+    roads, sprang straight from the water in a fine maze of rosy lines
+    penciled on the clear shadow of the eastern board. Captain Whalley gave
+    them a long glance. The ship, once his own, was anchored out there. It
+    was staggering to think that it was open to him no longer to take a boat
+    at the jetty and get himself pulled off to her when the evening came. To
+    no ship. Perhaps never more. Before the sale was concluded, and till the
+    purchase-money had been paid, he had spent daily some time on board the
+    Fair Maid. The money had been paid this very morning, and now, all at
+    once, there was positively no ship that he could go on board of when he
+    liked; no ship that would need his presence in order to do her work--to
+    live. It seemed an incredible state of affairs, something too bizarre
+    to last. And the sea was full of craft of all sorts. There was that prau
+    lying so still swathed in her shroud of sewn palm-leaves--she too had
+    her indispensable man. They lived through each other, this Malay he had
+    never seen, and this high-sterned thing of no size that seemed to be
+    resting after a long journey. And of all the ships in sight, near and
+    far, each was provided with a man, the man without whom the finest ship
+    is a dead thing, a floating and purposeless log.</p>
+
+    <p>After his one glance at the roadstead he went on, since there was
+    nothing to turn back for, and the time must be got through somehow. The
+    avenues of big trees ran straight over the Esplanade, cutting each other
+    at diverse angles, columnar below and luxuriant above. The interlaced
+    boughs high up there seemed to slumber; not a leaf stirred overhead:
+    and the reedy cast-iron lampposts in the middle of the road, gilt like
+    scepters, diminished in a long perspective, with their globes of white
+    porcelain atop, resembling a barbarous decoration of ostriches' eggs
+    displayed in a row. The flaming sky kindled a tiny crimson spark upon
+    the glistening surface of each glassy shell.</p>
+
+    <p>With his chin sunk a little, his hands behind his back, and the end of
+    his stick marking the gravel with a faint wavering line at his heels,
+    Captain Whalley reflected that if a ship without a man was like a body
+    without a soul, a sailor without a ship was of not much more account
+    in this world than an aimless log adrift upon the sea. The log might be
+    sound enough by itself, tough of fiber, and hard to destroy--but what of
+    that! And a sudden sense of irremediable idleness weighted his feet like
+    a great fatigue.</p>
+
+    <p>A succession of open carriages came bowling along the newly opened
+    sea-road. You could see across the wide grass-plots the discs of
+    vibration made by the spokes. The bright domes of the parasols swayed
+    lightly outwards like full-blown blossoms on the rim of a vase; and
+    the quiet sheet of dark-blue water, crossed by a bar of purple, made a
+    background for the spinning wheels and the high action of the horses,
+    whilst the turbaned heads of the Indian servants elevated above the line
+    of the sea horizon glided rapidly on the paler blue of the sky. In an
+    open space near the little bridge each turn-out trotted smartly in a
+    wide curve away from the sunset; then pulling up sharp, entered the main
+    alley in a long slow-moving file with the great red stillness of the sky
+    at the back. The trunks of mighty trees stood all touched with red on
+    the same side, the air seemed aflame under the high foliage, the
+    very ground under the hoofs of the horses was red. The wheels turned
+    solemnly; one after another the sunshades drooped, folding their colors
+    like gorgeous flowers shutting their petals at the end of the day. In
+    the whole half-mile of human beings no voice uttered a distinct word,
+    only a faint thudding noise went on mingled with slight jingling sounds,
+    and the motionless heads and shoulders of men and women sitting in
+    couples emerged stolidly above the lowered hoods--as if wooden. But one
+    carriage and pair coming late did not join the line.</p>
+
+    <p>It fled along in a noiseless roll; but on entering the avenue one of the
+    dark bays snorted, arching his neck and shying against the steel-tipped
+    pole; a flake of foam fell from the bit upon the point of a satiny
+    shoulder, and the dusky face of the coachman leaned forward at once over
+    the hands taking a fresh grip of the reins. It was a long dark-green
+    landau, having a dignified and buoyant motion between the sharply
+    curved C-springs, and a sort of strictly official majesty in its supreme
+    elegance. It seemed more roomy than is usual, its horses seemed slightly
+    bigger, the appointments a shade more perfect, the servants perched
+    somewhat higher on the box. The dresses of three women--two young
+    and pretty, and one, handsome, large, of mature age--seemed to fill
+    completely the shallow body of the carriage. The fourth face was that
+    of a man, heavy lidded, distinguished and sallow, with a somber, thick,
+    iron-gray imperial and mustaches, which somehow had the air of solid
+    appendages. His Excellency--</p>
+
+    <p>The rapid motion of that one equipage made all the others appear utterly
+    inferior, blighted, and reduced to crawl painfully at a snail's pace.
+    The landau distanced the whole file in a sort of sustained rush; the
+    features of the occupant whirling out of sight left behind an impression
+    of fixed stares and impassive vacancy; and after it had vanished in full
+    flight as it were, notwithstanding the long line of vehicles hugging the
+    curb at a walk, the whole lofty vista of the avenue seemed to lie open
+    and emptied of life in the enlarged impression of an august solitude.</p>
+
+    <p>Captain Whalley had lifted his head to look, and his mind, disturbed in
+    its meditation, turned with wonder (as men's minds will do) to matters
+    of no importance. It struck him that it was to this port, where he had
+    just sold his last ship, that he had come with the very first he had
+    ever owned, and with his head full of a plan for opening a new trade
+    with a distant part of the Archipelago. The then governor had given
+    him no end of encouragement. No Excellency he--this Mr. Denham--this
+    governor with his jacket off; a man who tended night and day, so to
+    speak, the growing prosperity of the settlement with the self-forgetful
+    devotion of a nurse for a child she loves; a lone bachelor who lived as
+    in a camp with the few servants and his three dogs in what was called
+    then the Government Bungalow: a low-roofed structure on the half-cleared
+    slope of a hill, with a new flagstaff in front and a police orderly on
+    the veranda. He remembered toiling up that hill under a heavy sun for
+    his audience; the unfurnished aspect of the cool shaded room; the long
+    table covered at one end with piles of papers, and with two guns, a
+    brass telescope, a small bottle of oil with a feather stuck in the neck
+    at the other--and the flattering attention given to him by the man in
+    power. It was an undertaking full of risk he had come to expound, but a
+    twenty minutes' talk in the Government Bungalow on the hill had made it
+    go smoothly from the start. And as he was retiring Mr. Denham, already
+    seated before the papers, called out after him, "Next month the Dido
+    starts for a cruise that way, and I shall request her captain officially
+    to give you a look in and see how you get on." The Dido was one of the
+    smart frigates on the China station--and five-and-thirty years make a
+    big slice of time. Five-and-thirty years ago an enterprise like his had
+    for the colony enough importance to be looked after by a Queen's ship.
+    A big slice of time. Individuals were of some account then. Men like
+    himself; men, too, like poor Evans, for instance, with his red face,
+    his coal-black whiskers, and his restless eyes, who had set up the first
+    patent slip for repairing small ships, on the edge of the forest, in
+    a lonely bay three miles up the coast. Mr. Denham had encouraged that
+    enterprise too, and yet somehow poor Evans had ended by dying at
+    home deucedly hard up. His son, they said, was squeezing oil out of
+    cocoa-nuts for a living on some God-forsaken islet of the Indian Ocean;
+    but it was from that patent slip in a lonely wooded bay that had sprung
+    the workshops of the Consolidated Docks Company, with its three
+    graving basins carved out of solid rock, its wharves, its jetties,
+    its electric-light plant, its steam-power houses--with its gigantic
+    sheer-legs, fit to lift the heaviest weight ever carried afloat, and
+    whose head could be seen like the top of a queer white monument peeping
+    over bushy points of land and sandy promontories, as you approached the
+    New Harbor from the west.</p>
+
+    <p>There had been a time when men counted: there were not so many carriages
+    in the colony then, though Mr. Denham, he fancied, had a buggy. And
+    Captain Whalley seemed to be swept out of the great avenue by the swirl
+    of a mental backwash. He remembered muddy shores, a harbor without
+    quays, the one solitary wooden pier (but that was a public work) jutting
+    out crookedly, the first coal-sheds erected on Monkey Point, that caught
+    fire mysteriously and smoldered for days, so that amazed ships came
+    into a roadstead full of sulphurous smoke, and the sun hung blood-red
+    at midday. He remembered the things, the faces, and something more
+    besides--like the faint flavor of a cup quaffed to the bottom, like a
+    subtle sparkle of the air that was not to be found in the atmosphere of
+    to-day.</p>
+
+    <p>In this evocation, swift and full of detail like a flash of magnesium
+    light into the niches of a dark memorial hall, Captain Whalley
+    contemplated things once important, the efforts of small men, the growth
+    of a great place, but now robbed of all consequence by the greatness
+    of accomplished facts, by hopes greater still; and they gave him for a
+    moment such an almost physical grip upon time, such a comprehension of
+    our unchangeable feelings, that he stopped short, struck the ground with
+    his stick, and ejaculated mentally, "What the devil am I doing here!" He
+    seemed lost in a sort of surprise; but he heard his name called out in
+    wheezy tones once, twice--and turned on his heels slowly.</p>
+
+    <p>He beheld then, waddling towards him autocratically, a man of an
+    old-fashioned and gouty aspect, with hair as white as his own, but with
+    shaved, florid cheeks, wearing a necktie--almost a neckcloth--whose
+    stiff ends projected far beyond his chin; with round legs, round arms,
+    a round body, a round face--generally producing the effect of his short
+    figure having been distended by means of an air-pump as much as the
+    seams of his clothing would stand. This was the Master-Attendant of the
+    port. A master-attendant is a superior sort of harbor-master; a person,
+    out in the East, of some consequence in his sphere; a Government
+    official, a magistrate for the waters of the port, and possessed of vast
+    but ill-defined disciplinary authority over seamen of all classes.
+    This particular Master-Attendant was reported to consider it miserably
+    inadequate, on the ground that it did not include the power of life
+    and death. This was a jocular exaggeration. Captain Eliott was fairly
+    satisfied with his position, and nursed no inconsiderable sense of such
+    power as he had. His conceited and tyrannical disposition did not allow
+    him to let it dwindle in his hands for want of use. The uproarious,
+    choleric frankness of his comments on people's character and conduct
+    caused him to be feared at bottom; though in conversation many pretended
+    not to mind him in the least, others would only smile sourly at the
+    mention of his name, and there were even some who dared to pronounce him
+    "a meddlesome old ruffian." But for almost all of them one of Captain
+    Eliott's outbreaks was nearly as distasteful to face as a chance of
+    annihilation.</p>
+
+      <style>
+        body {
+          padding: 15px;
+        }
+
+        .pointer {
+          padding: 15px;
+          background-color: rgba(0, 0, 0, 0.4);
+          color: white;
+          border-radius: 10px;
+          pointer-events: none;
+          opacity: 0;
+
+          transition: opacity 300ms;
+          -webkit-transition: opacity 300ms;
+        }
+
+        .pointer.show {
+          opacity: 1;
+        }
+      </style>
+
+
+      <div class="pointer"></div>
+
+      <script src="../../tether.js"></script>
+      <script>
+        new Tether({
+          element: '.pointer',
+          attachment: 'middle right',
+          targetAttachment: 'middle left',
+          targetModifier: 'scroll-handle',
+          target: document.body
+        });
+
+        var headers = document.querySelectorAll('h1,h2,h3,h4,h5,h6');
+        var hideTimeout = null;
+        var pointer = document.querySelector('.pointer')
+
+        var getSection = function(){
+          var closest, closestTop;
+          for (var i=0; i < headers.length; i++){
+            var rect = headers[i].getBoundingClientRect();
+
+            if (closestTop === undefined || (rect.top < 0 && rect.top > closestTop)){
+              closestTop = rect.top;
+              closest = headers[i];
+            }
+          }
+          return closest.innerHTML;
+        }
+
+        document.addEventListener('scroll', function(){
+          var percentage = Math.floor((100 * Math.max(0, pageYOffset)) / (document.body.scrollHeight - innerHeight)) + '%'
+          pointer.innerHTML = getSection() + ' - ' + percentage
+
+          pointer.classList.add('show');
+
+          if (hideTimeout)
+            clearTimeout(hideTimeout);
+  
+          hideTimeout = setTimeout(function(){
+            pointer.classList.remove('show');
+          }, 1000);
+        });
+    </script>
+  </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/simple/index.html b/afb-client/bower_components/tether/examples/simple/index.html
new file mode 100644
index 0000000..de3ac1e
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/simple/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+    </head>
+    <body>
+        <div class="instructions">Resize the page to see the Tether flip.</div>
+
+        <div class="element"></div>
+        <div class="target"></div>
+
+        <script src="../../tether.js"></script>
+        <script>
+            new Tether({
+                element: '.element',
+                target: '.target',
+                attachment: 'top left',
+                targetAttachment: 'top right',
+                constraints: [{
+                    to: 'window',
+                    attachment: 'together'
+                }]
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/testbed/index.html b/afb-client/bower_components/tether/examples/testbed/index.html
new file mode 100644
index 0000000..720ce73
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/testbed/index.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <link rel="stylesheet" href="../resources/css/base.css" />
+        <link rel="stylesheet" href="../common/css/style.css" />
+    </head>
+    <body>
+
+        <div class="element">
+        </div>
+
+        <div class="container">
+            <div class="pad"></div>
+            <div class="target"></div>
+            <div class="pad"></div>
+            <div class="pad"></div>
+        </div>
+
+        <script src="../../tether.js"></script>
+        <script>
+            new Tether({
+                element: '.element',
+                target: '.target',
+                attachment: 'top center',
+                targetAttachment: 'bottom center',
+                constraints: [{
+                  to: 'scrollParent',
+                  attachment: 'together'
+                }]
+            });
+        </script>
+    </body>
+  </html>
diff --git a/afb-client/bower_components/tether/examples/tooltip/index.html b/afb-client/bower_components/tether/examples/tooltip/index.html
new file mode 100644
index 0000000..fbf247f
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/tooltip/index.html
@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="chrome=1">
+        <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
+        <script type="text/javascript" src="//use.typekit.net/jbn8qxr.js"></script>
+        <script type="text/javascript">try{Typekit.load();}catch(e){}</script>
+        <link rel="stylesheet" href="../../css/drop.css" />
+        <link rel="stylesheet" href="../../css/drop-tooltip-theme-arrows.css" />
+        <style>
+            body {
+                font-family: "proxima-nova", "Helvetica Neue", sans-serif;
+                color: #444;
+            }
+
+            .scroll-parent {
+                margin: 200px;
+                height: 300px;
+                width: 300px;
+                display: inline-block;
+                overflow: auto;
+                border: 2px solid #eee;
+                padding: 40px;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="scroll-parent">
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="top center">Tooltip on Top</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="bottom center">Tooltip on Bottom</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="left middle">Tooltip on Left</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="right middle">Tooltip on Right</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="bottom left">Tooltip on Bottom Left</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="bottom right">Tooltip on Bottom Right</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="top left">Tooltip on Top Left</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="top right">Tooltip on Top Right</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="left bottom">Tooltip on Left Bottom</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="left top">Tooltip on Left Top</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="right bottom">Tooltip on Right Bottom</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+            <p><a href="javascript:;" class="drop-tooltip" data-tooltip-content="Whoa, I'm a tooltip" data-attach="right top">Tooltip on Right Top</a></p>
+            <p>This is a paragraph of text</p>
+            <p>This is a paragraph of text</p>
+        </div>
+
+        <script src="../resources/js/log.js"></script>
+        <script src="../resources/js/jquery.js"></script>
+        <script src="../../utils.js"></script>
+        <script src="../../tether.js"></script>
+        <script src="/drop/drop.min.js"></script>
+        <script src="../../tooltip.js"></script>
+        <script src="../../constraint.js"></script>
+        <script>
+            $('.drop-tooltip').each(function(){
+                new Tooltip({
+                    el: this,
+                    attach: $(this).data('attach')
+                });
+            });
+        </script>
+    </body>
+</html>
diff --git a/afb-client/bower_components/tether/examples/viewport/colors.css b/afb-client/bower_components/tether/examples/viewport/colors.css
new file mode 100644
index 0000000..64f8c1c
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/viewport/colors.css
@@ -0,0 +1,145 @@
+@charset "UTF-8";
+/****
+
+   colors.css v1.0 For a friendlier looking web
+   MIT License • http://clrs.cc • http://github.com/mrmrs/colors
+
+   Author: mrmrs
+           http://mrmrs.cc
+           @mrmrs_
+
+****/
+/*
+
+   SKINS
+   • Backgrounds
+   • Colors
+
+*/
+/* Backgrounds */
+.bg-navy {
+  background-color: #001f3f; }
+
+.bg-blue {
+  background-color: #0074d9; }
+
+.bg-aqua {
+  background-color: #7fdbff; }
+
+.bg-teal {
+  background-color: #39cccc; }
+
+.bg-olive {
+  background-color: #3d9970; }
+
+.bg-green {
+  background-color: #2ecc40; }
+
+.bg-lime {
+  background-color: #01ff70; }
+
+.bg-yellow {
+  background-color: #ffdc00; }
+
+.bg-orange {
+  background-color: #ff851b; }
+
+.bg-red {
+  background-color: #ff4136; }
+
+.bg-fuchsia {
+  background-color: #f012be; }
+
+.bg-purple {
+  background-color: #b10dc9; }
+
+.bg-maroon {
+  background-color: #85144b; }
+
+.bg-white {
+  background-color: white; }
+
+.bg-gray {
+  background-color: #aaaaaa; }
+
+.bg-silver {
+  background-color: #dddddd; }
+
+.bg-black {
+  background-color: #111111; }
+
+/* Colors */
+.navy {
+  color: #001f3f; }
+
+.blue {
+  color: #0074d9; }
+
+.aqua {
+  color: #7fdbff; }
+
+.teal {
+  color: #39cccc; }
+
+.olive {
+  color: #3d9970; }
+
+.green {
+  color: #2ecc40; }
+
+.lime {
+  color: #01ff70; }
+
+.yellow {
+  color: #ffdc00; }
+
+.orange {
+  color: #ff851b; }
+
+.red {
+  color: #ff4136; }
+
+.fuchsia {
+  color: #f012be; }
+
+.purple {
+  color: #b10dc9; }
+
+.maroon {
+  color: #85144b; }
+
+.white {
+  color: white; }
+
+.silver {
+  color: #dddddd; }
+
+.gray {
+  color: #aaaaaa; }
+
+.black {
+  color: #111111; }
+
+/* PRETTIER LINKS */
+a {
+  text-decoration: none;
+  -webkit-transition: color .3s ease-in-out;
+  transition: color .3s ease-in-out; }
+
+a:link {
+  color: #0074d9;
+  -webkit-transition: color .3s ease-in-out;
+  transition: color .3s ease-in-out; }
+
+a:visited {
+  color: #b10dc9; }
+
+a:hover {
+  color: #7fdbff;
+  -webkit-transition: color .3s ease-in-out;
+  transition: color .3s ease-in-out; }
+
+a:active {
+  color: #ff851b;
+  -webkit-transition: color .3s ease-in-out;
+  transition: color .3s ease-in-out; }
diff --git a/afb-client/bower_components/tether/examples/viewport/index.html b/afb-client/bower_components/tether/examples/viewport/index.html
new file mode 100644
index 0000000..ac0711b
--- /dev/null
+++ b/afb-client/bower_components/tether/examples/viewport/index.html
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="../resources/css/base.css" />
+    <link rel="stylesheet" href="./colors.css" />
+    <style>
+      * {
+        box-sizing: border-box;
+      }
+
+      .element {
+        background-color: #FFDC00;
+        width: 80%;
+        max-width: 300px;
+        padding: 0 15px;
+        font-size: 20px;
+        box-shadow: 0 0 0 2px rgba(255, 255, 255, 0.3);
+      }
+
+      @media (max-width: 380px) {
+        .element {
+          font-size: 16px;
+        }
+      }
+
+      .bit {
+        width: 10vw;
+        height: 10vw;
+        float: left;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="element">
+      <p>This element is tethered to the middle of the visible part of the body.</p>
+
+      <p>Inspect the element to see how Tether decided
+      to use <code>position: fixed</code>.</p>
+    </div>
+
+    <script src="../../tether.js"></script>
+    <script>
+      new Tether({
+        element: '.element',
+        target: document.body,
+        attachment: 'middle center',
+        targetAttachment: 'middle center',
+        targetModifier: 'visible'
+      });
+    </script>
+
+    <script>
+      // Random colors bit, don't mind this
+      colors = ['navy', 'blue', 'aqua', 'teal', 'olive', 'green', 'lime',
+        'yellow', 'orange', 'red', 'fuchsia', 'purple', 'maroon'];
+
+      curColors = null;
+      for(var i=300; i--;){
+        if (!curColors || !curColors.length)
+          curColors = colors.slice(0);
+
+        var bit = document.createElement('div')
+        var index = (Math.random() * curColors.length)|0;
+        bit.className = 'bit bg-' + curColors[index]
+        curColors.splice(index, 1);
+        document.body.appendChild(bit);
+      }
+    </script>
+  </body>
+</html>