Implement a web backend for rustdoc_ng

This large commit implements and `html` output option for rustdoc_ng. The
executable has been altered to be invoked as "rustdoc_ng html <crate>" and
it will dump everything into the local "doc" directory. JSON can still be
generated by changing 'html' to 'json'.

This also fixes a number of bugs in rustdoc_ng relating to comment stripping,
along with some other various issues that I found along the way.

The `make doc` command has been altered to generate the new documentation into
the `doc/ng/$(CRATE)` directories.

22 files changed, 3061 insertions, 133 deletions

diff --git a/RELEASES.txt b/RELEASES.txt
index a65c0c22142..328b783121d 100644
--- a/RELEASES.txt
+++ b/RELEASES.txt
@@ -142,6 +142,7 @@ Version 0.8 (October 2013)
       * The runtime uses jemalloc for allocations.
       * Segmented stacks are temporarily disabled as part of the transition to
         the new runtime. Stack overflows are possible!
+      * A new documentation backend, rustdoc_ng, is available for use
 
 Version 0.7 (July 2013)
 -----------------------
diff --git a/mk/docs.mk b/mk/docs.mk
index 7e3da1c86b1..c214823476d 100644
--- a/mk/docs.mk
+++ b/mk/docs.mk
@@ -213,6 +213,7 @@ else
 
 # The rustdoc executable
 RUSTDOC = $(HBIN2_H_$(CFG_BUILD_TRIPLE))/rustdoc$(X_$(CFG_BUILD_TRIPLE))
+RUSTDOC_NG = $(HBIN2_H_$(CFG_BUILD_TRIPLE))/rustdoc_ng$(X_$(CFG_BUILD_TRIPLE))
 
 # The library documenting macro
 # $(1) - The output directory
@@ -230,8 +231,22 @@ doc/$(1)/rust.css: rust.css
 DOCS += doc/$(1)/index.html
 endef
 
+# The library documenting macro
+# $(1) - The output directory
+# $(2) - The crate file
+# $(3) - The crate soruce files
+define libdocng
+doc/ng/$(1)/index.html: $(2) $(3) $$(RUSTDOC_NG)
+	@$$(call E, rustdoc_ng: $$@)
+	$(Q)$(RUSTDOC_NG) html $(2) -o doc/ng
+
+DOCS += doc/ng/$(1)/index.html
+endef
+
 $(eval $(call libdoc,std,$(STDLIB_CRATE),$(STDLIB_INPUTS)))
 $(eval $(call libdoc,extra,$(EXTRALIB_CRATE),$(EXTRALIB_INPUTS)))
+$(eval $(call libdocng,std,$(STDLIB_CRATE),$(STDLIB_INPUTS)))
+$(eval $(call libdocng,extra,$(EXTRALIB_CRATE),$(EXTRALIB_INPUTS)))
 endif
 
 
diff --git a/src/libextra/extra.rs b/src/libextra/extra.rs
index 9c3c8636d89..c73226eb761 100644
--- a/src/libextra/extra.rs
+++ b/src/libextra/extra.rs
@@ -25,6 +25,10 @@ Rust extras are part of the standard Rust distribution.
        uuid = "122bed0b-c19b-4b82-b0b7-7ae8aead7297",
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];
 
+#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      passes = "strip-hidden")];
+
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 5378a2c798d..d72494b6255 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #[macro_escape];
+#[doc(hidden)];
 
 macro_rules! rterrln (
     ($( $arg:expr),+) => ( {
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 3a43c3364c6..ba8beeba4f6 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -11,6 +11,7 @@
 // FIXME(#4375): this shouldn't have to be a nested module named 'generated'
 
 #[macro_escape];
+#[doc(hidden)];
 
 macro_rules! int_module (($T:ty, $bits:expr) => (mod generated {
 
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index 7cd1be7ab74..45280482b87 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -11,6 +11,7 @@
 // FIXME(#4375): this shouldn't have to be a nested module named 'generated'
 
 #[macro_escape];
+#[doc(hidden)];
 
 macro_rules! uint_module (($T:ty, $T_SIGNED:ty, $bits:expr) => (mod generated {
 
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 6df857b8d55..df59e5538b4 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -54,7 +54,8 @@ Several modules in `core` are clients of `rt`:
 
 */
 
-#[doc(hidden)];
+// XXX: this should not be here.
+#[allow(missing_doc)];
 
 use cell::Cell;
 use clone::Clone;
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index e9d5dd416ad..8dcb7d8cd04 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -57,6 +57,10 @@ they contained the following prologue:
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
+#[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      passes = "strip-hidden")];
+
 // Don't link to std. We are std.
 #[no_std];
 
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index cace4648df2..d33ae069112 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -262,7 +262,7 @@ impl Context {
                 let span = match self.names.find(&name) {
                     Some(e) => e.span,
                     None => {
-                        let msg = fmt!("There is no argument named `%s`", name);
+                        let msg = fmt!("there is no argument named `%s`", name);
                         self.ecx.span_err(self.fmtsp, msg);
                         return;
                     }
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 7ca6224c31d..f13bd6d9123 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -107,9 +107,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
     }
 
     if comment.starts_with("//") {
-        // FIXME #5475:
-        // return comment.slice(3u, comment.len()).to_owned();
-        let r = comment.slice(3u, comment.len()); return r.to_owned();
+        return comment.slice(3u, comment.len()).to_owned();
     }
 
     if comment.starts_with("/*") {
diff --git a/src/rustdoc_ng/clean.rs b/src/rustdoc_ng/clean.rs
index 65aa070ce6e..97a599196e7 100644
--- a/src/rustdoc_ng/clean.rs
+++ b/src/rustdoc_ng/clean.rs
@@ -15,6 +15,7 @@ use its = syntax::parse::token::ident_to_str;
 
 use syntax;
 use syntax::ast;
+use syntax::attr::AttributeMethods;
 
 use std;
 use doctree;
@@ -90,6 +91,48 @@ pub struct Item {
     id: ast::NodeId,
 }
 
+impl Item {
+    /// Finds the `doc` attribute as a List and returns the list of attributes
+    /// nested inside.
+    pub fn doc_list<'a>(&'a self) -> Option<&'a [Attribute]> {
+        for attr in self.attrs.iter() {
+            match *attr {
+                List(~"doc", ref list) => { return Some(list.as_slice()); }
+                _ => {}
+            }
+        }
+        return None;
+    }
+
+    /// Finds the `doc` attribute as a NameValue and returns the corresponding
+    /// value found.
+    pub fn doc_value<'a>(&'a self) -> Option<&'a str> {
+        for attr in self.attrs.iter() {
+            match *attr {
+                NameValue(~"doc", ref v) => { return Some(v.as_slice()); }
+                _ => {}
+            }
+        }
+        return None;
+    }
+
+    pub fn is_mod(&self) -> bool {
+        match self.inner { ModuleItem(*) => true, _ => false }
+    }
+    pub fn is_trait(&self) -> bool {
+        match self.inner { TraitItem(*) => true, _ => false }
+    }
+    pub fn is_struct(&self) -> bool {
+        match self.inner { StructItem(*) => true, _ => false }
+    }
+    pub fn is_enum(&self) -> bool {
+        match self.inner { EnumItem(*) => true, _ => false }
+    }
+    pub fn is_fn(&self) -> bool {
+        match self.inner { FunctionItem(*) => true, _ => false }
+    }
+}
+
 #[deriving(Clone, Encodable, Decodable)]
 pub enum ItemEnum {
     StructItem(Struct),
@@ -155,7 +198,7 @@ impl Clean<Attribute> for ast::MetaItem {
 
 impl Clean<Attribute> for ast::Attribute {
     fn clean(&self) -> Attribute {
-        self.node.value.clean()
+        self.desugar_doc().node.value.clean()
     }
 }
 
@@ -437,18 +480,24 @@ pub enum TraitMethod {
 }
 
 impl TraitMethod {
-    fn is_req(&self) -> bool {
+    pub fn is_req(&self) -> bool {
         match self {
             &Required(*) => true,
             _ => false,
         }
     }
-    fn is_def(&self) -> bool {
+    pub fn is_def(&self) -> bool {
         match self {
             &Provided(*) => true,
             _ => false,
         }
     }
+    pub fn item<'a>(&'a self) -> &'a Item {
+        match *self {
+            Required(ref item) => item,
+            Provided(ref item) => item,
+        }
+    }
 }
 
 impl Clean<TraitMethod> for ast::trait_method {
diff --git a/src/rustdoc_ng/fold.rs b/src/rustdoc_ng/fold.rs
index 7b72429e375..ae74f4e37c3 100644
--- a/src/rustdoc_ng/fold.rs
+++ b/src/rustdoc_ng/fold.rs
@@ -91,21 +91,9 @@ pub trait DocFolder {
     }
 
     fn fold_crate(&mut self, mut c: Crate) -> Crate {
-        let mut mod_ = None;
-        std::util::swap(&mut mod_, &mut c.module);
-        let mod_ = mod_.unwrap();
-        c.module = self.fold_item(mod_);
-        let Crate { name, module } = c;
-        match module {
-            Some(Item { inner: ModuleItem(m), name: name_, attrs: attrs_,
-            source, visibility: vis, id }) => {
-                return Crate { module: Some(Item { inner:
-                                            ModuleItem(self.fold_mod(m)),
-                                            name: name_, attrs: attrs_,
-                                            source: source, id: id, visibility: vis }), name: name};
-            },
-            Some(_) => fail!("non-module item set as module of crate"),
-            None => return Crate { module: None, name: name},
-        }
+        c.module = match std::util::replace(&mut c.module, None) {
+            Some(module) => self.fold_item(module), None => None
+        };
+        return c;
     }
 }
diff --git a/src/rustdoc_ng/html/format.rs b/src/rustdoc_ng/html/format.rs
new file mode 100644
index 00000000000..4d0f6928d50
--- /dev/null
+++ b/src/rustdoc_ng/html/format.rs
@@ -0,0 +1,364 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+use std::local_data;
+use std::rt::io;
+
+use syntax::ast;
+
+use clean;
+use html::render::{cache_key, current_location_key};
+
+pub struct VisSpace(Option<ast::visibility>);
+pub struct Method<'self>(&'self clean::SelfTy, &'self clean::FnDecl);
+
+impl fmt::Default for clean::Generics {
+    fn fmt(g: &clean::Generics, f: &mut fmt::Formatter) {
+        if g.lifetimes.len() == 0 && g.type_params.len() == 0 { return }
+        f.buf.write("&lt;".as_bytes());
+
+        for (i, life) in g.lifetimes.iter().enumerate() {
+            if i > 0 { f.buf.write(", ".as_bytes()); }
+            write!(f.buf, "{}", *life);
+        }
+
+        if g.type_params.len() > 0 {
+            if g.lifetimes.len() > 0 { f.buf.write(", ".as_bytes()); }
+
+            for (i, tp) in g.type_params.iter().enumerate() {
+                if i > 0 { f.buf.write(", ".as_bytes()) }
+                f.buf.write(tp.name.as_bytes());
+
+                if tp.bounds.len() > 0 {
+                    f.buf.write(": ".as_bytes());
+                    for (i, bound) in tp.bounds.iter().enumerate() {
+                        if i > 0 { f.buf.write(" + ".as_bytes()); }
+                        write!(f.buf, "{}", *bound);
+                    }
+                }
+            }
+        }
+        f.buf.write("&gt;".as_bytes());
+    }
+}
+
+impl fmt::Default for clean::Lifetime {
+    fn fmt(l: &clean::Lifetime, f: &mut fmt::Formatter) {
+        f.buf.write("'".as_bytes());
+        f.buf.write(l.as_bytes());
+    }
+}
+
+impl fmt::Default for clean::TyParamBound {
+    fn fmt(bound: &clean::TyParamBound, f: &mut fmt::Formatter) {
+        match *bound {
+            clean::RegionBound => {
+                f.buf.write("'static".as_bytes())
+            }
+            clean::TraitBound(ref ty) => {
+                write!(f.buf, "{}", *ty);
+            }
+        }
+    }
+}
+
+impl fmt::Default for clean::Path {
+    fn fmt(path: &clean::Path, f: &mut fmt::Formatter) {
+        if path.global { f.buf.write("::".as_bytes()) }
+        for (i, seg) in path.segments.iter().enumerate() {
+            if i > 0 { f.buf.write("::".as_bytes()) }
+            f.buf.write(seg.name.as_bytes());
+
+            if seg.lifetime.is_some() || seg.types.len() > 0 {
+                f.buf.write("&lt;".as_bytes());
+                match seg.lifetime {
+                    Some(ref lifetime) => write!(f.buf, "{}", *lifetime),
+                    None => {}
+                }
+                for (i, ty) in seg.types.iter().enumerate() {
+                    if i > 0 || seg.lifetime.is_some() {
+                        f.buf.write(", ".as_bytes());
+                    }
+                    write!(f.buf, "{}", *ty);
+                }
+                f.buf.write("&gt;".as_bytes());
+            }
+        }
+    }
+}
+
+fn resolved_path(w: &mut io::Writer, id: ast::NodeId, path: &clean::Path) {
+    // The generics will get written to both the title and link
+    let mut generics = ~"";
+    let last = path.segments.last();
+    if last.lifetime.is_some() || last.types.len() > 0 {
+        generics.push_str("&lt;");
+        match last.lifetime {
+            Some(ref lifetime) => generics.push_str(format!("{}", *lifetime)),
+            None => {}
+        }
+        for (i, ty) in last.types.iter().enumerate() {
+            if i > 0 || last.lifetime.is_some() {
+                generics.push_str(", ");
+            }
+            generics.push_str(format!("{}", *ty));
+        }
+        generics.push_str("&gt;");
+    }
+
+    // Did someone say rightward-drift?
+    do local_data::get(current_location_key) |loc| {
+        let loc = loc.unwrap();
+        do local_data::get(cache_key) |cache| {
+            do cache.unwrap().read |cache| {
+                match cache.paths.find(&id) {
+                    // This is a documented path, link to it!
+                    Some(&(ref fqp, shortty)) => {
+                        let fqn = fqp.connect("::");
+                        let mut same = 0;
+                        for (a, b) in loc.iter().zip(fqp.iter()) {
+                            if *a == *b {
+                                same += 1;
+                            } else {
+                                break;
+                            }
+                        }
+
+                        let mut url = ~"";
+                        for _ in range(same, loc.len()) {
+                            url.push_str("../");
+                        }
+                        if same == fqp.len() {
+                            url.push_str(shortty);
+                            url.push_str(".");
+                            url.push_str(*fqp.last());
+                            url.push_str(".html");
+                        } else {
+                            let remaining = fqp.slice_from(same);
+                            let to_link = remaining.slice_to(remaining.len() - 1);
+                            for component in to_link.iter() {
+                                url.push_str(*component);
+                                url.push_str("/");
+                            }
+                            url.push_str(shortty);
+                            url.push_str(".");
+                            url.push_str(*remaining.last());
+                            url.push_str(".html");
+                        }
+
+                        write!(w, "<a class='{}' href='{}' title='{}'>{}</a>{}",
+                               shortty, url, fqn, last.name, generics);
+                    }
+                    None => {
+                        write!(w, "{}{}", last.name, generics);
+                    }
+                };
+            }
+        }
+    }
+}
+
+impl fmt::Default for clean::Type {
+    fn fmt(g: &clean::Type, f: &mut fmt::Formatter) {
+        match *g {
+            clean::TyParamBinder(id) | clean::Generic(id) => {
+                do local_data::get(cache_key) |cache| {
+                    do cache.unwrap().read |m| {
+                        f.buf.write(m.typarams.get(&id).as_bytes());
+                    }
+                }
+            }
+            clean::Unresolved(*) => unreachable!(),
+            clean::ResolvedPath{id, typarams: ref typarams, path: ref path} => {
+                resolved_path(f.buf, id, path);
+                match *typarams {
+                    Some(ref params) => {
+                        f.buf.write("&lt;".as_bytes());
+                        for (i, param) in params.iter().enumerate() {
+                            if i > 0 { f.buf.write(", ".as_bytes()) }
+                            write!(f.buf, "{}", *param);
+                        }
+                        f.buf.write("&gt;".as_bytes());
+                    }
+                    None => {}
+                }
+            }
+            // XXX: this should be a link
+            clean::External(ref a, _) => {
+                write!(f.buf, "{}", *a);
+            }
+            clean::Self(*) => f.buf.write("Self".as_bytes()),
+            clean::Primitive(prim) => {
+                let s = match prim {
+                    ast::ty_int(ast::ty_i) => "int",
+                    ast::ty_int(ast::ty_i8) => "i8",
+                    ast::ty_int(ast::ty_i16) => "i16",
+                    ast::ty_int(ast::ty_i32) => "i32",
+                    ast::ty_int(ast::ty_i64) => "i64",
+                    ast::ty_uint(ast::ty_u) => "uint",
+                    ast::ty_uint(ast::ty_u8) => "u8",
+                    ast::ty_uint(ast::ty_u16) => "u16",
+                    ast::ty_uint(ast::ty_u32) => "u32",
+                    ast::ty_uint(ast::ty_u64) => "u64",
+                    ast::ty_float(ast::ty_f) => "float",
+                    ast::ty_float(ast::ty_f32) => "f32",
+                    ast::ty_float(ast::ty_f64) => "f64",
+                    ast::ty_str => "str",
+                    ast::ty_bool => "bool",
+                    ast::ty_char => "char",
+                };
+                f.buf.write(s.as_bytes());
+            }
+            clean::Closure(ref decl) => {
+                f.buf.write(match decl.sigil {
+                    ast::BorrowedSigil => "&amp;",
+                    ast::ManagedSigil => "@",
+                    ast::OwnedSigil => "~",
+                }.as_bytes());
+                match decl.region {
+                    Some(ref region) => write!(f.buf, "{} ", *region),
+                    None => {}
+                }
+                write!(f.buf, "{}{}fn{}",
+                       match decl.purity {
+                           ast::unsafe_fn => "unsafe ",
+                           ast::extern_fn => "extern ",
+                           ast::impure_fn => ""
+                       },
+                       match decl.onceness {
+                           ast::Once => "once ",
+                           ast::Many => "",
+                       },
+                       decl.decl);
+                // XXX: where are bounds and lifetimes printed?!
+            }
+            clean::BareFunction(ref decl) => {
+                write!(f.buf, "{}{}fn{}{}",
+                       match decl.purity {
+                           ast::unsafe_fn => "unsafe ",
+                           ast::extern_fn => "extern ",
+                           ast::impure_fn => ""
+                       },
+                       match decl.abi {
+                           ~"" | ~"\"Rust\"" => ~"",
+                           ref s => " " + *s + " ",
+                       },
+                       decl.generics,
+                       decl.decl);
+            }
+            clean::Tuple(ref typs) => {
+                f.buf.write("(".as_bytes());
+                for (i, typ) in typs.iter().enumerate() {
+                    if i > 0 { f.buf.write(", ".as_bytes()) }
+                    write!(f.buf, "{}", *typ);
+                }
+                f.buf.write(")".as_bytes());
+            }
+            clean::Vector(ref t) => write!(f.buf, "[{}]", **t),
+            clean::FixedVector(ref t, ref s) => {
+                write!(f.buf, "[{}, ..{}]", **t, *s);
+            }
+            clean::String => f.buf.write("str".as_bytes()),
+            clean::Bool => f.buf.write("bool".as_bytes()),
+            clean::Unit => f.buf.write("()".as_bytes()),
+            clean::Bottom => f.buf.write("!".as_bytes()),
+            clean::Unique(ref t) => write!(f.buf, "~{}", **t),
+            clean::Managed(m, ref t) => {
+                write!(f.buf, "@{}{}",
+                       match m {
+                           clean::Mutable => "mut ",
+                           clean::Immutable => "",
+                       }, **t)
+            }
+            clean::RawPointer(m, ref t) => {
+                write!(f.buf, "*{}{}",
+                       match m {
+                           clean::Mutable => "mut ",
+                           clean::Immutable => "",
+                       }, **t)
+            }
+            clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => {
+                let lt = match *l { Some(ref l) => format!("{} ", *l), _ => ~"" };
+                write!(f.buf, "&amp;{}{}{}",
+                       lt,
+                       match mutability {
+                           clean::Mutable => "mut ",
+                           clean::Immutable => "",
+                       },
+                       **ty);
+            }
+        }
+    }
+}
+
+impl fmt::Default for clean::FnDecl {
+    fn fmt(d: &clean::FnDecl, f: &mut fmt::Formatter) {
+        let mut args = ~"";
+        for (i, input) in d.inputs.iter().enumerate() {
+            if i > 0 { args.push_str(", "); }
+            if input.name.len() > 0 {
+                args.push_str(format!("{}: ", input.name));
+            }
+            args.push_str(format!("{}", input.type_));
+        }
+        write!(f.buf, "({args}){arrow, select, yes{ -&gt; {ret}} other{}}",
+               args = args,
+               arrow = match d.output { clean::Unit => "no", _ => "yes" },
+               ret = d.output);
+    }
+}
+
+impl<'self> fmt::Default for Method<'self> {
+    fn fmt(m: &Method<'self>, f: &mut fmt::Formatter) {
+        let Method(selfty, d) = *m;
+        let mut args = ~"";
+        match *selfty {
+            clean::SelfStatic => {},
+            clean::SelfValue => args.push_str("self"),
+            clean::SelfOwned => args.push_str("~self"),
+            clean::SelfManaged(clean::Mutable) => args.push_str("@mut self"),
+            clean::SelfManaged(clean::Immutable) => args.push_str("@self"),
+            clean::SelfBorrowed(Some(ref lt), clean::Immutable) => {
+                args.push_str(format!("&amp;{} self", *lt));
+            }
+            clean::SelfBorrowed(Some(ref lt), clean::Mutable) => {
+                args.push_str(format!("&amp;{} mut self", *lt));
+            }
+            clean::SelfBorrowed(None, clean::Mutable) => {
+                args.push_str("&amp;mut self");
+            }
+            clean::SelfBorrowed(None, clean::Immutable) => {
+                args.push_str("&amp;self");
+            }
+        }
+        for (i, input) in d.inputs.iter().enumerate() {
+            if i > 0 || args.len() > 0 { args.push_str(", "); }
+            if input.name.len() > 0 {
+                args.push_str(format!("{}: ", input.name));
+            }
+            args.push_str(format!("{}", input.type_));
+        }
+        write!(f.buf, "({args}){arrow, select, yes{ -&gt; {ret}} other{}}",
+               args = args,
+               arrow = match d.output { clean::Unit => "no", _ => "yes" },
+               ret = d.output);
+    }
+}
+
+impl fmt::Default for VisSpace {
+    fn fmt(v: &VisSpace, f: &mut fmt::Formatter) {
+        match **v {
+            Some(ast::public) => { write!(f.buf, "pub "); }
+            Some(ast::private) => { write!(f.buf, "priv "); }
+            Some(ast::inherited) | None => {}
+        }
+    }
+}
diff --git a/src/rustdoc_ng/html/layout.rs b/src/rustdoc_ng/html/layout.rs
new file mode 100644
index 00000000000..fcf13779389
--- /dev/null
+++ b/src/rustdoc_ng/html/layout.rs
@@ -0,0 +1,130 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+use std::rt::io;
+
+#[deriving(Clone)]
+pub struct Layout {
+    logo: ~str,
+    favicon: ~str,
+    crate: ~str,
+}
+
+pub struct Page<'self> {
+    title: &'self str,
+    ty: &'self str,
+    root_path: &'self str,
+}
+
+pub fn render<T: fmt::Default, S: fmt::Default>(
+    dst: &mut io::Writer, layout: &Layout, page: &Page, sidebar: &S, t: &T)
+{
+    write!(dst, "
+<!DOCTYPE html>
+<html lang=\"en\">
+<head>
+    <meta charset=\"utf-8\" />
+    <title>{title}</title>
+
+    <link href='http://fonts.googleapis.com/css?family=Oswald:700|Inconsolata:400'
+          rel='stylesheet' type='text/css'>
+    <link rel=\"stylesheet\" type=\"text/css\" href=\"{root_path}main.css\">
+
+    {favicon, select, none{} other{
+        <link rel=\"icon\" href=\"#\" sizes=\"16x16\"
+              type=\"image/vnd.microsoft.icon\" />}}
+</head>
+<body>
+    <!--[if lte IE 8]>
+    <div class=\"warning\">
+        This old browser is unsupported and will most likely display funky
+        things
+    </div>
+    <![endif]-->
+
+    <section class=\"sidebar\">
+        {logo, select, none{} other{
+            <a href='{root_path}index.html'><img src='#' alt=''/></a>
+        }}
+
+        {sidebar}
+    </section>
+
+    <nav class=\"sub\">
+        <form class=\"search-form js-only\">
+            <input class=\"search-input\" name=\"search\"
+                   autocomplete=\"off\" />
+            <button class=\"do-search\">Search</button>
+        </form>
+    </nav>
+
+    <section class=\"content {ty}\">{content}</section>
+
+    <section class=\"footer\"></section>
+
+    <script>
+        var rootPath = \"{root_path}\";
+    </script>
+    <script src=\"{root_path}jquery.js\"></script>
+    <script src=\"{root_path}{crate}/search-index.js\"></script>
+    <script src=\"{root_path}main.js\"></script>
+
+    <div id=\"help\" class=\"hidden\">
+        <div class=\"shortcuts\">
+            <h1>Keyboard shortcuts</h1>
+            <dl>
+                <dt>?</dt>
+                <dd>Show this help dialog</dd>
+                <dt>S</dt>
+                <dd>Focus the search field</dd>
+                <dt>&uarr;</dt>
+                <dd>Move up in search results</dd>
+                <dt>&darr;</dt>
+                <dd>Move down in search results</dd>
+                <dt>&\\#9166;</dt>
+                <dd>Go to active search result</dd>
+            </dl>
+        </div>
+        <div class=\"infos\">
+            <h1>Search tricks</h1>
+            <p>
+                Prefix searches with a type followed by a colon (e.g.
+                <code>fn:</code>) to restrict the search to a given type.
+            </p>
+            <p>
+                Accepted types are: <code>fn</code>, <code>mod</code>,
+                <code>struct</code> (or <code>str</code>), <code>enum</code>,
+                <code>trait</code>, <code>typedef</code> (or
+                <code>tdef</code>).
+            </p>
+        </div>
+    </div>
+</body>
+</html>
+",
+    content   = *t,
+    root_path = page.root_path,
+    ty        = page.ty,
+    logo      = nonestr(layout.logo),
+    title     = page.title,
+    favicon   = nonestr(layout.favicon),
+    sidebar   = *sidebar,
+    crate     = layout.crate,
+    );
+}
+
+fn boolstr(b: bool) -> &'static str {
+    if b { "true" } else { "false" }
+}
+
+fn nonestr<'a>(s: &'a str) -> &'a str {
+    if s == "" { "none" } else { s }
+}
diff --git a/src/rustdoc_ng/html/markdown.rs b/src/rustdoc_ng/html/markdown.rs
new file mode 100644
index 00000000000..14e2327550b
--- /dev/null
+++ b/src/rustdoc_ng/html/markdown.rs
@@ -0,0 +1,54 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::fmt;
+use std::rt::io::Reader;
+use std::rt::io::pipe::PipeStream;
+use std::rt::io::process::{ProcessConfig, Process, CreatePipe};
+use std::rt::io;
+
+pub struct Markdown<'self>(&'self str);
+
+impl<'self> fmt::Default for Markdown<'self> {
+    fn fmt(md: &Markdown<'self>, fmt: &mut fmt::Formatter) {
+        if md.len() == 0 { return; }
+
+        // Create the pandoc process
+        do io::io_error::cond.trap(|err| {
+            fail2!("Error executing `pandoc`: {}", err.desc);
+        }).inside {
+            let io = ~[CreatePipe(PipeStream::new().unwrap(), true, false),
+                       CreatePipe(PipeStream::new().unwrap(), false, true)];
+            let args = ProcessConfig {
+                program: "pandoc",
+                args: [],
+                env: None,
+                cwd: None,
+                io: io,
+            };
+            let mut p = Process::new(args).expect("couldn't fork for pandoc");
+
+            // Write the markdown to stdin and close it.
+            p.io[0].get_mut_ref().write(md.as_bytes());
+            p.io[0] = None;
+
+            // Ferry the output from pandoc over to the destination buffer.
+            let mut buf = [0, ..1024];
+            loop {
+                match p.io[1].get_mut_ref().read(buf) {
+                    None | Some(0) => { break }
+                    Some(n) => {
+                        fmt.buf.write(buf.slice_to(n));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/rustdoc_ng/html/render.rs b/src/rustdoc_ng/html/render.rs
new file mode 100644
index 00000000000..b004061e04a
--- /dev/null
+++ b/src/rustdoc_ng/html/render.rs
@@ -0,0 +1,1108 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cell::Cell;
+use std::comm::{SharedPort, SharedChan};
+use std::comm;
+use std::fmt;
+use std::hashmap::HashMap;
+use std::local_data;
+use std::rt::io::buffered::BufferedWriter;
+use std::rt::io::file::{FileInfo, DirectoryInfo};
+use std::rt::io::file;
+use std::rt::io;
+use std::task;
+use std::unstable::finally::Finally;
+use std::util;
+use std::vec;
+
+use extra::arc::RWArc;
+use extra::json::ToJson;
+use extra::sort;
+
+use syntax::ast;
+
+use clean;
+use doctree;
+use fold::DocFolder;
+use html::format::{VisSpace, Method};
+use html::layout;
+use html::markdown::Markdown;
+
+#[deriving(Clone)]
+pub struct Context {
+    current: ~[~str],
+    root_path: ~str,
+    dst: Path,
+    layout: layout::Layout,
+    sidebar: HashMap<~str, ~[~str]>,
+}
+
+enum Implementor {
+    PathType(clean::Type),
+    OtherType(clean::Generics, /* trait */ clean::Type, /* for */ clean::Type),
+}
+
+struct Cache {
+    // typaram id => name of that typaram
+    typarams: HashMap<ast::NodeId, ~str>,
+    // type id => all implementations for that type
+    impls: HashMap<ast::NodeId, ~[clean::Impl]>,
+    // path id => (full qualified path, shortty) -- used to generate urls
+    paths: HashMap<ast::NodeId, (~[~str], &'static str)>,
+    // trait id => method name => dox
+    traits: HashMap<ast::NodeId, HashMap<~str, ~str>>,
+    // trait id => implementors of the trait
+    implementors: HashMap<ast::NodeId, ~[Implementor]>,
+
+    priv stack: ~[~str],
+    priv parent_stack: ~[ast::NodeId],
+    priv search_index: ~[IndexItem],
+}
+
+struct Item<'self> { cx: &'self Context, item: &'self clean::Item, }
+struct Sidebar<'self> { cx: &'self Context, item: &'self clean::Item, }
+
+struct IndexItem {
+    ty: &'static str,
+    name: ~str,
+    path: ~str,
+    desc: ~str,
+    parent: Option<ast::NodeId>,
+}
+
+local_data_key!(pub cache_key: RWArc<Cache>)
+local_data_key!(pub current_location_key: ~[~str])
+
+/// Generates the documentation for `crate` into the directory `dst`
+pub fn run(mut crate: clean::Crate, dst: Path) {
+    let mut cx = Context {
+        dst: dst,
+        current: ~[],
+        root_path: ~"",
+        sidebar: HashMap::new(),
+        layout: layout::Layout {
+            logo: ~"",
+            favicon: ~"",
+            crate: crate.name.clone(),
+        },
+    };
+    mkdir(&cx.dst);
+
+    match crate.module.get_ref().doc_list() {
+        Some(attrs) => {
+            for attr in attrs.iter() {
+                match *attr {
+                    clean::NameValue(~"html_favicon_url", ref s) => {
+                        cx.layout.favicon = s.to_owned();
+                    }
+                    clean::NameValue(~"html_logo_url", ref s) => {
+                        cx.layout.logo = s.to_owned();
+                    }
+                    _ => {}
+                }
+            }
+        }
+        None => {}
+    }
+
+    // Crawl the crate to build various caches used for the output
+    let mut cache = Cache {
+        impls: HashMap::new(),
+        typarams: HashMap::new(),
+        paths: HashMap::new(),
+        traits: HashMap::new(),
+        implementors: HashMap::new(),
+        stack: ~[],
+        parent_stack: ~[],
+        search_index: ~[],
+    };
+    cache.stack.push(crate.name.clone());
+    crate = cache.fold_crate(crate);
+
+    // Add all the static files
+    write(cx.dst.push("jquery.js"), include_str!("static/jquery-2.0.3.min.js"));
+    write(cx.dst.push("main.js"), include_str!("static/main.js"));
+    write(cx.dst.push("main.css"), include_str!("static/main.css"));
+    write(cx.dst.push("normalize.css"), include_str!("static/normalize.css"));
+    write(cx.dst.push("index.html"), format!("
+        <DOCTYPE html><html><head>
+            <meta http-equiv='refresh'
+                  content=\"0; url={}/index.html\">
+        </head><body></body></html>
+    ", crate.name));
+
+    {
+        mkdir(&cx.dst.push(crate.name));
+        let dst = cx.dst.push(crate.name).push("search-index.js");
+        let mut w = BufferedWriter::new(dst.open_writer(io::CreateOrTruncate));
+        let w = &mut w as &mut io::Writer;
+        write!(w, "var searchIndex = [");
+        for (i, item) in cache.search_index.iter().enumerate() {
+            if i > 0 { write!(w, ","); }
+            write!(w, "\\{ty:\"{}\",name:\"{}\",path:\"{}\",desc:{}",
+                   item.ty, item.name, item.path,
+                   item.desc.to_json().to_str())
+            match item.parent {
+                Some(id) => { write!(w, ",parent:'{}'", id); }
+                None => {}
+            }
+            write!(w, "\\}");
+        }
+        write!(w, "];");
+        write!(w, "var allPaths = \\{");
+        for (i, (&id, &(ref fqp, short))) in cache.paths.iter().enumerate() {
+            if i > 0 { write!(w, ","); }
+            write!(w, "'{}':\\{type:'{}',name:'{}'\\}", id, short, *fqp.last());
+        }
+        write!(w, "\\};");
+        w.flush();
+    }
+
+    // Now render the whole crate.
+    cx.crate(crate, cache);
+}
+
+fn write(dst: Path, contents: &str) {
+    let mut w = dst.open_writer(io::CreateOrTruncate);
+    w.write(contents.as_bytes());
+}
+
+fn mkdir(path: &Path) {
+    do io::io_error::cond.trap(|err| {
+        error2!("Couldn't create directory `{}`: {}",
+                path.to_str(), err.desc);
+        fail!()
+    }).inside {
+        if !path.is_dir() {
+            file::mkdir(path);
+        }
+    }
+}
+
+impl<'self> DocFolder for Cache {
+    fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
+        // Register any generics to their corresponding string. This is used
+        // when pretty-printing types
+        match item.inner {
+            clean::StructItem(ref s)   => self.generics(&s.generics),
+            clean::EnumItem(ref e)     => self.generics(&e.generics),
+            clean::FunctionItem(ref f) => self.generics(&f.generics),
+            clean::TypedefItem(ref t)  => self.generics(&t.generics),
+            clean::TraitItem(ref t)    => self.generics(&t.generics),
+            clean::ImplItem(ref i)     => self.generics(&i.generics),
+            clean::TyMethodItem(ref i) => self.generics(&i.generics),
+            clean::MethodItem(ref i)   => self.generics(&i.generics),
+            _ => {}
+        }
+
+        // Propagate a trait methods' documentation to all implementors of the
+        // trait
+        match item.inner {
+            clean::TraitItem(ref t) => {
+                let mut dox = HashMap::new();
+                for meth in t.methods.iter() {
+                    let it = meth.item();
+                    match it.doc_value() {
+                        None => {}
+                        Some(s) => {
+                            dox.insert(it.name.get_ref().to_owned(),
+                                       s.to_owned());
+                        }
+                    }
+                }
+                self.traits.insert(item.id, dox);
+            }
+            _ => {}
+        }
+
+        // Collect all the implementors of traits.
+        match item.inner {
+            clean::ImplItem(ref i) => {
+                match i.trait_ {
+                    Some(clean::ResolvedPath{ id, _ }) => {
+                        let v = do self.implementors.find_or_insert_with(id) |_|{
+                            ~[]
+                        };
+                        match i.for_ {
+                            clean::ResolvedPath{_} => {
+                                v.unshift(PathType(i.for_.clone()));
+                            }
+                            _ => {
+                                v.push(OtherType(i.generics.clone(),
+                                                 i.trait_.get_ref().clone(),
+                                                 i.for_.clone()));
+                            }
+                        }
+                    }
+                    Some(*) | None => {}
+                }
+            }
+            _ => {}
+        }
+
+        // Index this method for searching later on
+        match item.name {
+            Some(ref s) => {
+                let parent = match item.inner {
+                    clean::TyMethodItem(*) | clean::VariantItem(*) => {
+                        Some((Some(*self.parent_stack.last()),
+                              self.stack.slice_to(self.stack.len() - 1)))
+
+                    }
+                    clean::MethodItem(*) => {
+                        if self.parent_stack.len() == 0 {
+                            None
+                        } else {
+                            Some((Some(*self.parent_stack.last()),
+                                  self.stack.as_slice()))
+                        }
+                    }
+                    _ => Some((None, self.stack.as_slice()))
+                };
+                match parent {
+                    Some((parent, path)) => {
+                        self.search_index.push(IndexItem {
+                            ty: shortty(&item),
+                            name: s.to_owned(),
+                            path: path.connect("::"),
+                            desc: shorter(item.doc_value()).to_owned(),
+                            parent: parent,
+                        });
+                    }
+                    None => {}
+                }
+            }
+            None => {}
+        }
+
+        // Keep track of the fully qualified path for this item.
+        let pushed = if item.name.is_some() {
+            let n = item.name.get_ref();
+            if n.len() > 0 {
+                self.stack.push(n.to_owned());
+                true
+            } else { false }
+        } else { false };
+        match item.inner {
+            clean::StructItem(*) | clean::EnumItem(*) |
+            clean::TypedefItem(*) | clean::TraitItem(*) => {
+                self.paths.insert(item.id, (self.stack.clone(), shortty(&item)));
+            }
+            _ => {}
+        }
+
+        // Maintain the parent stack
+        let parent_pushed = match item.inner {
+            clean::TraitItem(*) | clean::EnumItem(*) => {
+                self.parent_stack.push(item.id); true
+            }
+            clean::ImplItem(ref i) => {
+                match i.for_ {
+                    clean::ResolvedPath{ id, _ } => {
+                        self.parent_stack.push(id); true
+                    }
+                    _ => false
+                }
+            }
+            _ => false
+        };
+
+        // Once we've recursively found all the generics, then hoard off all the
+        // implementations elsewhere
+        let ret = match self.fold_item_recur(item) {
+            Some(item) => {
+                match item.inner {
+                    clean::ImplItem(i) => {
+                        match i.for_ {
+                            clean::ResolvedPath { id, _ } => {
+                                let v = do self.impls.find_or_insert_with(id) |_| {
+                                    ~[]
+                                };
+                                v.push(i);
+                            }
+                            _ => {}
+                        }
+                        None
+                    }
+                    _ => Some(item),
+                }
+            }
+            i => i,
+        };
+
+        if pushed { self.stack.pop(); }
+        if parent_pushed { self.parent_stack.pop(); }
+        return ret;
+    }
+}
+
+impl<'self> Cache {
+    fn generics(&mut self, generics: &clean::Generics) {
+        for typ in generics.type_params.iter() {
+            self.typarams.insert(typ.id, typ.name.clone());
+        }
+    }
+}
+
+impl Context {
+    fn recurse<T>(&mut self, s: ~str, f: &fn(&mut Context) -> T) -> T {
+        // Recurse in the directory structure and change the "root path" to make
+        // sure it always points to the top (relatively)
+        if s.len() == 0 {
+            fail2!("what {:?}", self);
+        }
+        let next = self.dst.push(s);
+        let prev = util::replace(&mut self.dst, next);
+        self.root_path.push_str("../");
+        self.current.push(s);
+
+        mkdir(&self.dst);
+        let ret = f(self);
+
+        // Go back to where we were at
+        self.dst = prev;
+        let len = self.root_path.len();
+        self.root_path.truncate(len - 3);
+        self.current.pop();
+
+        return ret;
+    }
+
+    /// Processes
+    fn crate(self, mut crate: clean::Crate, cache: Cache) {
+        enum Work {
+            Die,
+            Process(Context, clean::Item),
+        }
+        enum Progress { JobNew, JobDone }
+        static WORKERS: int = 10;
+
+        let mut item = match crate.module.take() {
+            Some(i) => i,
+            None => return
+        };
+        item.name = Some(crate.name);
+
+        let (port, chan) = comm::stream::<Work>();
+        let port = SharedPort::new(port);
+        let chan = SharedChan::new(chan);
+        let (prog_port, prog_chan) = comm::stream();
+        let prog_chan = SharedChan::new(prog_chan);
+        let cache = RWArc::new(cache);
+
+        for i in range(0, WORKERS) {
+            let port = port.clone();
+            let chan = chan.clone();
+            let prog_chan = prog_chan.clone();
+
+            let mut task = task::task();
+            task.unlinked(); // we kill things manually
+            task.name(format!("worker{}", i));
+            do task.spawn_with(cache.clone()) |cache| {
+                local_data::set(cache_key, cache);
+                loop {
+                    match port.recv() {
+                        Process(cx, item) => {
+                            let mut cx = cx;
+                            let item = Cell::new(item);
+                            do (|| {
+                                do cx.item(item.take()) |cx, item| {
+                                    prog_chan.send(JobNew);
+                                    chan.send(Process(cx.clone(), item));
+                                }
+                            }).finally {
+                                // If we fail, everything else should still get
+                                // completed
+                                prog_chan.send(JobDone);
+                            }
+                        }
+                        Die => break,
+                    }
+                }
+            }
+        }
+
+        let watcher_chan = chan.clone();
+        let (done_port, done_chan) = comm::stream();
+        do task::spawn {
+            let mut jobs = 0;
+            loop {
+                match prog_port.recv() {
+                    JobNew => jobs += 1,
+                    JobDone => jobs -= 1,
+                }
+
+                if jobs == 0 { break }
+            }
+
+            for _ in range(0, WORKERS) {
+                watcher_chan.send(Die);
+            }
+            done_chan.send(());
+        }
+
+        prog_chan.send(JobNew);
+        chan.send(Process(self, item));
+        done_port.recv();
+    }
+
+    fn item(&mut self, item: clean::Item, f: &fn(&mut Context, clean::Item)) {
+        fn render(w: io::file::FileWriter, cx: &mut Context, it: &clean::Item,
+                  pushname: bool) {
+            // A little unfortunate that this is done like this, but it sure
+            // does make formatting *a lot* nicer.
+            local_data::set(current_location_key, cx.current.clone());
+
+            let mut title = cx.current.connect("::");
+            if pushname {
+                if title.len() > 0 { title.push_str("::"); }
+                title.push_str(*it.name.get_ref());
+            }
+            title.push_str(" - Rust");
+            let page = layout::Page {
+                ty: shortty(it),
+                root_path: cx.root_path,
+                title: title,
+            };
+
+            // We have a huge number of calls to write, so try to alleviate some
+            // of the pain by using a buffered writer instead of invoking the
+            // write sycall all the time.
+            let mut writer = BufferedWriter::new(w);
+            layout::render(&mut writer as &mut io::Writer, &cx.layout, &page,
+                           &Sidebar{ cx: cx, item: it },
+                           &Item{ cx: cx, item: it });
+            writer.flush();
+        }
+
+        match item.inner {
+            clean::ModuleItem(*) => {
+                let name = item.name.get_ref().to_owned();
+                let item = Cell::new(item);
+                do self.recurse(name) |this| {
+                    let item = item.take();
+                    let dst = this.dst.push("index.html");
+                    let writer = dst.open_writer(io::CreateOrTruncate);
+                    render(writer.unwrap(), this, &item, false);
+
+                    let m = match item.inner {
+                        clean::ModuleItem(m) => m,
+                        _ => unreachable!()
+                    };
+                    this.sidebar = build_sidebar(&m);
+                    for item in m.items.move_iter() {
+                        f(this, item);
+                    }
+                }
+            }
+            _ if item.name.is_some() => {
+                let dst = self.dst.push(item_path(&item));
+                let writer = dst.open_writer(io::CreateOrTruncate);
+                render(writer.unwrap(), self, &item, true);
+            }
+            _ => {}
+        }
+    }
+}
+
+fn shortty(item: &clean::Item) -> &'static str {
+    match item.inner {
+        clean::ModuleItem(*)      => "mod",
+        clean::StructItem(*)      => "struct",
+        clean::EnumItem(*)        => "enum",
+        clean::FunctionItem(*)    => "fn",
+        clean::TypedefItem(*)     => "typedef",
+        clean::StaticItem(*)      => "static",
+        clean::TraitItem(*)       => "trait",
+        clean::ImplItem(*)        => "impl",
+        clean::ViewItemItem(*)    => "viewitem",
+        clean::TyMethodItem(*)    => "tymethod",
+        clean::MethodItem(*)      => "method",
+        clean::StructFieldItem(*) => "structfield",
+        clean::VariantItem(*)     => "variant",
+    }
+}
+
+impl<'self> Item<'self> {
+    fn ismodule(&self) -> bool {
+        match self.item.inner {
+            clean::ModuleItem(*) => true, _ => false
+        }
+    }
+}
+
+impl<'self> fmt::Default for Item<'self> {
+    fn fmt(it: &Item<'self>, fmt: &mut fmt::Formatter) {
+        // Write the breadcrumb trail header for the top
+        write!(fmt.buf, "<h1 class='fqn'>");
+        match it.item.inner {
+            clean::ModuleItem(*) => write!(fmt.buf, "Module "),
+            clean::FunctionItem(*) => write!(fmt.buf, "Function "),
+            clean::TraitItem(*) => write!(fmt.buf, "Trait "),
+            clean::StructItem(*) => write!(fmt.buf, "Struct "),
+            clean::EnumItem(*) => write!(fmt.buf, "Enum "),
+            _ => {}
+        }
+        let cur = it.cx.current.as_slice();
+        let amt = if it.ismodule() { cur.len() - 1 } else { cur.len() };
+        for (i, component) in cur.iter().enumerate().take(amt) {
+            let mut trail = ~"";
+            for _ in range(0, cur.len() - i - 1) {
+                trail.push_str("../");
+            }
+            write!(fmt.buf, "<a href='{}index.html'>{}</a>::",
+                   trail, component.as_slice());
+        }
+        write!(fmt.buf, "<a class='{}' href=''>{}</a></h1>",
+               shortty(it.item), it.item.name.get_ref().as_slice());
+
+        match it.item.inner {
+            clean::ModuleItem(ref m) => item_module(fmt.buf, it.cx,
+                                                    it.item, m.items),
+            clean::FunctionItem(ref f) => item_function(fmt.buf, it.item, f),
+            clean::TraitItem(ref t) => item_trait(fmt.buf, it.item, t),
+            clean::StructItem(ref s) => item_struct(fmt.buf, it.item, s),
+            clean::EnumItem(ref e) => item_enum(fmt.buf, it.item, e),
+            clean::TypedefItem(ref t) => item_typedef(fmt.buf, it.item, t),
+            _ => {}
+        }
+    }
+}
+
+fn item_path(item: &clean::Item) -> ~str {
+    match item.inner {
+        clean::ModuleItem(*) => *item.name.get_ref() + "/index.html",
+        _ => shortty(item) + "." + *item.name.get_ref() + ".html"
+    }
+}
+
+fn full_path(cx: &Context, item: &clean::Item) -> ~str {
+    let mut s = cx.current.connect("::");
+    s.push_str("::");
+    s.push_str(item.name.get_ref().as_slice());
+    return s;
+}
+
+fn blank<'a>(s: Option<&'a str>) -> &'a str {
+    match s {
+        Some(s) => s,
+        None => ""
+    }
+}
+
+fn shorter<'a>(s: Option<&'a str>) -> &'a str {
+    match s {
+        Some(s) => match s.find_str("\n\n") {
+            Some(pos) => s.slice_to(pos),
+            None => s,
+        },
+        None => ""
+    }
+}
+
+fn document(w: &mut io::Writer, item: &clean::Item) {
+    match item.doc_value() {
+        Some(s) => {
+            write!(w, "<div class='docblock'>{}</div>", Markdown(s));
+        }
+        None => {}
+    }
+}
+
+fn item_module(w: &mut io::Writer, cx: &Context,
+               item: &clean::Item, items: &[clean::Item]) {
+    document(w, item);
+    let mut indices = vec::from_fn(items.len(), |i| i);
+
+    fn lt(i1: &clean::Item, i2: &clean::Item) -> bool {
+        if shortty(i1) == shortty(i2) {
+            return i1.name < i2.name;
+        }
+        match (&i1.inner, &i2.inner) {
+            (&clean::ViewItemItem(*), _) => true,
+            (_, &clean::ViewItemItem(*)) => false,
+            (&clean::ModuleItem(*), _) => true,
+            (_, &clean::ModuleItem(*)) => false,
+            (&clean::StructItem(*), _) => true,
+            (_, &clean::StructItem(*)) => false,
+            (&clean::EnumItem(*), _) => true,
+            (_, &clean::EnumItem(*)) => false,
+            (&clean::StaticItem(*), _) => true,
+            (_, &clean::StaticItem(*)) => false,
+            (&clean::TraitItem(*), _) => true,
+            (_, &clean::TraitItem(*)) => false,
+            (&clean::FunctionItem(*), _) => true,
+            (_, &clean::FunctionItem(*)) => false,
+            (&clean::TypedefItem(*), _) => true,
+            (_, &clean::TypedefItem(*)) => false,
+            _ => false,
+        }
+    }
+
+    do sort::quick_sort(indices) |&i1, &i2| {
+        lt(&items[i1], &items[i2])
+    }
+
+    let mut curty = "";
+    for &idx in indices.iter() {
+        let myitem = &items[idx];
+        if myitem.name.is_none() { loop }
+
+        let myty = shortty(myitem);
+        if myty != curty {
+            if curty != "" {
+                write!(w, "</table>");
+            }
+            curty = myty;
+            write!(w, "<h2>{}</h2>\n<table>", match myitem.inner {
+                clean::ModuleItem(*)      => "Modules",
+                clean::StructItem(*)      => "Structs",
+                clean::EnumItem(*)        => "Enums",
+                clean::FunctionItem(*)    => "Functions",
+                clean::TypedefItem(*)     => "Type Definitions",
+                clean::StaticItem(*)      => "Statics",
+                clean::TraitItem(*)       => "Traits",
+                clean::ImplItem(*)        => "Implementations",
+                clean::ViewItemItem(*)    => "Reexports",
+                clean::TyMethodItem(*)    => "Type Methods",
+                clean::MethodItem(*)      => "Methods",
+                clean::StructFieldItem(*) => "Struct Fields",
+                clean::VariantItem(*)     => "Variants",
+            });
+        }
+
+        match myitem.inner {
+            clean::StaticItem(ref s) => {
+                struct Initializer<'self>(&'self str);
+                impl<'self> fmt::Default for Initializer<'self> {
+                    fn fmt(s: &Initializer<'self>, f: &mut fmt::Formatter) {
+                        let tag = if s.contains("\n") { "pre" } else { "code" };
+                        write!(f.buf, "<{tag}>{}</{tag}>",
+                               s.as_slice(), tag=tag);
+                    }
+                }
+
+                write!(w, "
+                    <tr>
+                        <td><code>{}: {} = </code>{}</td>
+                        <td class='docblock'>{}&nbsp;</td>
+                    </tr>
+                ",
+                *myitem.name.get_ref(),
+                s.type_,
+                Initializer(s.expr),
+                Markdown(blank(myitem.doc_value())));
+            }
+
+            _ => {
+                write!(w, "
+                    <tr>
+                        <td><a class='{class}' href='{href}'
+                               title='{title}'>{}</a></td>
+                        <td class='docblock short'>{}</td>
+                    </tr>
+                ",
+                *myitem.name.get_ref(),
+                Markdown(shorter(myitem.doc_value())),
+                class = shortty(myitem),
+                href = item_path(myitem),
+                title = full_path(cx, myitem));
+            }
+        }
+    }
+    write!(w, "</table>");
+}
+
+fn item_function(w: &mut io::Writer, it: &clean::Item, f: &clean::Function) {
+    write!(w, "<pre class='fn'>{vis}fn {name}{generics}{decl}</pre>",
+           vis = VisSpace(it.visibility),
+           name = it.name.get_ref().as_slice(),
+           generics = f.generics,
+           decl = f.decl);
+    document(w, it);
+}
+
+fn item_trait(w: &mut io::Writer, it: &clean::Item, t: &clean::Trait) {
+    let mut parents = ~"";
+    if t.parents.len() > 0 {
+        parents.push_str(": ");
+        for (i, p) in t.parents.iter().enumerate() {
+            if i > 0 { parents.push_str(" + "); }
+            parents.push_str(format!("{}", *p));
+        }
+    }
+
+    // Output the trait definition
+    write!(w, "<pre class='trait'>{}trait {}{}{} ",
+           VisSpace(it.visibility),
+           it.name.get_ref().as_slice(),
+           t.generics,
+           parents);
+    let required = t.methods.iter().filter(|m| m.is_req()).to_owned_vec();
+    let provided = t.methods.iter().filter(|m| !m.is_req()).to_owned_vec();
+
+    if t.methods.len() == 0 {
+        write!(w, "\\{ \\}");
+    } else {
+        write!(w, "\\{\n");
+        for m in required.iter() {
+            write!(w, "    ");
+            render_method(w, m.item(), true);
+            write!(w, ";\n");
+        }
+        if required.len() > 0 && provided.len() > 0 {
+            w.write("\n".as_bytes());
+        }
+        for m in provided.iter() {
+            write!(w, "    ");
+            render_method(w, m.item(), true);
+            write!(w, " \\{ ... \\}\n");
+        }
+        write!(w, "\\}");
+    }
+    write!(w, "</pre>");
+
+    // Trait documentation
+    document(w, it);
+
+    fn meth(w: &mut io::Writer, m: &clean::TraitMethod) {
+        write!(w, "<h3 id='fn.{}' class='method'><code>",
+               *m.item().name.get_ref());
+        render_method(w, m.item(), false);
+        write!(w, "</code></h3>");
+        document(w, m.item());
+    }
+
+    // Output the documentation for each function individually
+    if required.len() > 0 {
+        write!(w, "
+            <h2 id='required-methods'>Required Methods</h2>
+            <div class='methods'>
+        ");
+        for m in required.iter() {
+            meth(w, *m);
+        }
+        write!(w, "</div>");
+    }
+    if provided.len() > 0 {
+        write!(w, "
+            <h2 id='provided-methods'>Provided Methods</h2>
+            <div class='methods'>
+        ");
+        for m in provided.iter() {
+            meth(w, *m);
+        }
+        write!(w, "</div>");
+    }
+
+    do local_data::get(cache_key) |cache| {
+        do cache.unwrap().read |cache| {
+            match cache.implementors.find(&it.id) {
+                Some(implementors) => {
+                    write!(w, "
+                        <h2 id='implementors'>Implementors</h2>
+                        <ul class='item-list'>
+                    ");
+                    for i in implementors.iter() {
+                        match *i {
+                            PathType(ref ty) => {
+                                write!(w, "<li><code>{}</code></li>", *ty);
+                            }
+                            OtherType(ref generics, ref trait_, ref for_) => {
+                                write!(w, "<li><code>impl{} {} for {}</code></li>",
+                                       *generics, *trait_, *for_);
+                            }
+                        }
+                    }
+                    write!(w, "</ul>");
+                }
+                None => {}
+            }
+        }
+    }
+}
+
+fn render_method(w: &mut io::Writer, meth: &clean::Item, withlink: bool) {
+    fn fun(w: &mut io::Writer, it: &clean::Item, purity: ast::purity,
+           g: &clean::Generics, selfty: &clean::SelfTy, d: &clean::FnDecl,
+           withlink: bool) {
+        write!(w, "{}fn {withlink, select,
+                            true{<a href='\\#fn.{name}'>{name}</a>}
+                            other{{name}}
+                        }{generics}{decl}",
+               match purity {
+                   ast::unsafe_fn => "unsafe ",
+                   _ => "",
+               },
+               name = it.name.get_ref().as_slice(),
+               generics = *g,
+               decl = Method(selfty, d),
+               withlink = if withlink {"true"} else {"false"});
+    }
+    match meth.inner {
+        clean::TyMethodItem(ref m) => {
+            fun(w, meth, m.purity, &m.generics, &m.self_, &m.decl, withlink);
+        }
+        clean::MethodItem(ref m) => {
+            fun(w, meth, m.purity, &m.generics, &m.self_, &m.decl, withlink);
+        }
+        _ => unreachable!()
+    }
+}
+
+fn item_struct(w: &mut io::Writer, it: &clean::Item, s: &clean::Struct) {
+    write!(w, "<pre class='struct'>");
+    render_struct(w, it, Some(&s.generics), s.struct_type, s.fields, "");
+    write!(w, "</pre>");
+
+    document(w, it);
+    render_methods(w, it);
+}
+
+fn item_enum(w: &mut io::Writer, it: &clean::Item, e: &clean::Enum) {
+    write!(w, "<pre class='enum'>{}enum {}{}",
+           VisSpace(it.visibility),
+           it.name.get_ref().as_slice(),
+           e.generics);
+    if e.variants.len() == 0 {
+        write!(w, " \\{\\}");
+    } else {
+        write!(w, " \\{\n");
+        for v in e.variants.iter() {
+            let name = v.name.get_ref().as_slice();
+            match v.inner {
+                clean::VariantItem(ref var) => {
+                    match var.kind {
+                        clean::CLikeVariant => write!(w, "    {},\n", name),
+                        clean::TupleVariant(ref tys) => {
+                            write!(w, "    {}(", name);
+                            for (i, ty) in tys.iter().enumerate() {
+                                if i > 0 { write!(w, ", ") }
+                                write!(w, "{}", *ty);
+                            }
+                            write!(w, "),\n");
+                        }
+                        clean::StructVariant(ref s) => {
+                            render_struct(w, v, None, s.struct_type, s.fields,
+                                          "    ");
+                        }
+                    }
+                }
+                _ => unreachable!()
+            }
+        }
+        write!(w, "\\}");
+    }
+    write!(w, "</pre>");
+
+    document(w, it);
+    render_methods(w, it);
+}
+
+fn render_struct(w: &mut io::Writer, it: &clean::Item,
+                 g: Option<&clean::Generics>,
+                 ty: doctree::StructType,
+                 fields: &[clean::Item],
+                 tab: &str) {
+    write!(w, "{}struct {}",
+           VisSpace(it.visibility),
+           it.name.get_ref().as_slice());
+    match g {
+        Some(g) => write!(w, "{}", *g),
+        None => {}
+    }
+    match ty {
+        doctree::Plain => {
+            write!(w, " \\{\n");
+            for field in fields.iter() {
+                match field.inner {
+                    clean::StructFieldItem(ref ty) => {
+                        write!(w, "    {}{}: {},\n{}",
+                               VisSpace(field.visibility),
+                               field.name.get_ref().as_slice(),
+                               ty.type_,
+                               tab);
+                    }
+                    _ => unreachable!()
+                }
+            }
+            write!(w, "\\}");
+        }
+        doctree::Tuple | doctree::Newtype => {
+            write!(w, "(");
+            for (i, field) in fields.iter().enumerate() {
+                if i > 0 { write!(w, ", ") }
+                match field.inner {
+                    clean::StructFieldItem(ref field) => {
+                        write!(w, "{}", field.type_);
+                    }
+                    _ => unreachable!()
+                }
+            }
+            write!(w, ");");
+        }
+        doctree::Unit => { write!(w, ";"); }
+    }
+}
+
+fn render_methods(w: &mut io::Writer, it: &clean::Item) {
+    do local_data::get(cache_key) |cache| {
+        let cache = cache.unwrap();
+        do cache.read |c| {
+            match c.impls.find(&it.id) {
+                Some(v) => {
+                    let mut non_trait = v.iter().filter(|i| i.trait_.is_none());
+                    let non_trait = non_trait.to_owned_vec();
+                    let mut traits = v.iter().filter(|i| i.trait_.is_some());
+                    let traits = traits.to_owned_vec();
+
+                    if non_trait.len() > 0 {
+                        write!(w, "<h2 id='methods'>Methods</h2>");
+                        for &i in non_trait.iter() {
+                            render_impl(w, i);
+                        }
+                    }
+                    if traits.len() > 0 {
+                        write!(w, "<h2 id='implementations'>Trait \
+                                   Implementations</h2>");
+                        for &i in traits.iter() {
+                            render_impl(w, i);
+                        }
+                    }
+                }
+                None => {}
+            }
+        }
+    }
+}
+
+fn render_impl(w: &mut io::Writer, i: &clean::Impl) {
+    write!(w, "<h3 class='impl'><code>impl{} ", i.generics);
+    let trait_id = match i.trait_ {
+        Some(ref ty) => {
+            write!(w, "{} for ", *ty);
+            match *ty {
+                clean::ResolvedPath { id, _ } => Some(id),
+                _ => None,
+            }
+        }
+        None => None
+    };
+    write!(w, "{}</code></h3>", i.for_);
+    write!(w, "<div class='methods'>");
+    for meth in i.methods.iter() {
+        write!(w, "<h4 id='fn.{}' class='method'><code>",
+               *meth.name.get_ref());
+        render_method(w, meth, false);
+        write!(w, "</code></h4>\n");
+        match meth.doc_value() {
+            Some(s) => {
+                write!(w, "<div class='docblock'>{}</div>", Markdown(s));
+                loop
+            }
+            None => {}
+        }
+
+        // No documentation? Attempt to slurp in the trait's documentation
+        let trait_id = match trait_id { Some(id) => id, None => loop };
+        do local_data::get(cache_key) |cache| {
+            do cache.unwrap().read |cache| {
+                let name = meth.name.get_ref().as_slice();
+                match cache.traits.find(&trait_id) {
+                    Some(m) => {
+                        match m.find_equiv(&name) {
+                            Some(s) => {
+                                write!(w, "<div class='docblock'>{}</div>",
+                                       Markdown(s.as_slice()));
+                            }
+                            None => {}
+                        }
+                    }
+                    None => {}
+                }
+            }
+        }
+    }
+    write!(w, "</div>");
+}
+
+fn item_typedef(w: &mut io::Writer, it: &clean::Item, t: &clean::Typedef) {
+    write!(w, "<pre class='typedef'>type {}{} = {};</pre>",
+           it.name.get_ref().as_slice(),
+           t.generics,
+           t.type_);
+
+    document(w, it);
+}
+
+impl<'self> fmt::Default for Sidebar<'self> {
+    fn fmt(s: &Sidebar<'self>, fmt: &mut fmt::Formatter) {
+        let cx = s.cx;
+        let it = s.item;
+        write!(fmt.buf, "<p class='location'>");
+        let len = cx.current.len() - if it.is_mod() {1} else {0};
+        for (i, name) in cx.current.iter().take(len).enumerate() {
+            if i > 0 { write!(fmt.buf, "&\\#8203;::") }
+            write!(fmt.buf, "<a href='{}index.html'>{}</a>",
+                   cx.root_path.slice_to((cx.current.len() - i - 1) * 3), *name);
+        }
+        write!(fmt.buf, "</p>");
+
+        fn block(w: &mut io::Writer, short: &str, longty: &str,
+                 cur: &clean::Item, cx: &Context) {
+            let items = match cx.sidebar.find_equiv(&short) {
+                Some(items) => items.as_slice(),
+                None => return
+            };
+            write!(w, "<div class='block {}'><h2>{}</h2>", short, longty);
+            for item in items.iter() {
+                let class = if cur.name.get_ref() == item &&
+                               short == shortty(cur) { "current" } else { "" };
+                write!(w, "<a class='{ty} {class}' href='{curty, select,
+                                mod{../}
+                                other{}
+                           }{ty, select,
+                                mod{{name}/index.html}
+                                other{#.{name}.html}
+                           }'>{name}</a><br/>",
+                       ty = short,
+                       class = class,
+                       curty = shortty(cur),
+                       name = item.as_slice());
+            }
+            write!(w, "</div>");
+        }
+
+        block(fmt.buf, "mod", "Modules", it, cx);
+        block(fmt.buf, "struct", "Structs", it, cx);
+        block(fmt.buf, "enum", "Enums", it, cx);
+        block(fmt.buf, "trait", "Traits", it, cx);
+        block(fmt.buf, "fn", "Functions", it, cx);
+    }
+}
+
+fn build_sidebar(m: &clean::Module) -> HashMap<~str, ~[~str]> {
+    let mut map = HashMap::new();
+    for item in m.items.iter() {
+        let short = shortty(item);
+        let myname = match item.name {
+            None => loop,
+            Some(ref s) => s.to_owned(),
+        };
+        let v = map.find_or_insert_with(short.to_owned(), |_| ~[]);
+        v.push(myname);
+    }
+
+    for (_, items) in map.mut_iter() {
+        sort::quick_sort(*items, |i1, i2| i1 < i2);
+    }
+    return map;
+}
diff --git a/src/rustdoc_ng/html/static/jquery-2.0.3.min.js b/src/rustdoc_ng/html/static/jquery-2.0.3.min.js
new file mode 100644
index 00000000000..2be209dd223
--- /dev/null
+++ b/src/rustdoc_ng/html/static/jquery-2.0.3.min.js
@@ -0,0 +1,6 @@
+/*! jQuery v2.0.3 | (c) 2005, 2013 jQuery Foundation, Inc. | jquery.org/license
+//@ sourceMappingURL=jquery-2.0.3.min.map
+*/
+(function(e,undefined){var t,n,r=typeof undefined,i=e.location,o=e.document,s=o.documentElement,a=e.jQuery,u=e.$,l={},c=[],p="2.0.3",f=c.concat,h=c.push,d=c.slice,g=c.indexOf,m=l.toString,y=l.hasOwnProperty,v=p.trim,x=function(e,n){return new x.fn.init(e,n,t)},b=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,w=/\S+/g,T=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,C=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,k=/^-ms-/,N=/-([\da-z])/gi,E=function(e,t){return t.toUpperCase()},S=function(){o.removeEventListener("DOMContentLoaded",S,!1),e.removeEventListener("load",S,!1),x.ready()};x.fn=x.prototype={jquery:p,constructor:x,init:function(e,t,n){var r,i;if(!e)return this;if("string"==typeof e){if(r="<"===e.charAt(0)&&">"===e.charAt(e.length-1)&&e.length>=3?[null,e,null]:T.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof x?t[0]:t,x.merge(this,x.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:o,!0)),C.test(r[1])&&x.isPlainObject(t))for(r in t)x.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return i=o.getElementById(r[2]),i&&i.parentNode&&(this.length=1,this[0]=i),this.context=o,this.selector=e,this}return e.nodeType?(this.context=this[0]=e,this.length=1,this):x.isFunction(e)?n.ready(e):(e.selector!==undefined&&(this.selector=e.selector,this.context=e.context),x.makeArray(e,this))},selector:"",length:0,toArray:function(){return d.call(this)},get:function(e){return null==e?this.toArray():0>e?this[this.length+e]:this[e]},pushStack:function(e){var t=x.merge(this.constructor(),e);return t.prevObject=this,t.context=this.context,t},each:function(e,t){return x.each(this,e,t)},ready:function(e){return x.ready.promise().done(e),this},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(0>e?t:0);return this.pushStack(n>=0&&t>n?[this[n]]:[])},map:function(e){return this.pushStack(x.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:h,sort:[].sort,splice:[].splice},x.fn.init.prototype=x.fn,x.extend=x.fn.extend=function(){var e,t,n,r,i,o,s=arguments[0]||{},a=1,u=arguments.length,l=!1;for("boolean"==typeof s&&(l=s,s=arguments[1]||{},a=2),"object"==typeof s||x.isFunction(s)||(s={}),u===a&&(s=this,--a);u>a;a++)if(null!=(e=arguments[a]))for(t in e)n=s[t],r=e[t],s!==r&&(l&&r&&(x.isPlainObject(r)||(i=x.isArray(r)))?(i?(i=!1,o=n&&x.isArray(n)?n:[]):o=n&&x.isPlainObject(n)?n:{},s[t]=x.extend(l,o,r)):r!==undefined&&(s[t]=r));return s},x.extend({expando:"jQuery"+(p+Math.random()).replace(/\D/g,""),noConflict:function(t){return e.$===x&&(e.$=u),t&&e.jQuery===x&&(e.jQuery=a),x},isReady:!1,readyWait:1,holdReady:function(e){e?x.readyWait++:x.ready(!0)},ready:function(e){(e===!0?--x.readyWait:x.isReady)||(x.isReady=!0,e!==!0&&--x.readyWait>0||(n.resolveWith(o,[x]),x.fn.trigger&&x(o).trigger("ready").off("ready")))},isFunction:function(e){return"function"===x.type(e)},isArray:Array.isArray,isWindow:function(e){return null!=e&&e===e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?l[m.call(e)]||"object":typeof e},isPlainObject:function(e){if("object"!==x.type(e)||e.nodeType||x.isWindow(e))return!1;try{if(e.constructor&&!y.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}return!0},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw Error(e)},parseHTML:function(e,t,n){if(!e||"string"!=typeof e)return null;"boolean"==typeof t&&(n=t,t=!1),t=t||o;var r=C.exec(e),i=!n&&[];return r?[t.createElement(r[1])]:(r=x.buildFragment([e],t,i),i&&x(i).remove(),x.merge([],r.childNodes))},parseJSON:JSON.parse,parseXML:function(e){var t,n;if(!e||"string"!=typeof e)return null;try{n=new DOMParser,t=n.parseFromString(e,"text/xml")}catch(r){t=undefined}return(!t||t.getElementsByTagName("parsererror").length)&&x.error("Invalid XML: "+e),t},noop:function(){},globalEval:function(e){var t,n=eval;e=x.trim(e),e&&(1===e.indexOf("use strict")?(t=o.createElement("script"),t.text=e,o.head.appendChild(t).parentNode.removeChild(t)):n(e))},camelCase:function(e){return e.replace(k,"ms-").replace(N,E)},nodeName:function(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()},each:function(e,t,n){var r,i=0,o=e.length,s=j(e);if(n){if(s){for(;o>i;i++)if(r=t.apply(e[i],n),r===!1)break}else for(i in e)if(r=t.apply(e[i],n),r===!1)break}else if(s){for(;o>i;i++)if(r=t.call(e[i],i,e[i]),r===!1)break}else for(i in e)if(r=t.call(e[i],i,e[i]),r===!1)break;return e},trim:function(e){return null==e?"":v.call(e)},makeArray:function(e,t){var n=t||[];return null!=e&&(j(Object(e))?x.merge(n,"string"==typeof e?[e]:e):h.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:g.call(t,e,n)},merge:function(e,t){var n=t.length,r=e.length,i=0;if("number"==typeof n)for(;n>i;i++)e[r++]=t[i];else while(t[i]!==undefined)e[r++]=t[i++];return e.length=r,e},grep:function(e,t,n){var r,i=[],o=0,s=e.length;for(n=!!n;s>o;o++)r=!!t(e[o],o),n!==r&&i.push(e[o]);return i},map:function(e,t,n){var r,i=0,o=e.length,s=j(e),a=[];if(s)for(;o>i;i++)r=t(e[i],i,n),null!=r&&(a[a.length]=r);else for(i in e)r=t(e[i],i,n),null!=r&&(a[a.length]=r);return f.apply([],a)},guid:1,proxy:function(e,t){var n,r,i;return"string"==typeof t&&(n=e[t],t=e,e=n),x.isFunction(e)?(r=d.call(arguments,2),i=function(){return e.apply(t||this,r.concat(d.call(arguments)))},i.guid=e.guid=e.guid||x.guid++,i):undefined},access:function(e,t,n,r,i,o,s){var a=0,u=e.length,l=null==n;if("object"===x.type(n)){i=!0;for(a in n)x.access(e,t,a,n[a],!0,o,s)}else if(r!==undefined&&(i=!0,x.isFunction(r)||(s=!0),l&&(s?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(x(e),n)})),t))for(;u>a;a++)t(e[a],n,s?r:r.call(e[a],a,t(e[a],n)));return i?e:l?t.call(e):u?t(e[0],n):o},now:Date.now,swap:function(e,t,n,r){var i,o,s={};for(o in t)s[o]=e.style[o],e.style[o]=t[o];i=n.apply(e,r||[]);for(o in t)e.style[o]=s[o];return i}}),x.ready.promise=function(t){return n||(n=x.Deferred(),"complete"===o.readyState?setTimeout(x.ready):(o.addEventListener("DOMContentLoaded",S,!1),e.addEventListener("load",S,!1))),n.promise(t)},x.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(e,t){l["[object "+t+"]"]=t.toLowerCase()});function j(e){var t=e.length,n=x.type(e);return x.isWindow(e)?!1:1===e.nodeType&&t?!0:"array"===n||"function"!==n&&(0===t||"number"==typeof t&&t>0&&t-1 in e)}t=x(o),function(e,undefined){var t,n,r,i,o,s,a,u,l,c,p,f,h,d,g,m,y,v="sizzle"+-new Date,b=e.document,w=0,T=0,C=st(),k=st(),N=st(),E=!1,S=function(e,t){return e===t?(E=!0,0):0},j=typeof undefined,D=1<<31,A={}.hasOwnProperty,L=[],q=L.pop,H=L.push,O=L.push,F=L.slice,P=L.indexOf||function(e){var t=0,n=this.length;for(;n>t;t++)if(this[t]===e)return t;return-1},R="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",M="[\\x20\\t\\r\\n\\f]",W="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",$=W.replace("w","w#"),B="\\["+M+"*("+W+")"+M+"*(?:([*^$|!~]?=)"+M+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+$+")|)|)"+M+"*\\]",I=":("+W+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+B.replace(3,8)+")*)|.*)\\)|)",z=RegExp("^"+M+"+|((?:^|[^\\\\])(?:\\\\.)*)"+M+"+$","g"),_=RegExp("^"+M+"*,"+M+"*"),X=RegExp("^"+M+"*([>+~]|"+M+")"+M+"*"),U=RegExp(M+"*[+~]"),Y=RegExp("="+M+"*([^\\]'\"]*)"+M+"*\\]","g"),V=RegExp(I),G=RegExp("^"+$+"$"),J={ID:RegExp("^#("+W+")"),CLASS:RegExp("^\\.("+W+")"),TAG:RegExp("^("+W.replace("w","w*")+")"),ATTR:RegExp("^"+B),PSEUDO:RegExp("^"+I),CHILD:RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:RegExp("^(?:"+R+")$","i"),needsContext:RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Q=/^[^{]+\{\s*\[native \w/,K=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,Z=/^(?:input|select|textarea|button)$/i,et=/^h\d$/i,tt=/'|\\/g,nt=RegExp("\\\\([\\da-f]{1,6}"+M+"?|("+M+")|.)","ig"),rt=function(e,t,n){var r="0x"+t-65536;return r!==r||n?t:0>r?String.fromCharCode(r+65536):String.fromCharCode(55296|r>>10,56320|1023&r)};try{O.apply(L=F.call(b.childNodes),b.childNodes),L[b.childNodes.length].nodeType}catch(it){O={apply:L.length?function(e,t){H.apply(e,F.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function ot(e,t,r,i){var o,s,a,u,l,f,g,m,x,w;if((t?t.ownerDocument||t:b)!==p&&c(t),t=t||p,r=r||[],!e||"string"!=typeof e)return r;if(1!==(u=t.nodeType)&&9!==u)return[];if(h&&!i){if(o=K.exec(e))if(a=o[1]){if(9===u){if(s=t.getElementById(a),!s||!s.parentNode)return r;if(s.id===a)return r.push(s),r}else if(t.ownerDocument&&(s=t.ownerDocument.getElementById(a))&&y(t,s)&&s.id===a)return r.push(s),r}else{if(o[2])return O.apply(r,t.getElementsByTagName(e)),r;if((a=o[3])&&n.getElementsByClassName&&t.getElementsByClassName)return O.apply(r,t.getElementsByClassName(a)),r}if(n.qsa&&(!d||!d.test(e))){if(m=g=v,x=t,w=9===u&&e,1===u&&"object"!==t.nodeName.toLowerCase()){f=gt(e),(g=t.getAttribute("id"))?m=g.replace(tt,"\\$&"):t.setAttribute("id",m),m="[id='"+m+"'] ",l=f.length;while(l--)f[l]=m+mt(f[l]);x=U.test(e)&&t.parentNode||t,w=f.join(",")}if(w)try{return O.apply(r,x.querySelectorAll(w)),r}catch(T){}finally{g||t.removeAttribute("id")}}}return kt(e.replace(z,"$1"),t,r,i)}function st(){var e=[];function t(n,r){return e.push(n+=" ")>i.cacheLength&&delete t[e.shift()],t[n]=r}return t}function at(e){return e[v]=!0,e}function ut(e){var t=p.createElement("div");try{return!!e(t)}catch(n){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function lt(e,t){var n=e.split("|"),r=e.length;while(r--)i.attrHandle[n[r]]=t}function ct(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&(~t.sourceIndex||D)-(~e.sourceIndex||D);if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function pt(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function ft(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function ht(e){return at(function(t){return t=+t,at(function(n,r){var i,o=e([],n.length,t),s=o.length;while(s--)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))})})}s=ot.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return t?"HTML"!==t.nodeName:!1},n=ot.support={},c=ot.setDocument=function(e){var t=e?e.ownerDocument||e:b,r=t.defaultView;return t!==p&&9===t.nodeType&&t.documentElement?(p=t,f=t.documentElement,h=!s(t),r&&r.attachEvent&&r!==r.top&&r.attachEvent("onbeforeunload",function(){c()}),n.attributes=ut(function(e){return e.className="i",!e.getAttribute("className")}),n.getElementsByTagName=ut(function(e){return e.appendChild(t.createComment("")),!e.getElementsByTagName("*").length}),n.getElementsByClassName=ut(function(e){return e.innerHTML="<div class='a'></div><div class='a i'></div>",e.firstChild.className="i",2===e.getElementsByClassName("i").length}),n.getById=ut(function(e){return f.appendChild(e).id=v,!t.getElementsByName||!t.getElementsByName(v).length}),n.getById?(i.find.ID=function(e,t){if(typeof t.getElementById!==j&&h){var n=t.getElementById(e);return n&&n.parentNode?[n]:[]}},i.filter.ID=function(e){var t=e.replace(nt,rt);return function(e){return e.getAttribute("id")===t}}):(delete i.find.ID,i.filter.ID=function(e){var t=e.replace(nt,rt);return function(e){var n=typeof e.getAttributeNode!==j&&e.getAttributeNode("id");return n&&n.value===t}}),i.find.TAG=n.getElementsByTagName?function(e,t){return typeof t.getElementsByTagName!==j?t.getElementsByTagName(e):undefined}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},i.find.CLASS=n.getElementsByClassName&&function(e,t){return typeof t.getElementsByClassName!==j&&h?t.getElementsByClassName(e):undefined},g=[],d=[],(n.qsa=Q.test(t.querySelectorAll))&&(ut(function(e){e.innerHTML="<select><option selected=''></option></select>",e.querySelectorAll("[selected]").length||d.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll(":checked").length||d.push(":checked")}),ut(function(e){var n=t.createElement("input");n.setAttribute("type","hidden"),e.appendChild(n).setAttribute("t",""),e.querySelectorAll("[t^='']").length&&d.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll(":enabled").length||d.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),d.push(",.*:")})),(n.matchesSelector=Q.test(m=f.webkitMatchesSelector||f.mozMatchesSelector||f.oMatchesSelector||f.msMatchesSelector))&&ut(function(e){n.disconnectedMatch=m.call(e,"div"),m.call(e,"[s!='']:x"),g.push("!=",I)}),d=d.length&&RegExp(d.join("|")),g=g.length&&RegExp(g.join("|")),y=Q.test(f.contains)||f.compareDocumentPosition?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},S=f.compareDocumentPosition?function(e,r){if(e===r)return E=!0,0;var i=r.compareDocumentPosition&&e.compareDocumentPosition&&e.compareDocumentPosition(r);return i?1&i||!n.sortDetached&&r.compareDocumentPosition(e)===i?e===t||y(b,e)?-1:r===t||y(b,r)?1:l?P.call(l,e)-P.call(l,r):0:4&i?-1:1:e.compareDocumentPosition?-1:1}:function(e,n){var r,i=0,o=e.parentNode,s=n.parentNode,a=[e],u=[n];if(e===n)return E=!0,0;if(!o||!s)return e===t?-1:n===t?1:o?-1:s?1:l?P.call(l,e)-P.call(l,n):0;if(o===s)return ct(e,n);r=e;while(r=r.parentNode)a.unshift(r);r=n;while(r=r.parentNode)u.unshift(r);while(a[i]===u[i])i++;return i?ct(a[i],u[i]):a[i]===b?-1:u[i]===b?1:0},t):p},ot.matches=function(e,t){return ot(e,null,null,t)},ot.matchesSelector=function(e,t){if((e.ownerDocument||e)!==p&&c(e),t=t.replace(Y,"='$1']"),!(!n.matchesSelector||!h||g&&g.test(t)||d&&d.test(t)))try{var r=m.call(e,t);if(r||n.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(i){}return ot(t,p,null,[e]).length>0},ot.contains=function(e,t){return(e.ownerDocument||e)!==p&&c(e),y(e,t)},ot.attr=function(e,t){(e.ownerDocument||e)!==p&&c(e);var r=i.attrHandle[t.toLowerCase()],o=r&&A.call(i.attrHandle,t.toLowerCase())?r(e,t,!h):undefined;return o===undefined?n.attributes||!h?e.getAttribute(t):(o=e.getAttributeNode(t))&&o.specified?o.value:null:o},ot.error=function(e){throw Error("Syntax error, unrecognized expression: "+e)},ot.uniqueSort=function(e){var t,r=[],i=0,o=0;if(E=!n.detectDuplicates,l=!n.sortStable&&e.slice(0),e.sort(S),E){while(t=e[o++])t===e[o]&&(i=r.push(o));while(i--)e.splice(r[i],1)}return e},o=ot.getText=function(e){var t,n="",r=0,i=e.nodeType;if(i){if(1===i||9===i||11===i){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=o(e)}else if(3===i||4===i)return e.nodeValue}else for(;t=e[r];r++)n+=o(t);return n},i=ot.selectors={cacheLength:50,createPseudo:at,match:J,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(nt,rt),e[3]=(e[4]||e[5]||"").replace(nt,rt),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ot.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ot.error(e[0]),e},PSEUDO:function(e){var t,n=!e[5]&&e[2];return J.CHILD.test(e[0])?null:(e[3]&&e[4]!==undefined?e[2]=e[4]:n&&V.test(n)&&(t=gt(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(nt,rt).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=C[e+" "];return t||(t=RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&C(e,function(e){return t.test("string"==typeof e.className&&e.className||typeof e.getAttribute!==j&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r){var i=ot.attr(r,e);return null==i?"!="===t:t?(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i+" ").indexOf(n)>-1:"|="===t?i===n||i.slice(0,n.length+1)===n+"-":!1):!0}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,p,f,h,d,g=o!==s?"nextSibling":"previousSibling",m=t.parentNode,y=a&&t.nodeName.toLowerCase(),x=!u&&!a;if(m){if(o){while(g){p=t;while(p=p[g])if(a?p.nodeName.toLowerCase()===y:1===p.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&x){c=m[v]||(m[v]={}),l=c[e]||[],h=l[0]===w&&l[1],f=l[0]===w&&l[2],p=h&&m.childNodes[h];while(p=++h&&p&&p[g]||(f=h=0)||d.pop())if(1===p.nodeType&&++f&&p===t){c[e]=[w,h,f];break}}else if(x&&(l=(t[v]||(t[v]={}))[e])&&l[0]===w)f=l[1];else while(p=++h&&p&&p[g]||(f=h=0)||d.pop())if((a?p.nodeName.toLowerCase()===y:1===p.nodeType)&&++f&&(x&&((p[v]||(p[v]={}))[e]=[w,f]),p===t))break;return f-=i,f===r||0===f%r&&f/r>=0}}},PSEUDO:function(e,t){var n,r=i.pseudos[e]||i.setFilters[e.toLowerCase()]||ot.error("unsupported pseudo: "+e);return r[v]?r(t):r.length>1?(n=[e,e,"",t],i.setFilters.hasOwnProperty(e.toLowerCase())?at(function(e,n){var i,o=r(e,t),s=o.length;while(s--)i=P.call(e,o[s]),e[i]=!(n[i]=o[s])}):function(e){return r(e,0,n)}):r}},pseudos:{not:at(function(e){var t=[],n=[],r=a(e.replace(z,"$1"));return r[v]?at(function(e,t,n,i){var o,s=r(e,null,i,[]),a=e.length;while(a--)(o=s[a])&&(e[a]=!(t[a]=o))}):function(e,i,o){return t[0]=e,r(t,null,o,n),!n.pop()}}),has:at(function(e){return function(t){return ot(e,t).length>0}}),contains:at(function(e){return function(t){return(t.textContent||t.innerText||o(t)).indexOf(e)>-1}}),lang:at(function(e){return G.test(e||"")||ot.error("unsupported lang: "+e),e=e.replace(nt,rt).toLowerCase(),function(t){var n;do if(n=h?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===f},focus:function(e){return e===p.activeElement&&(!p.hasFocus||p.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:function(e){return e.disabled===!1},disabled:function(e){return e.disabled===!0},checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeName>"@"||3===e.nodeType||4===e.nodeType)return!1;return!0},parent:function(e){return!i.pseudos.empty(e)},header:function(e){return et.test(e.nodeName)},input:function(e){return Z.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||t.toLowerCase()===e.type)},first:ht(function(){return[0]}),last:ht(function(e,t){return[t-1]}),eq:ht(function(e,t,n){return[0>n?n+t:n]}),even:ht(function(e,t){var n=0;for(;t>n;n+=2)e.push(n);return e}),odd:ht(function(e,t){var n=1;for(;t>n;n+=2)e.push(n);return e}),lt:ht(function(e,t,n){var r=0>n?n+t:n;for(;--r>=0;)e.push(r);return e}),gt:ht(function(e,t,n){var r=0>n?n+t:n;for(;t>++r;)e.push(r);return e})}},i.pseudos.nth=i.pseudos.eq;for(t in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})i.pseudos[t]=pt(t);for(t in{submit:!0,reset:!0})i.pseudos[t]=ft(t);function dt(){}dt.prototype=i.filters=i.pseudos,i.setFilters=new dt;function gt(e,t){var n,r,o,s,a,u,l,c=k[e+" "];if(c)return t?0:c.slice(0);a=e,u=[],l=i.preFilter;while(a){(!n||(r=_.exec(a)))&&(r&&(a=a.slice(r[0].length)||a),u.push(o=[])),n=!1,(r=X.exec(a))&&(n=r.shift(),o.push({value:n,type:r[0].replace(z," ")}),a=a.slice(n.length));for(s in i.filter)!(r=J[s].exec(a))||l[s]&&!(r=l[s](r))||(n=r.shift(),o.push({value:n,type:s,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?ot.error(e):k(e,u).slice(0)}function mt(e){var t=0,n=e.length,r="";for(;n>t;t++)r+=e[t].value;return r}function yt(e,t,n){var i=t.dir,o=n&&"parentNode"===i,s=T++;return t.first?function(t,n,r){while(t=t[i])if(1===t.nodeType||o)return e(t,n,r)}:function(t,n,a){var u,l,c,p=w+" "+s;if(a){while(t=t[i])if((1===t.nodeType||o)&&e(t,n,a))return!0}else while(t=t[i])if(1===t.nodeType||o)if(c=t[v]||(t[v]={}),(l=c[i])&&l[0]===p){if((u=l[1])===!0||u===r)return u===!0}else if(l=c[i]=[p],l[1]=e(t,n,a)||r,l[1]===!0)return!0}}function vt(e){return e.length>1?function(t,n,r){var i=e.length;while(i--)if(!e[i](t,n,r))return!1;return!0}:e[0]}function xt(e,t,n,r,i){var o,s=[],a=0,u=e.length,l=null!=t;for(;u>a;a++)(o=e[a])&&(!n||n(o,r,i))&&(s.push(o),l&&t.push(a));return s}function bt(e,t,n,r,i,o){return r&&!r[v]&&(r=bt(r)),i&&!i[v]&&(i=bt(i,o)),at(function(o,s,a,u){var l,c,p,f=[],h=[],d=s.length,g=o||Ct(t||"*",a.nodeType?[a]:a,[]),m=!e||!o&&t?g:xt(g,f,e,a,u),y=n?i||(o?e:d||r)?[]:s:m;if(n&&n(m,y,a,u),r){l=xt(y,h),r(l,[],a,u),c=l.length;while(c--)(p=l[c])&&(y[h[c]]=!(m[h[c]]=p))}if(o){if(i||e){if(i){l=[],c=y.length;while(c--)(p=y[c])&&l.push(m[c]=p);i(null,y=[],l,u)}c=y.length;while(c--)(p=y[c])&&(l=i?P.call(o,p):f[c])>-1&&(o[l]=!(s[l]=p))}}else y=xt(y===s?y.splice(d,y.length):y),i?i(null,s,y,u):O.apply(s,y)})}function wt(e){var t,n,r,o=e.length,s=i.relative[e[0].type],a=s||i.relative[" "],l=s?1:0,c=yt(function(e){return e===t},a,!0),p=yt(function(e){return P.call(t,e)>-1},a,!0),f=[function(e,n,r){return!s&&(r||n!==u)||((t=n).nodeType?c(e,n,r):p(e,n,r))}];for(;o>l;l++)if(n=i.relative[e[l].type])f=[yt(vt(f),n)];else{if(n=i.filter[e[l].type].apply(null,e[l].matches),n[v]){for(r=++l;o>r;r++)if(i.relative[e[r].type])break;return bt(l>1&&vt(f),l>1&&mt(e.slice(0,l-1).concat({value:" "===e[l-2].type?"*":""})).replace(z,"$1"),n,r>l&&wt(e.slice(l,r)),o>r&&wt(e=e.slice(r)),o>r&&mt(e))}f.push(n)}return vt(f)}function Tt(e,t){var n=0,o=t.length>0,s=e.length>0,a=function(a,l,c,f,h){var d,g,m,y=[],v=0,x="0",b=a&&[],T=null!=h,C=u,k=a||s&&i.find.TAG("*",h&&l.parentNode||l),N=w+=null==C?1:Math.random()||.1;for(T&&(u=l!==p&&l,r=n);null!=(d=k[x]);x++){if(s&&d){g=0;while(m=e[g++])if(m(d,l,c)){f.push(d);break}T&&(w=N,r=++n)}o&&((d=!m&&d)&&v--,a&&b.push(d))}if(v+=x,o&&x!==v){g=0;while(m=t[g++])m(b,y,l,c);if(a){if(v>0)while(x--)b[x]||y[x]||(y[x]=q.call(f));y=xt(y)}O.apply(f,y),T&&!a&&y.length>0&&v+t.length>1&&ot.uniqueSort(f)}return T&&(w=N,u=C),b};return o?at(a):a}a=ot.compile=function(e,t){var n,r=[],i=[],o=N[e+" "];if(!o){t||(t=gt(e)),n=t.length;while(n--)o=wt(t[n]),o[v]?r.push(o):i.push(o);o=N(e,Tt(i,r))}return o};function Ct(e,t,n){var r=0,i=t.length;for(;i>r;r++)ot(e,t[r],n);return n}function kt(e,t,r,o){var s,u,l,c,p,f=gt(e);if(!o&&1===f.length){if(u=f[0]=f[0].slice(0),u.length>2&&"ID"===(l=u[0]).type&&n.getById&&9===t.nodeType&&h&&i.relative[u[1].type]){if(t=(i.find.ID(l.matches[0].replace(nt,rt),t)||[])[0],!t)return r;e=e.slice(u.shift().value.length)}s=J.needsContext.test(e)?0:u.length;while(s--){if(l=u[s],i.relative[c=l.type])break;if((p=i.find[c])&&(o=p(l.matches[0].replace(nt,rt),U.test(u[0].type)&&t.parentNode||t))){if(u.splice(s,1),e=o.length&&mt(u),!e)return O.apply(r,o),r;break}}}return a(e,f)(o,t,!h,r,U.test(e)),r}n.sortStable=v.split("").sort(S).join("")===v,n.detectDuplicates=E,c(),n.sortDetached=ut(function(e){return 1&e.compareDocumentPosition(p.createElement("div"))}),ut(function(e){return e.innerHTML="<a href='#'></a>","#"===e.firstChild.getAttribute("href")})||lt("type|href|height|width",function(e,t,n){return n?undefined:e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),n.attributes&&ut(function(e){return e.innerHTML="<input/>",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||lt("value",function(e,t,n){return n||"input"!==e.nodeName.toLowerCase()?undefined:e.defaultValue}),ut(function(e){return null==e.getAttribute("disabled")})||lt(R,function(e,t,n){var r;return n?undefined:(r=e.getAttributeNode(t))&&r.specified?r.value:e[t]===!0?t.toLowerCase():null}),x.find=ot,x.expr=ot.selectors,x.expr[":"]=x.expr.pseudos,x.unique=ot.uniqueSort,x.text=ot.getText,x.isXMLDoc=ot.isXML,x.contains=ot.contains}(e);var D={};function A(e){var t=D[e]={};return x.each(e.match(w)||[],function(e,n){t[n]=!0}),t}x.Callbacks=function(e){e="string"==typeof e?D[e]||A(e):x.extend({},e);var t,n,r,i,o,s,a=[],u=!e.once&&[],l=function(p){for(t=e.memory&&p,n=!0,s=i||0,i=0,o=a.length,r=!0;a&&o>s;s++)if(a[s].apply(p[0],p[1])===!1&&e.stopOnFalse){t=!1;break}r=!1,a&&(u?u.length&&l(u.shift()):t?a=[]:c.disable())},c={add:function(){if(a){var n=a.length;(function s(t){x.each(t,function(t,n){var r=x.type(n);"function"===r?e.unique&&c.has(n)||a.push(n):n&&n.length&&"string"!==r&&s(n)})})(arguments),r?o=a.length:t&&(i=n,l(t))}return this},remove:function(){return a&&x.each(arguments,function(e,t){var n;while((n=x.inArray(t,a,n))>-1)a.splice(n,1),r&&(o>=n&&o--,s>=n&&s--)}),this},has:function(e){return e?x.inArray(e,a)>-1:!(!a||!a.length)},empty:function(){return a=[],o=0,this},disable:function(){return a=u=t=undefined,this},disabled:function(){return!a},lock:function(){return u=undefined,t||c.disable(),this},locked:function(){return!u},fireWith:function(e,t){return!a||n&&!u||(t=t||[],t=[e,t.slice?t.slice():t],r?u.push(t):l(t)),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!n}};return c},x.extend({Deferred:function(e){var t=[["resolve","done",x.Callbacks("once memory"),"resolved"],["reject","fail",x.Callbacks("once memory"),"rejected"],["notify","progress",x.Callbacks("memory")]],n="pending",r={state:function(){return n},always:function(){return i.done(arguments).fail(arguments),this},then:function(){var e=arguments;return x.Deferred(function(n){x.each(t,function(t,o){var s=o[0],a=x.isFunction(e[t])&&e[t];i[o[1]](function(){var e=a&&a.apply(this,arguments);e&&x.isFunction(e.promise)?e.promise().done(n.resolve).fail(n.reject).progress(n.notify):n[s+"With"](this===r?n.promise():this,a?[e]:arguments)})}),e=null}).promise()},promise:function(e){return null!=e?x.extend(e,r):r}},i={};return r.pipe=r.then,x.each(t,function(e,o){var s=o[2],a=o[3];r[o[1]]=s.add,a&&s.add(function(){n=a},t[1^e][2].disable,t[2][2].lock),i[o[0]]=function(){return i[o[0]+"With"](this===i?r:this,arguments),this},i[o[0]+"With"]=s.fireWith}),r.promise(i),e&&e.call(i,i),i},when:function(e){var t=0,n=d.call(arguments),r=n.length,i=1!==r||e&&x.isFunction(e.promise)?r:0,o=1===i?e:x.Deferred(),s=function(e,t,n){return function(r){t[e]=this,n[e]=arguments.length>1?d.call(arguments):r,n===a?o.notifyWith(t,n):--i||o.resolveWith(t,n)}},a,u,l;if(r>1)for(a=Array(r),u=Array(r),l=Array(r);r>t;t++)n[t]&&x.isFunction(n[t].promise)?n[t].promise().done(s(t,l,n)).fail(o.reject).progress(s(t,u,a)):--i;return i||o.resolveWith(l,n),o.promise()}}),x.support=function(t){var n=o.createElement("input"),r=o.createDocumentFragment(),i=o.createElement("div"),s=o.createElement("select"),a=s.appendChild(o.createElement("option"));return n.type?(n.type="checkbox",t.checkOn=""!==n.value,t.optSelected=a.selected,t.reliableMarginRight=!0,t.boxSizingReliable=!0,t.pixelPosition=!1,n.checked=!0,t.noCloneChecked=n.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!a.disabled,n=o.createElement("input"),n.value="t",n.type="radio",t.radioValue="t"===n.value,n.setAttribute("checked","t"),n.setAttribute("name","t"),r.appendChild(n),t.checkClone=r.cloneNode(!0).cloneNode(!0).lastChild.checked,t.focusinBubbles="onfocusin"in e,i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",t.clearCloneStyle="content-box"===i.style.backgroundClip,x(function(){var n,r,s="padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box",a=o.getElementsByTagName("body")[0];a&&(n=o.createElement("div"),n.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",a.appendChild(n).appendChild(i),i.innerHTML="",i.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%",x.swap(a,null!=a.style.zoom?{zoom:1}:{},function(){t.boxSizing=4===i.offsetWidth}),e.getComputedStyle&&(t.pixelPosition="1%"!==(e.getComputedStyle(i,null)||{}).top,t.boxSizingReliable="4px"===(e.getComputedStyle(i,null)||{width:"4px"}).width,r=i.appendChild(o.createElement("div")),r.style.cssText=i.style.cssText=s,r.style.marginRight=r.style.width="0",i.style.width="1px",t.reliableMarginRight=!parseFloat((e.getComputedStyle(r,null)||{}).marginRight)),a.removeChild(n))}),t):t}({});var L,q,H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,O=/([A-Z])/g;function F(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=x.expando+Math.random()}F.uid=1,F.accepts=function(e){return e.nodeType?1===e.nodeType||9===e.nodeType:!0},F.prototype={key:function(e){if(!F.accepts(e))return 0;var t={},n=e[this.expando];if(!n){n=F.uid++;try{t[this.expando]={value:n},Object.defineProperties(e,t)}catch(r){t[this.expando]=n,x.extend(e,t)}}return this.cache[n]||(this.cache[n]={}),n},set:function(e,t,n){var r,i=this.key(e),o=this.cache[i];if("string"==typeof t)o[t]=n;else if(x.isEmptyObject(o))x.extend(this.cache[i],t);else for(r in t)o[r]=t[r];return o},get:function(e,t){var n=this.cache[this.key(e)];return t===undefined?n:n[t]},access:function(e,t,n){var r;return t===undefined||t&&"string"==typeof t&&n===undefined?(r=this.get(e,t),r!==undefined?r:this.get(e,x.camelCase(t))):(this.set(e,t,n),n!==undefined?n:t)},remove:function(e,t){var n,r,i,o=this.key(e),s=this.cache[o];if(t===undefined)this.cache[o]={};else{x.isArray(t)?r=t.concat(t.map(x.camelCase)):(i=x.camelCase(t),t in s?r=[t,i]:(r=i,r=r in s?[r]:r.match(w)||[])),n=r.length;while(n--)delete s[r[n]]}},hasData:function(e){return!x.isEmptyObject(this.cache[e[this.expando]]||{})},discard:function(e){e[this.expando]&&delete this.cache[e[this.expando]]}},L=new F,q=new F,x.extend({acceptData:F.accepts,hasData:function(e){return L.hasData(e)||q.hasData(e)},data:function(e,t,n){return L.access(e,t,n)},removeData:function(e,t){L.remove(e,t)},_data:function(e,t,n){return q.access(e,t,n)},_removeData:function(e,t){q.remove(e,t)}}),x.fn.extend({data:function(e,t){var n,r,i=this[0],o=0,s=null;if(e===undefined){if(this.length&&(s=L.get(i),1===i.nodeType&&!q.get(i,"hasDataAttrs"))){for(n=i.attributes;n.length>o;o++)r=n[o].name,0===r.indexOf("data-")&&(r=x.camelCase(r.slice(5)),P(i,r,s[r]));q.set(i,"hasDataAttrs",!0)}return s}return"object"==typeof e?this.each(function(){L.set(this,e)}):x.access(this,function(t){var n,r=x.camelCase(e);if(i&&t===undefined){if(n=L.get(i,e),n!==undefined)return n;if(n=L.get(i,r),n!==undefined)return n;if(n=P(i,r,undefined),n!==undefined)return n}else this.each(function(){var n=L.get(this,r);L.set(this,r,t),-1!==e.indexOf("-")&&n!==undefined&&L.set(this,e,t)})},null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each(function(){L.remove(this,e)})}});function P(e,t,n){var r;if(n===undefined&&1===e.nodeType)if(r="data-"+t.replace(O,"-$1").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n="true"===n?!0:"false"===n?!1:"null"===n?null:+n+""===n?+n:H.test(n)?JSON.parse(n):n}catch(i){}L.set(e,t,n)}else n=undefined;return n}x.extend({queue:function(e,t,n){var r;return e?(t=(t||"fx")+"queue",r=q.get(e,t),n&&(!r||x.isArray(n)?r=q.access(e,t,x.makeArray(n)):r.push(n)),r||[]):undefined},dequeue:function(e,t){t=t||"fx";var n=x.queue(e,t),r=n.length,i=n.shift(),o=x._queueHooks(e,t),s=function(){x.dequeue(e,t)
+};"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,s,o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return q.get(e,n)||q.access(e,n,{empty:x.Callbacks("once memory").add(function(){q.remove(e,[t+"queue",n])})})}}),x.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),n>arguments.length?x.queue(this[0],e):t===undefined?this:this.each(function(){var n=x.queue(this,e,t);x._queueHooks(this,e),"fx"===e&&"inprogress"!==n[0]&&x.dequeue(this,e)})},dequeue:function(e){return this.each(function(){x.dequeue(this,e)})},delay:function(e,t){return e=x.fx?x.fx.speeds[e]||e:e,t=t||"fx",this.queue(t,function(t,n){var r=setTimeout(t,e);n.stop=function(){clearTimeout(r)}})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=x.Deferred(),o=this,s=this.length,a=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=undefined),e=e||"fx";while(s--)n=q.get(o[s],e+"queueHooks"),n&&n.empty&&(r++,n.empty.add(a));return a(),i.promise(t)}});var R,M,W=/[\t\r\n\f]/g,$=/\r/g,B=/^(?:input|select|textarea|button)$/i;x.fn.extend({attr:function(e,t){return x.access(this,x.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each(function(){x.removeAttr(this,e)})},prop:function(e,t){return x.access(this,x.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[x.propFix[e]||e]})},addClass:function(e){var t,n,r,i,o,s=0,a=this.length,u="string"==typeof e&&e;if(x.isFunction(e))return this.each(function(t){x(this).addClass(e.call(this,t,this.className))});if(u)for(t=(e||"").match(w)||[];a>s;s++)if(n=this[s],r=1===n.nodeType&&(n.className?(" "+n.className+" ").replace(W," "):" ")){o=0;while(i=t[o++])0>r.indexOf(" "+i+" ")&&(r+=i+" ");n.className=x.trim(r)}return this},removeClass:function(e){var t,n,r,i,o,s=0,a=this.length,u=0===arguments.length||"string"==typeof e&&e;if(x.isFunction(e))return this.each(function(t){x(this).removeClass(e.call(this,t,this.className))});if(u)for(t=(e||"").match(w)||[];a>s;s++)if(n=this[s],r=1===n.nodeType&&(n.className?(" "+n.className+" ").replace(W," "):"")){o=0;while(i=t[o++])while(r.indexOf(" "+i+" ")>=0)r=r.replace(" "+i+" "," ");n.className=e?x.trim(r):""}return this},toggleClass:function(e,t){var n=typeof e;return"boolean"==typeof t&&"string"===n?t?this.addClass(e):this.removeClass(e):x.isFunction(e)?this.each(function(n){x(this).toggleClass(e.call(this,n,this.className,t),t)}):this.each(function(){if("string"===n){var t,i=0,o=x(this),s=e.match(w)||[];while(t=s[i++])o.hasClass(t)?o.removeClass(t):o.addClass(t)}else(n===r||"boolean"===n)&&(this.className&&q.set(this,"__className__",this.className),this.className=this.className||e===!1?"":q.get(this,"__className__")||"")})},hasClass:function(e){var t=" "+e+" ",n=0,r=this.length;for(;r>n;n++)if(1===this[n].nodeType&&(" "+this[n].className+" ").replace(W," ").indexOf(t)>=0)return!0;return!1},val:function(e){var t,n,r,i=this[0];{if(arguments.length)return r=x.isFunction(e),this.each(function(n){var i;1===this.nodeType&&(i=r?e.call(this,n,x(this).val()):e,null==i?i="":"number"==typeof i?i+="":x.isArray(i)&&(i=x.map(i,function(e){return null==e?"":e+""})),t=x.valHooks[this.type]||x.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&t.set(this,i,"value")!==undefined||(this.value=i))});if(i)return t=x.valHooks[i.type]||x.valHooks[i.nodeName.toLowerCase()],t&&"get"in t&&(n=t.get(i,"value"))!==undefined?n:(n=i.value,"string"==typeof n?n.replace($,""):null==n?"":n)}}}),x.extend({valHooks:{option:{get:function(e){var t=e.attributes.value;return!t||t.specified?e.value:e.text}},select:{get:function(e){var t,n,r=e.options,i=e.selectedIndex,o="select-one"===e.type||0>i,s=o?null:[],a=o?i+1:r.length,u=0>i?a:o?i:0;for(;a>u;u++)if(n=r[u],!(!n.selected&&u!==i||(x.support.optDisabled?n.disabled:null!==n.getAttribute("disabled"))||n.parentNode.disabled&&x.nodeName(n.parentNode,"optgroup"))){if(t=x(n).val(),o)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=x.makeArray(t),s=i.length;while(s--)r=i[s],(r.selected=x.inArray(x(r).val(),o)>=0)&&(n=!0);return n||(e.selectedIndex=-1),o}}},attr:function(e,t,n){var i,o,s=e.nodeType;if(e&&3!==s&&8!==s&&2!==s)return typeof e.getAttribute===r?x.prop(e,t,n):(1===s&&x.isXMLDoc(e)||(t=t.toLowerCase(),i=x.attrHooks[t]||(x.expr.match.bool.test(t)?M:R)),n===undefined?i&&"get"in i&&null!==(o=i.get(e,t))?o:(o=x.find.attr(e,t),null==o?undefined:o):null!==n?i&&"set"in i&&(o=i.set(e,n,t))!==undefined?o:(e.setAttribute(t,n+""),n):(x.removeAttr(e,t),undefined))},removeAttr:function(e,t){var n,r,i=0,o=t&&t.match(w);if(o&&1===e.nodeType)while(n=o[i++])r=x.propFix[n]||n,x.expr.match.bool.test(n)&&(e[r]=!1),e.removeAttribute(n)},attrHooks:{type:{set:function(e,t){if(!x.support.radioValue&&"radio"===t&&x.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},propFix:{"for":"htmlFor","class":"className"},prop:function(e,t,n){var r,i,o,s=e.nodeType;if(e&&3!==s&&8!==s&&2!==s)return o=1!==s||!x.isXMLDoc(e),o&&(t=x.propFix[t]||t,i=x.propHooks[t]),n!==undefined?i&&"set"in i&&(r=i.set(e,n,t))!==undefined?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){return e.hasAttribute("tabindex")||B.test(e.nodeName)||e.href?e.tabIndex:-1}}}}),M={set:function(e,t,n){return t===!1?x.removeAttr(e,n):e.setAttribute(n,n),n}},x.each(x.expr.match.bool.source.match(/\w+/g),function(e,t){var n=x.expr.attrHandle[t]||x.find.attr;x.expr.attrHandle[t]=function(e,t,r){var i=x.expr.attrHandle[t],o=r?undefined:(x.expr.attrHandle[t]=undefined)!=n(e,t,r)?t.toLowerCase():null;return x.expr.attrHandle[t]=i,o}}),x.support.optSelected||(x.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null}}),x.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){x.propFix[this.toLowerCase()]=this}),x.each(["radio","checkbox"],function(){x.valHooks[this]={set:function(e,t){return x.isArray(t)?e.checked=x.inArray(x(e).val(),t)>=0:undefined}},x.support.checkOn||(x.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var I=/^key/,z=/^(?:mouse|contextmenu)|click/,_=/^(?:focusinfocus|focusoutblur)$/,X=/^([^.]*)(?:\.(.+)|)$/;function U(){return!0}function Y(){return!1}function V(){try{return o.activeElement}catch(e){}}x.event={global:{},add:function(e,t,n,i,o){var s,a,u,l,c,p,f,h,d,g,m,y=q.get(e);if(y){n.handler&&(s=n,n=s.handler,o=s.selector),n.guid||(n.guid=x.guid++),(l=y.events)||(l=y.events={}),(a=y.handle)||(a=y.handle=function(e){return typeof x===r||e&&x.event.triggered===e.type?undefined:x.event.dispatch.apply(a.elem,arguments)},a.elem=e),t=(t||"").match(w)||[""],c=t.length;while(c--)u=X.exec(t[c])||[],d=m=u[1],g=(u[2]||"").split(".").sort(),d&&(f=x.event.special[d]||{},d=(o?f.delegateType:f.bindType)||d,f=x.event.special[d]||{},p=x.extend({type:d,origType:m,data:i,handler:n,guid:n.guid,selector:o,needsContext:o&&x.expr.match.needsContext.test(o),namespace:g.join(".")},s),(h=l[d])||(h=l[d]=[],h.delegateCount=0,f.setup&&f.setup.call(e,i,g,a)!==!1||e.addEventListener&&e.addEventListener(d,a,!1)),f.add&&(f.add.call(e,p),p.handler.guid||(p.handler.guid=n.guid)),o?h.splice(h.delegateCount++,0,p):h.push(p),x.event.global[d]=!0);e=null}},remove:function(e,t,n,r,i){var o,s,a,u,l,c,p,f,h,d,g,m=q.hasData(e)&&q.get(e);if(m&&(u=m.events)){t=(t||"").match(w)||[""],l=t.length;while(l--)if(a=X.exec(t[l])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){p=x.event.special[h]||{},h=(r?p.delegateType:p.bindType)||h,f=u[h]||[],a=a[2]&&RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=o=f.length;while(o--)c=f[o],!i&&g!==c.origType||n&&n.guid!==c.guid||a&&!a.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(f.splice(o,1),c.selector&&f.delegateCount--,p.remove&&p.remove.call(e,c));s&&!f.length&&(p.teardown&&p.teardown.call(e,d,m.handle)!==!1||x.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)x.event.remove(e,h+t[l],n,r,!0);x.isEmptyObject(u)&&(delete m.handle,q.remove(e,"events"))}},trigger:function(t,n,r,i){var s,a,u,l,c,p,f,h=[r||o],d=y.call(t,"type")?t.type:t,g=y.call(t,"namespace")?t.namespace.split("."):[];if(a=u=r=r||o,3!==r.nodeType&&8!==r.nodeType&&!_.test(d+x.event.triggered)&&(d.indexOf(".")>=0&&(g=d.split("."),d=g.shift(),g.sort()),c=0>d.indexOf(":")&&"on"+d,t=t[x.expando]?t:new x.Event(d,"object"==typeof t&&t),t.isTrigger=i?2:3,t.namespace=g.join("."),t.namespace_re=t.namespace?RegExp("(^|\\.)"+g.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=undefined,t.target||(t.target=r),n=null==n?[t]:x.makeArray(n,[t]),f=x.event.special[d]||{},i||!f.trigger||f.trigger.apply(r,n)!==!1)){if(!i&&!f.noBubble&&!x.isWindow(r)){for(l=f.delegateType||d,_.test(l+d)||(a=a.parentNode);a;a=a.parentNode)h.push(a),u=a;u===(r.ownerDocument||o)&&h.push(u.defaultView||u.parentWindow||e)}s=0;while((a=h[s++])&&!t.isPropagationStopped())t.type=s>1?l:f.bindType||d,p=(q.get(a,"events")||{})[t.type]&&q.get(a,"handle"),p&&p.apply(a,n),p=c&&a[c],p&&x.acceptData(a)&&p.apply&&p.apply(a,n)===!1&&t.preventDefault();return t.type=d,i||t.isDefaultPrevented()||f._default&&f._default.apply(h.pop(),n)!==!1||!x.acceptData(r)||c&&x.isFunction(r[d])&&!x.isWindow(r)&&(u=r[c],u&&(r[c]=null),x.event.triggered=d,r[d](),x.event.triggered=undefined,u&&(r[c]=u)),t.result}},dispatch:function(e){e=x.event.fix(e);var t,n,r,i,o,s=[],a=d.call(arguments),u=(q.get(this,"events")||{})[e.type]||[],l=x.event.special[e.type]||{};if(a[0]=e,e.delegateTarget=this,!l.preDispatch||l.preDispatch.call(this,e)!==!1){s=x.event.handlers.call(this,e,u),t=0;while((i=s[t++])&&!e.isPropagationStopped()){e.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!e.isImmediatePropagationStopped())(!e.namespace_re||e.namespace_re.test(o.namespace))&&(e.handleObj=o,e.data=o.data,r=((x.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,a),r!==undefined&&(e.result=r)===!1&&(e.preventDefault(),e.stopPropagation()))}return l.postDispatch&&l.postDispatch.call(this,e),e.result}},handlers:function(e,t){var n,r,i,o,s=[],a=t.delegateCount,u=e.target;if(a&&u.nodeType&&(!e.button||"click"!==e.type))for(;u!==this;u=u.parentNode||this)if(u.disabled!==!0||"click"!==e.type){for(r=[],n=0;a>n;n++)o=t[n],i=o.selector+" ",r[i]===undefined&&(r[i]=o.needsContext?x(i,this).index(u)>=0:x.find(i,this,null,[u]).length),r[i]&&r.push(o);r.length&&s.push({elem:u,handlers:r})}return t.length>a&&s.push({elem:this,handlers:t.slice(a)}),s},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(e,t){return null==e.which&&(e.which=null!=t.charCode?t.charCode:t.keyCode),e}},mouseHooks:{props:"button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(e,t){var n,r,i,s=t.button;return null==e.pageX&&null!=t.clientX&&(n=e.target.ownerDocument||o,r=n.documentElement,i=n.body,e.pageX=t.clientX+(r&&r.scrollLeft||i&&i.scrollLeft||0)-(r&&r.clientLeft||i&&i.clientLeft||0),e.pageY=t.clientY+(r&&r.scrollTop||i&&i.scrollTop||0)-(r&&r.clientTop||i&&i.clientTop||0)),e.which||s===undefined||(e.which=1&s?1:2&s?3:4&s?2:0),e}},fix:function(e){if(e[x.expando])return e;var t,n,r,i=e.type,s=e,a=this.fixHooks[i];a||(this.fixHooks[i]=a=z.test(i)?this.mouseHooks:I.test(i)?this.keyHooks:{}),r=a.props?this.props.concat(a.props):this.props,e=new x.Event(s),t=r.length;while(t--)n=r[t],e[n]=s[n];return e.target||(e.target=o),3===e.target.nodeType&&(e.target=e.target.parentNode),a.filter?a.filter(e,s):e},special:{load:{noBubble:!0},focus:{trigger:function(){return this!==V()&&this.focus?(this.focus(),!1):undefined},delegateType:"focusin"},blur:{trigger:function(){return this===V()&&this.blur?(this.blur(),!1):undefined},delegateType:"focusout"},click:{trigger:function(){return"checkbox"===this.type&&this.click&&x.nodeName(this,"input")?(this.click(),!1):undefined},_default:function(e){return x.nodeName(e.target,"a")}},beforeunload:{postDispatch:function(e){e.result!==undefined&&(e.originalEvent.returnValue=e.result)}}},simulate:function(e,t,n,r){var i=x.extend(new x.Event,n,{type:e,isSimulated:!0,originalEvent:{}});r?x.event.trigger(i,null,t):x.event.dispatch.call(t,i),i.isDefaultPrevented()&&n.preventDefault()}},x.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n,!1)},x.Event=function(e,t){return this instanceof x.Event?(e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||e.getPreventDefault&&e.getPreventDefault()?U:Y):this.type=e,t&&x.extend(this,t),this.timeStamp=e&&e.timeStamp||x.now(),this[x.expando]=!0,undefined):new x.Event(e,t)},x.Event.prototype={isDefaultPrevented:Y,isPropagationStopped:Y,isImmediatePropagationStopped:Y,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=U,e&&e.preventDefault&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=U,e&&e.stopPropagation&&e.stopPropagation()},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=U,this.stopPropagation()}},x.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(e,t){x.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,o=e.handleObj;return(!i||i!==r&&!x.contains(r,i))&&(e.type=o.origType,n=o.handler.apply(this,arguments),e.type=t),n}}}),x.support.focusinBubbles||x.each({focus:"focusin",blur:"focusout"},function(e,t){var n=0,r=function(e){x.event.simulate(t,e.target,x.event.fix(e),!0)};x.event.special[t]={setup:function(){0===n++&&o.addEventListener(e,r,!0)},teardown:function(){0===--n&&o.removeEventListener(e,r,!0)}}}),x.fn.extend({on:function(e,t,n,r,i){var o,s;if("object"==typeof e){"string"!=typeof t&&(n=n||t,t=undefined);for(s in e)this.on(s,t,n,e[s],i);return this}if(null==n&&null==r?(r=t,n=t=undefined):null==r&&("string"==typeof t?(r=n,n=undefined):(r=n,n=t,t=undefined)),r===!1)r=Y;else if(!r)return this;return 1===i&&(o=r,r=function(e){return x().off(e),o.apply(this,arguments)},r.guid=o.guid||(o.guid=x.guid++)),this.each(function(){x.event.add(this,e,r,n,t)})},one:function(e,t,n,r){return this.on(e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,x(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return(t===!1||"function"==typeof t)&&(n=t,t=undefined),n===!1&&(n=Y),this.each(function(){x.event.remove(this,e,n,t)})},trigger:function(e,t){return this.each(function(){x.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];return n?x.event.trigger(e,t,n,!0):undefined}});var G=/^.[^:#\[\.,]*$/,J=/^(?:parents|prev(?:Until|All))/,Q=x.expr.match.needsContext,K={children:!0,contents:!0,next:!0,prev:!0};x.fn.extend({find:function(e){var t,n=[],r=this,i=r.length;if("string"!=typeof e)return this.pushStack(x(e).filter(function(){for(t=0;i>t;t++)if(x.contains(r[t],this))return!0}));for(t=0;i>t;t++)x.find(e,r[t],n);return n=this.pushStack(i>1?x.unique(n):n),n.selector=this.selector?this.selector+" "+e:e,n},has:function(e){var t=x(e,this),n=t.length;return this.filter(function(){var e=0;for(;n>e;e++)if(x.contains(this,t[e]))return!0})},not:function(e){return this.pushStack(et(this,e||[],!0))},filter:function(e){return this.pushStack(et(this,e||[],!1))},is:function(e){return!!et(this,"string"==typeof e&&Q.test(e)?x(e):e||[],!1).length},closest:function(e,t){var n,r=0,i=this.length,o=[],s=Q.test(e)||"string"!=typeof e?x(e,t||this.context):0;for(;i>r;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(11>n.nodeType&&(s?s.index(n)>-1:1===n.nodeType&&x.find.matchesSelector(n,e))){n=o.push(n);break}return this.pushStack(o.length>1?x.unique(o):o)},index:function(e){return e?"string"==typeof e?g.call(x(e),this[0]):g.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){var n="string"==typeof e?x(e,t):x.makeArray(e&&e.nodeType?[e]:e),r=x.merge(this.get(),n);return this.pushStack(x.unique(r))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}});function Z(e,t){while((e=e[t])&&1!==e.nodeType);return e}x.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return x.dir(e,"parentNode")},parentsUntil:function(e,t,n){return x.dir(e,"parentNode",n)},next:function(e){return Z(e,"nextSibling")},prev:function(e){return Z(e,"previousSibling")},nextAll:function(e){return x.dir(e,"nextSibling")},prevAll:function(e){return x.dir(e,"previousSibling")},nextUntil:function(e,t,n){return x.dir(e,"nextSibling",n)},prevUntil:function(e,t,n){return x.dir(e,"previousSibling",n)},siblings:function(e){return x.sibling((e.parentNode||{}).firstChild,e)},children:function(e){return x.sibling(e.firstChild)},contents:function(e){return e.contentDocument||x.merge([],e.childNodes)}},function(e,t){x.fn[e]=function(n,r){var i=x.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=x.filter(r,i)),this.length>1&&(K[e]||x.unique(i),J.test(e)&&i.reverse()),this.pushStack(i)}}),x.extend({filter:function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?x.find.matchesSelector(r,e)?[r]:[]:x.find.matches(e,x.grep(t,function(e){return 1===e.nodeType}))},dir:function(e,t,n){var r=[],i=n!==undefined;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&x(e).is(n))break;r.push(e)}return r},sibling:function(e,t){var n=[];for(;e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n}});function et(e,t,n){if(x.isFunction(t))return x.grep(e,function(e,r){return!!t.call(e,r,e)!==n});if(t.nodeType)return x.grep(e,function(e){return e===t!==n});if("string"==typeof t){if(G.test(t))return x.filter(t,e,n);t=x.filter(t,e)}return x.grep(e,function(e){return g.call(t,e)>=0!==n})}var tt=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,nt=/<([\w:]+)/,rt=/<|&#?\w+;/,it=/<(?:script|style|link)/i,ot=/^(?:checkbox|radio)$/i,st=/checked\s*(?:[^=]|=\s*.checked.)/i,at=/^$|\/(?:java|ecma)script/i,ut=/^true\/(.*)/,lt=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,ct={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};ct.optgroup=ct.option,ct.tbody=ct.tfoot=ct.colgroup=ct.caption=ct.thead,ct.th=ct.td,x.fn.extend({text:function(e){return x.access(this,function(e){return e===undefined?x.text(this):this.empty().append((this[0]&&this[0].ownerDocument||o).createTextNode(e))},null,e,arguments.length)},append:function(){return this.domManip(arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=pt(this,e);t.appendChild(e)}})},prepend:function(){return this.domManip(arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=pt(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return this.domManip(arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return this.domManip(arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},remove:function(e,t){var n,r=e?x.filter(e,this):this,i=0;for(;null!=(n=r[i]);i++)t||1!==n.nodeType||x.cleanData(mt(n)),n.parentNode&&(t&&x.contains(n.ownerDocument,n)&&dt(mt(n,"script")),n.parentNode.removeChild(n));return this},empty:function(){var e,t=0;for(;null!=(e=this[t]);t++)1===e.nodeType&&(x.cleanData(mt(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null==e?!1:e,t=null==t?e:t,this.map(function(){return x.clone(this,e,t)})},html:function(e){return x.access(this,function(e){var t=this[0]||{},n=0,r=this.length;if(e===undefined&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!it.test(e)&&!ct[(nt.exec(e)||["",""])[1].toLowerCase()]){e=e.replace(tt,"<$1></$2>");try{for(;r>n;n++)t=this[n]||{},1===t.nodeType&&(x.cleanData(mt(t,!1)),t.innerHTML=e);t=0}catch(i){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var e=x.map(this,function(e){return[e.nextSibling,e.parentNode]}),t=0;return this.domManip(arguments,function(n){var r=e[t++],i=e[t++];i&&(r&&r.parentNode!==i&&(r=this.nextSibling),x(this).remove(),i.insertBefore(n,r))},!0),t?this:this.remove()},detach:function(e){return this.remove(e,!0)},domManip:function(e,t,n){e=f.apply([],e);var r,i,o,s,a,u,l=0,c=this.length,p=this,h=c-1,d=e[0],g=x.isFunction(d);if(g||!(1>=c||"string"!=typeof d||x.support.checkClone)&&st.test(d))return this.each(function(r){var i=p.eq(r);g&&(e[0]=d.call(this,r,i.html())),i.domManip(e,t,n)});if(c&&(r=x.buildFragment(e,this[0].ownerDocument,!1,!n&&this),i=r.firstChild,1===r.childNodes.length&&(r=i),i)){for(o=x.map(mt(r,"script"),ft),s=o.length;c>l;l++)a=r,l!==h&&(a=x.clone(a,!0,!0),s&&x.merge(o,mt(a,"script"))),t.call(this[l],a,l);if(s)for(u=o[o.length-1].ownerDocument,x.map(o,ht),l=0;s>l;l++)a=o[l],at.test(a.type||"")&&!q.access(a,"globalEval")&&x.contains(u,a)&&(a.src?x._evalUrl(a.src):x.globalEval(a.textContent.replace(lt,"")))}return this}}),x.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,t){x.fn[e]=function(e){var n,r=[],i=x(e),o=i.length-1,s=0;for(;o>=s;s++)n=s===o?this:this.clone(!0),x(i[s])[t](n),h.apply(r,n.get());return this.pushStack(r)}}),x.extend({clone:function(e,t,n){var r,i,o,s,a=e.cloneNode(!0),u=x.contains(e.ownerDocument,e);if(!(x.support.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||x.isXMLDoc(e)))for(s=mt(a),o=mt(e),r=0,i=o.length;i>r;r++)yt(o[r],s[r]);if(t)if(n)for(o=o||mt(e),s=s||mt(a),r=0,i=o.length;i>r;r++)gt(o[r],s[r]);else gt(e,a);return s=mt(a,"script"),s.length>0&&dt(s,!u&&mt(e,"script")),a},buildFragment:function(e,t,n,r){var i,o,s,a,u,l,c=0,p=e.length,f=t.createDocumentFragment(),h=[];for(;p>c;c++)if(i=e[c],i||0===i)if("object"===x.type(i))x.merge(h,i.nodeType?[i]:i);else if(rt.test(i)){o=o||f.appendChild(t.createElement("div")),s=(nt.exec(i)||["",""])[1].toLowerCase(),a=ct[s]||ct._default,o.innerHTML=a[1]+i.replace(tt,"<$1></$2>")+a[2],l=a[0];while(l--)o=o.lastChild;x.merge(h,o.childNodes),o=f.firstChild,o.textContent=""}else h.push(t.createTextNode(i));f.textContent="",c=0;while(i=h[c++])if((!r||-1===x.inArray(i,r))&&(u=x.contains(i.ownerDocument,i),o=mt(f.appendChild(i),"script"),u&&dt(o),n)){l=0;while(i=o[l++])at.test(i.type||"")&&n.push(i)}return f},cleanData:function(e){var t,n,r,i,o,s,a=x.event.special,u=0;for(;(n=e[u])!==undefined;u++){if(F.accepts(n)&&(o=n[q.expando],o&&(t=q.cache[o]))){if(r=Object.keys(t.events||{}),r.length)for(s=0;(i=r[s])!==undefined;s++)a[i]?x.event.remove(n,i):x.removeEvent(n,i,t.handle);q.cache[o]&&delete q.cache[o]}delete L.cache[n[L.expando]]}},_evalUrl:function(e){return x.ajax({url:e,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0})}});function pt(e,t){return x.nodeName(e,"table")&&x.nodeName(1===t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e.appendChild(e.ownerDocument.createElement("tbody")):e}function ft(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function ht(e){var t=ut.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function dt(e,t){var n=e.length,r=0;for(;n>r;r++)q.set(e[r],"globalEval",!t||q.get(t[r],"globalEval"))}function gt(e,t){var n,r,i,o,s,a,u,l;if(1===t.nodeType){if(q.hasData(e)&&(o=q.access(e),s=q.set(t,o),l=o.events)){delete s.handle,s.events={};for(i in l)for(n=0,r=l[i].length;r>n;n++)x.event.add(t,i,l[i][n])}L.hasData(e)&&(a=L.access(e),u=x.extend({},a),L.set(t,u))}}function mt(e,t){var n=e.getElementsByTagName?e.getElementsByTagName(t||"*"):e.querySelectorAll?e.querySelectorAll(t||"*"):[];return t===undefined||t&&x.nodeName(e,t)?x.merge([e],n):n}function yt(e,t){var n=t.nodeName.toLowerCase();"input"===n&&ot.test(e.type)?t.checked=e.checked:("input"===n||"textarea"===n)&&(t.defaultValue=e.defaultValue)}x.fn.extend({wrapAll:function(e){var t;return x.isFunction(e)?this.each(function(t){x(this).wrapAll(e.call(this,t))}):(this[0]&&(t=x(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this)},wrapInner:function(e){return x.isFunction(e)?this.each(function(t){x(this).wrapInner(e.call(this,t))}):this.each(function(){var t=x(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=x.isFunction(e);return this.each(function(n){x(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(){return this.parent().each(function(){x.nodeName(this,"body")||x(this).replaceWith(this.childNodes)}).end()}});var vt,xt,bt=/^(none|table(?!-c[ea]).+)/,wt=/^margin/,Tt=RegExp("^("+b+")(.*)$","i"),Ct=RegExp("^("+b+")(?!px)[a-z%]+$","i"),kt=RegExp("^([+-])=("+b+")","i"),Nt={BODY:"block"},Et={position:"absolute",visibility:"hidden",display:"block"},St={letterSpacing:0,fontWeight:400},jt=["Top","Right","Bottom","Left"],Dt=["Webkit","O","Moz","ms"];function At(e,t){if(t in e)return t;var n=t.charAt(0).toUpperCase()+t.slice(1),r=t,i=Dt.length;while(i--)if(t=Dt[i]+n,t in e)return t;return r}function Lt(e,t){return e=t||e,"none"===x.css(e,"display")||!x.contains(e.ownerDocument,e)}function qt(t){return e.getComputedStyle(t,null)}function Ht(e,t){var n,r,i,o=[],s=0,a=e.length;for(;a>s;s++)r=e[s],r.style&&(o[s]=q.get(r,"olddisplay"),n=r.style.display,t?(o[s]||"none"!==n||(r.style.display=""),""===r.style.display&&Lt(r)&&(o[s]=q.access(r,"olddisplay",Rt(r.nodeName)))):o[s]||(i=Lt(r),(n&&"none"!==n||!i)&&q.set(r,"olddisplay",i?n:x.css(r,"display"))));for(s=0;a>s;s++)r=e[s],r.style&&(t&&"none"!==r.style.display&&""!==r.style.display||(r.style.display=t?o[s]||"":"none"));return e}x.fn.extend({css:function(e,t){return x.access(this,function(e,t,n){var r,i,o={},s=0;if(x.isArray(t)){for(r=qt(e),i=t.length;i>s;s++)o[t[s]]=x.css(e,t[s],!1,r);return o}return n!==undefined?x.style(e,t,n):x.css(e,t)},e,t,arguments.length>1)},show:function(){return Ht(this,!0)},hide:function(){return Ht(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){Lt(this)?x(this).show():x(this).hide()})}}),x.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=vt(e,"opacity");return""===n?"1":n}}}},cssNumber:{columnCount:!0,fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,s,a=x.camelCase(t),u=e.style;return t=x.cssProps[a]||(x.cssProps[a]=At(u,a)),s=x.cssHooks[t]||x.cssHooks[a],n===undefined?s&&"get"in s&&(i=s.get(e,!1,r))!==undefined?i:u[t]:(o=typeof n,"string"===o&&(i=kt.exec(n))&&(n=(i[1]+1)*i[2]+parseFloat(x.css(e,t)),o="number"),null==n||"number"===o&&isNaN(n)||("number"!==o||x.cssNumber[a]||(n+="px"),x.support.clearCloneStyle||""!==n||0!==t.indexOf("background")||(u[t]="inherit"),s&&"set"in s&&(n=s.set(e,n,r))===undefined||(u[t]=n)),undefined)}},css:function(e,t,n,r){var i,o,s,a=x.camelCase(t);return t=x.cssProps[a]||(x.cssProps[a]=At(e.style,a)),s=x.cssHooks[t]||x.cssHooks[a],s&&"get"in s&&(i=s.get(e,!0,n)),i===undefined&&(i=vt(e,t,r)),"normal"===i&&t in St&&(i=St[t]),""===n||n?(o=parseFloat(i),n===!0||x.isNumeric(o)?o||0:i):i}}),vt=function(e,t,n){var r,i,o,s=n||qt(e),a=s?s.getPropertyValue(t)||s[t]:undefined,u=e.style;return s&&(""!==a||x.contains(e.ownerDocument,e)||(a=x.style(e,t)),Ct.test(a)&&wt.test(t)&&(r=u.width,i=u.minWidth,o=u.maxWidth,u.minWidth=u.maxWidth=u.width=a,a=s.width,u.width=r,u.minWidth=i,u.maxWidth=o)),a};function Ot(e,t,n){var r=Tt.exec(t);return r?Math.max(0,r[1]-(n||0))+(r[2]||"px"):t}function Ft(e,t,n,r,i){var o=n===(r?"border":"content")?4:"width"===t?1:0,s=0;for(;4>o;o+=2)"margin"===n&&(s+=x.css(e,n+jt[o],!0,i)),r?("content"===n&&(s-=x.css(e,"padding"+jt[o],!0,i)),"margin"!==n&&(s-=x.css(e,"border"+jt[o]+"Width",!0,i))):(s+=x.css(e,"padding"+jt[o],!0,i),"padding"!==n&&(s+=x.css(e,"border"+jt[o]+"Width",!0,i)));return s}function Pt(e,t,n){var r=!0,i="width"===t?e.offsetWidth:e.offsetHeight,o=qt(e),s=x.support.boxSizing&&"border-box"===x.css(e,"boxSizing",!1,o);if(0>=i||null==i){if(i=vt(e,t,o),(0>i||null==i)&&(i=e.style[t]),Ct.test(i))return i;r=s&&(x.support.boxSizingReliable||i===e.style[t]),i=parseFloat(i)||0}return i+Ft(e,t,n||(s?"border":"content"),r,o)+"px"}function Rt(e){var t=o,n=Nt[e];return n||(n=Mt(e,t),"none"!==n&&n||(xt=(xt||x("<iframe frameborder='0' width='0' height='0'/>").css("cssText","display:block !important")).appendTo(t.documentElement),t=(xt[0].contentWindow||xt[0].contentDocument).document,t.write("<!doctype html><html><body>"),t.close(),n=Mt(e,t),xt.detach()),Nt[e]=n),n}function Mt(e,t){var n=x(t.createElement(e)).appendTo(t.body),r=x.css(n[0],"display");return n.remove(),r}x.each(["height","width"],function(e,t){x.cssHooks[t]={get:function(e,n,r){return n?0===e.offsetWidth&&bt.test(x.css(e,"display"))?x.swap(e,Et,function(){return Pt(e,t,r)}):Pt(e,t,r):undefined},set:function(e,n,r){var i=r&&qt(e);return Ot(e,n,r?Ft(e,t,r,x.support.boxSizing&&"border-box"===x.css(e,"boxSizing",!1,i),i):0)}}}),x(function(){x.support.reliableMarginRight||(x.cssHooks.marginRight={get:function(e,t){return t?x.swap(e,{display:"inline-block"},vt,[e,"marginRight"]):undefined}}),!x.support.pixelPosition&&x.fn.position&&x.each(["top","left"],function(e,t){x.cssHooks[t]={get:function(e,n){return n?(n=vt(e,t),Ct.test(n)?x(e).position()[t]+"px":n):undefined}}})}),x.expr&&x.expr.filters&&(x.expr.filters.hidden=function(e){return 0>=e.offsetWidth&&0>=e.offsetHeight},x.expr.filters.visible=function(e){return!x.expr.filters.hidden(e)}),x.each({margin:"",padding:"",border:"Width"},function(e,t){x.cssHooks[e+t]={expand:function(n){var r=0,i={},o="string"==typeof n?n.split(" "):[n];for(;4>r;r++)i[e+jt[r]+t]=o[r]||o[r-2]||o[0];return i}},wt.test(e)||(x.cssHooks[e+t].set=Ot)});var Wt=/%20/g,$t=/\[\]$/,Bt=/\r?\n/g,It=/^(?:submit|button|image|reset|file)$/i,zt=/^(?:input|select|textarea|keygen)/i;x.fn.extend({serialize:function(){return x.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=x.prop(this,"elements");return e?x.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!x(this).is(":disabled")&&zt.test(this.nodeName)&&!It.test(e)&&(this.checked||!ot.test(e))}).map(function(e,t){var n=x(this).val();return null==n?null:x.isArray(n)?x.map(n,function(e){return{name:t.name,value:e.replace(Bt,"\r\n")}}):{name:t.name,value:n.replace(Bt,"\r\n")}}).get()}}),x.param=function(e,t){var n,r=[],i=function(e,t){t=x.isFunction(t)?t():null==t?"":t,r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(t)};if(t===undefined&&(t=x.ajaxSettings&&x.ajaxSettings.traditional),x.isArray(e)||e.jquery&&!x.isPlainObject(e))x.each(e,function(){i(this.name,this.value)});else for(n in e)_t(n,e[n],t,i);return r.join("&").replace(Wt,"+")};function _t(e,t,n,r){var i;if(x.isArray(t))x.each(t,function(t,i){n||$t.test(e)?r(e,i):_t(e+"["+("object"==typeof i?t:"")+"]",i,n,r)});else if(n||"object"!==x.type(t))r(e,t);else for(i in t)_t(e+"["+i+"]",t[i],n,r)}x.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(e,t){x.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),x.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)},bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)
+},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}});var Xt,Ut,Yt=x.now(),Vt=/\?/,Gt=/#.*$/,Jt=/([?&])_=[^&]*/,Qt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Kt=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Zt=/^(?:GET|HEAD)$/,en=/^\/\//,tn=/^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,nn=x.fn.load,rn={},on={},sn="*/".concat("*");try{Ut=i.href}catch(an){Ut=o.createElement("a"),Ut.href="",Ut=Ut.href}Xt=tn.exec(Ut.toLowerCase())||[];function un(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,o=t.toLowerCase().match(w)||[];if(x.isFunction(n))while(r=o[i++])"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function ln(e,t,n,r){var i={},o=e===on;function s(a){var u;return i[a]=!0,x.each(e[a]||[],function(e,a){var l=a(t,n,r);return"string"!=typeof l||o||i[l]?o?!(u=l):undefined:(t.dataTypes.unshift(l),s(l),!1)}),u}return s(t.dataTypes[0])||!i["*"]&&s("*")}function cn(e,t){var n,r,i=x.ajaxSettings.flatOptions||{};for(n in t)t[n]!==undefined&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&x.extend(!0,e,r),e}x.fn.load=function(e,t,n){if("string"!=typeof e&&nn)return nn.apply(this,arguments);var r,i,o,s=this,a=e.indexOf(" ");return a>=0&&(r=e.slice(a),e=e.slice(0,a)),x.isFunction(t)?(n=t,t=undefined):t&&"object"==typeof t&&(i="POST"),s.length>0&&x.ajax({url:e,type:i,dataType:"html",data:t}).done(function(e){o=arguments,s.html(r?x("<div>").append(x.parseHTML(e)).find(r):e)}).complete(n&&function(e,t){s.each(n,o||[e.responseText,t,e])}),this},x.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){x.fn[t]=function(e){return this.on(t,e)}}),x.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ut,type:"GET",isLocal:Kt.test(Xt[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":sn,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":x.parseJSON,"text xml":x.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?cn(cn(e,x.ajaxSettings),t):cn(x.ajaxSettings,e)},ajaxPrefilter:un(rn),ajaxTransport:un(on),ajax:function(e,t){"object"==typeof e&&(t=e,e=undefined),t=t||{};var n,r,i,o,s,a,u,l,c=x.ajaxSetup({},t),p=c.context||c,f=c.context&&(p.nodeType||p.jquery)?x(p):x.event,h=x.Deferred(),d=x.Callbacks("once memory"),g=c.statusCode||{},m={},y={},v=0,b="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(2===v){if(!o){o={};while(t=Qt.exec(i))o[t[1].toLowerCase()]=t[2]}t=o[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return 2===v?i:null},setRequestHeader:function(e,t){var n=e.toLowerCase();return v||(e=y[n]=y[n]||e,m[e]=t),this},overrideMimeType:function(e){return v||(c.mimeType=e),this},statusCode:function(e){var t;if(e)if(2>v)for(t in e)g[t]=[g[t],e[t]];else T.always(e[T.status]);return this},abort:function(e){var t=e||b;return n&&n.abort(t),k(0,t),this}};if(h.promise(T).complete=d.add,T.success=T.done,T.error=T.fail,c.url=((e||c.url||Ut)+"").replace(Gt,"").replace(en,Xt[1]+"//"),c.type=t.method||t.type||c.method||c.type,c.dataTypes=x.trim(c.dataType||"*").toLowerCase().match(w)||[""],null==c.crossDomain&&(a=tn.exec(c.url.toLowerCase()),c.crossDomain=!(!a||a[1]===Xt[1]&&a[2]===Xt[2]&&(a[3]||("http:"===a[1]?"80":"443"))===(Xt[3]||("http:"===Xt[1]?"80":"443")))),c.data&&c.processData&&"string"!=typeof c.data&&(c.data=x.param(c.data,c.traditional)),ln(rn,c,t,T),2===v)return T;u=c.global,u&&0===x.active++&&x.event.trigger("ajaxStart"),c.type=c.type.toUpperCase(),c.hasContent=!Zt.test(c.type),r=c.url,c.hasContent||(c.data&&(r=c.url+=(Vt.test(r)?"&":"?")+c.data,delete c.data),c.cache===!1&&(c.url=Jt.test(r)?r.replace(Jt,"$1_="+Yt++):r+(Vt.test(r)?"&":"?")+"_="+Yt++)),c.ifModified&&(x.lastModified[r]&&T.setRequestHeader("If-Modified-Since",x.lastModified[r]),x.etag[r]&&T.setRequestHeader("If-None-Match",x.etag[r])),(c.data&&c.hasContent&&c.contentType!==!1||t.contentType)&&T.setRequestHeader("Content-Type",c.contentType),T.setRequestHeader("Accept",c.dataTypes[0]&&c.accepts[c.dataTypes[0]]?c.accepts[c.dataTypes[0]]+("*"!==c.dataTypes[0]?", "+sn+"; q=0.01":""):c.accepts["*"]);for(l in c.headers)T.setRequestHeader(l,c.headers[l]);if(c.beforeSend&&(c.beforeSend.call(p,T,c)===!1||2===v))return T.abort();b="abort";for(l in{success:1,error:1,complete:1})T[l](c[l]);if(n=ln(on,c,t,T)){T.readyState=1,u&&f.trigger("ajaxSend",[T,c]),c.async&&c.timeout>0&&(s=setTimeout(function(){T.abort("timeout")},c.timeout));try{v=1,n.send(m,k)}catch(C){if(!(2>v))throw C;k(-1,C)}}else k(-1,"No Transport");function k(e,t,o,a){var l,m,y,b,w,C=t;2!==v&&(v=2,s&&clearTimeout(s),n=undefined,i=a||"",T.readyState=e>0?4:0,l=e>=200&&300>e||304===e,o&&(b=pn(c,T,o)),b=fn(c,b,T,l),l?(c.ifModified&&(w=T.getResponseHeader("Last-Modified"),w&&(x.lastModified[r]=w),w=T.getResponseHeader("etag"),w&&(x.etag[r]=w)),204===e||"HEAD"===c.type?C="nocontent":304===e?C="notmodified":(C=b.state,m=b.data,y=b.error,l=!y)):(y=C,(e||!C)&&(C="error",0>e&&(e=0))),T.status=e,T.statusText=(t||C)+"",l?h.resolveWith(p,[m,C,T]):h.rejectWith(p,[T,C,y]),T.statusCode(g),g=undefined,u&&f.trigger(l?"ajaxSuccess":"ajaxError",[T,c,l?m:y]),d.fireWith(p,[T,C]),u&&(f.trigger("ajaxComplete",[T,c]),--x.active||x.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return x.get(e,t,n,"json")},getScript:function(e,t){return x.get(e,undefined,t,"script")}}),x.each(["get","post"],function(e,t){x[t]=function(e,n,r,i){return x.isFunction(n)&&(i=i||r,r=n,n=undefined),x.ajax({url:e,type:t,dataType:i,data:n,success:r})}});function pn(e,t,n){var r,i,o,s,a=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),r===undefined&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in a)if(a[i]&&a[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}s||(s=i)}o=o||s}return o?(o!==u[0]&&u.unshift(o),n[o]):undefined}function fn(e,t,n,r){var i,o,s,a,u,l={},c=e.dataTypes.slice();if(c[1])for(s in e.converters)l[s.toLowerCase()]=e.converters[s];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(s=l[u+" "+o]||l["* "+o],!s)for(i in l)if(a=i.split(" "),a[1]===o&&(s=l[u+" "+a[0]]||l["* "+a[0]])){s===!0?s=l[i]:l[i]!==!0&&(o=a[0],c.unshift(a[1]));break}if(s!==!0)if(s&&e["throws"])t=s(t);else try{t=s(t)}catch(p){return{state:"parsererror",error:s?p:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}x.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(e){return x.globalEval(e),e}}}),x.ajaxPrefilter("script",function(e){e.cache===undefined&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),x.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,i){t=x("<script>").prop({async:!0,charset:e.scriptCharset,src:e.url}).on("load error",n=function(e){t.remove(),n=null,e&&i("error"===e.type?404:200,e.type)}),o.head.appendChild(t[0])},abort:function(){n&&n()}}}});var hn=[],dn=/(=)\?(?=&|$)|\?\?/;x.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=hn.pop()||x.expando+"_"+Yt++;return this[e]=!0,e}}),x.ajaxPrefilter("json jsonp",function(t,n,r){var i,o,s,a=t.jsonp!==!1&&(dn.test(t.url)?"url":"string"==typeof t.data&&!(t.contentType||"").indexOf("application/x-www-form-urlencoded")&&dn.test(t.data)&&"data");return a||"jsonp"===t.dataTypes[0]?(i=t.jsonpCallback=x.isFunction(t.jsonpCallback)?t.jsonpCallback():t.jsonpCallback,a?t[a]=t[a].replace(dn,"$1"+i):t.jsonp!==!1&&(t.url+=(Vt.test(t.url)?"&":"?")+t.jsonp+"="+i),t.converters["script json"]=function(){return s||x.error(i+" was not called"),s[0]},t.dataTypes[0]="json",o=e[i],e[i]=function(){s=arguments},r.always(function(){e[i]=o,t[i]&&(t.jsonpCallback=n.jsonpCallback,hn.push(i)),s&&x.isFunction(o)&&o(s[0]),s=o=undefined}),"script"):undefined}),x.ajaxSettings.xhr=function(){try{return new XMLHttpRequest}catch(e){}};var gn=x.ajaxSettings.xhr(),mn={0:200,1223:204},yn=0,vn={};e.ActiveXObject&&x(e).on("unload",function(){for(var e in vn)vn[e]();vn=undefined}),x.support.cors=!!gn&&"withCredentials"in gn,x.support.ajax=gn=!!gn,x.ajaxTransport(function(e){var t;return x.support.cors||gn&&!e.crossDomain?{send:function(n,r){var i,o,s=e.xhr();if(s.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(i in e.xhrFields)s[i]=e.xhrFields[i];e.mimeType&&s.overrideMimeType&&s.overrideMimeType(e.mimeType),e.crossDomain||n["X-Requested-With"]||(n["X-Requested-With"]="XMLHttpRequest");for(i in n)s.setRequestHeader(i,n[i]);t=function(e){return function(){t&&(delete vn[o],t=s.onload=s.onerror=null,"abort"===e?s.abort():"error"===e?r(s.status||404,s.statusText):r(mn[s.status]||s.status,s.statusText,"string"==typeof s.responseText?{text:s.responseText}:undefined,s.getAllResponseHeaders()))}},s.onload=t(),s.onerror=t("error"),t=vn[o=yn++]=t("abort"),s.send(e.hasContent&&e.data||null)},abort:function(){t&&t()}}:undefined});var xn,bn,wn=/^(?:toggle|show|hide)$/,Tn=RegExp("^(?:([+-])=|)("+b+")([a-z%]*)$","i"),Cn=/queueHooks$/,kn=[An],Nn={"*":[function(e,t){var n=this.createTween(e,t),r=n.cur(),i=Tn.exec(t),o=i&&i[3]||(x.cssNumber[e]?"":"px"),s=(x.cssNumber[e]||"px"!==o&&+r)&&Tn.exec(x.css(n.elem,e)),a=1,u=20;if(s&&s[3]!==o){o=o||s[3],i=i||[],s=+r||1;do a=a||".5",s/=a,x.style(n.elem,e,s+o);while(a!==(a=n.cur()/r)&&1!==a&&--u)}return i&&(s=n.start=+s||+r||0,n.unit=o,n.end=i[1]?s+(i[1]+1)*i[2]:+i[2]),n}]};function En(){return setTimeout(function(){xn=undefined}),xn=x.now()}function Sn(e,t,n){var r,i=(Nn[t]||[]).concat(Nn["*"]),o=0,s=i.length;for(;s>o;o++)if(r=i[o].call(n,t,e))return r}function jn(e,t,n){var r,i,o=0,s=kn.length,a=x.Deferred().always(function(){delete u.elem}),u=function(){if(i)return!1;var t=xn||En(),n=Math.max(0,l.startTime+l.duration-t),r=n/l.duration||0,o=1-r,s=0,u=l.tweens.length;for(;u>s;s++)l.tweens[s].run(o);return a.notifyWith(e,[l,o,n]),1>o&&u?n:(a.resolveWith(e,[l]),!1)},l=a.promise({elem:e,props:x.extend({},t),opts:x.extend(!0,{specialEasing:{}},n),originalProperties:t,originalOptions:n,startTime:xn||En(),duration:n.duration,tweens:[],createTween:function(t,n){var r=x.Tween(e,l.opts,t,n,l.opts.specialEasing[t]||l.opts.easing);return l.tweens.push(r),r},stop:function(t){var n=0,r=t?l.tweens.length:0;if(i)return this;for(i=!0;r>n;n++)l.tweens[n].run(1);return t?a.resolveWith(e,[l,t]):a.rejectWith(e,[l,t]),this}}),c=l.props;for(Dn(c,l.opts.specialEasing);s>o;o++)if(r=kn[o].call(l,e,c,l.opts))return r;return x.map(c,Sn,l),x.isFunction(l.opts.start)&&l.opts.start.call(e,l),x.fx.timer(x.extend(u,{elem:e,anim:l,queue:l.opts.queue})),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always)}function Dn(e,t){var n,r,i,o,s;for(n in e)if(r=x.camelCase(n),i=t[r],o=e[n],x.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),s=x.cssHooks[r],s&&"expand"in s){o=s.expand(o),delete e[r];for(n in o)n in e||(e[n]=o[n],t[n]=i)}else t[r]=i}x.Animation=x.extend(jn,{tweener:function(e,t){x.isFunction(e)?(t=e,e=["*"]):e=e.split(" ");var n,r=0,i=e.length;for(;i>r;r++)n=e[r],Nn[n]=Nn[n]||[],Nn[n].unshift(t)},prefilter:function(e,t){t?kn.unshift(e):kn.push(e)}});function An(e,t,n){var r,i,o,s,a,u,l=this,c={},p=e.style,f=e.nodeType&&Lt(e),h=q.get(e,"fxshow");n.queue||(a=x._queueHooks(e,"fx"),null==a.unqueued&&(a.unqueued=0,u=a.empty.fire,a.empty.fire=function(){a.unqueued||u()}),a.unqueued++,l.always(function(){l.always(function(){a.unqueued--,x.queue(e,"fx").length||a.empty.fire()})})),1===e.nodeType&&("height"in t||"width"in t)&&(n.overflow=[p.overflow,p.overflowX,p.overflowY],"inline"===x.css(e,"display")&&"none"===x.css(e,"float")&&(p.display="inline-block")),n.overflow&&(p.overflow="hidden",l.always(function(){p.overflow=n.overflow[0],p.overflowX=n.overflow[1],p.overflowY=n.overflow[2]}));for(r in t)if(i=t[r],wn.exec(i)){if(delete t[r],o=o||"toggle"===i,i===(f?"hide":"show")){if("show"!==i||!h||h[r]===undefined)continue;f=!0}c[r]=h&&h[r]||x.style(e,r)}if(!x.isEmptyObject(c)){h?"hidden"in h&&(f=h.hidden):h=q.access(e,"fxshow",{}),o&&(h.hidden=!f),f?x(e).show():l.done(function(){x(e).hide()}),l.done(function(){var t;q.remove(e,"fxshow");for(t in c)x.style(e,t,c[t])});for(r in c)s=Sn(f?h[r]:0,r,l),r in h||(h[r]=s.start,f&&(s.end=s.start,s.start="width"===r||"height"===r?1:0))}}function Ln(e,t,n,r,i){return new Ln.prototype.init(e,t,n,r,i)}x.Tween=Ln,Ln.prototype={constructor:Ln,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||"swing",this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(x.cssNumber[n]?"":"px")},cur:function(){var e=Ln.propHooks[this.prop];return e&&e.get?e.get(this):Ln.propHooks._default.get(this)},run:function(e){var t,n=Ln.propHooks[this.prop];return this.pos=t=this.options.duration?x.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):Ln.propHooks._default.set(this),this}},Ln.prototype.init.prototype=Ln.prototype,Ln.propHooks={_default:{get:function(e){var t;return null==e.elem[e.prop]||e.elem.style&&null!=e.elem.style[e.prop]?(t=x.css(e.elem,e.prop,""),t&&"auto"!==t?t:0):e.elem[e.prop]},set:function(e){x.fx.step[e.prop]?x.fx.step[e.prop](e):e.elem.style&&(null!=e.elem.style[x.cssProps[e.prop]]||x.cssHooks[e.prop])?x.style(e.elem,e.prop,e.now+e.unit):e.elem[e.prop]=e.now}}},Ln.propHooks.scrollTop=Ln.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},x.each(["toggle","show","hide"],function(e,t){var n=x.fn[t];x.fn[t]=function(e,r,i){return null==e||"boolean"==typeof e?n.apply(this,arguments):this.animate(qn(t,!0),e,r,i)}}),x.fn.extend({fadeTo:function(e,t,n,r){return this.filter(Lt).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=x.isEmptyObject(e),o=x.speed(t,n,r),s=function(){var t=jn(this,x.extend({},e),o);(i||q.get(this,"finish"))&&t.stop(!0)};return s.finish=s,i||o.queue===!1?this.each(s):this.queue(o.queue,s)},stop:function(e,t,n){var r=function(e){var t=e.stop;delete e.stop,t(n)};return"string"!=typeof e&&(n=t,t=e,e=undefined),t&&e!==!1&&this.queue(e||"fx",[]),this.each(function(){var t=!0,i=null!=e&&e+"queueHooks",o=x.timers,s=q.get(this);if(i)s[i]&&s[i].stop&&r(s[i]);else for(i in s)s[i]&&s[i].stop&&Cn.test(i)&&r(s[i]);for(i=o.length;i--;)o[i].elem!==this||null!=e&&o[i].queue!==e||(o[i].anim.stop(n),t=!1,o.splice(i,1));(t||!n)&&x.dequeue(this,e)})},finish:function(e){return e!==!1&&(e=e||"fx"),this.each(function(){var t,n=q.get(this),r=n[e+"queue"],i=n[e+"queueHooks"],o=x.timers,s=r?r.length:0;for(n.finish=!0,x.queue(this,e,[]),i&&i.stop&&i.stop.call(this,!0),t=o.length;t--;)o[t].elem===this&&o[t].queue===e&&(o[t].anim.stop(!0),o.splice(t,1));for(t=0;s>t;t++)r[t]&&r[t].finish&&r[t].finish.call(this);delete n.finish})}});function qn(e,t){var n,r={height:e},i=0;for(t=t?1:0;4>i;i+=2-t)n=jt[i],r["margin"+n]=r["padding"+n]=e;return t&&(r.opacity=r.width=e),r}x.each({slideDown:qn("show"),slideUp:qn("hide"),slideToggle:qn("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,t){x.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}}),x.speed=function(e,t,n){var r=e&&"object"==typeof e?x.extend({},e):{complete:n||!n&&t||x.isFunction(e)&&e,duration:e,easing:n&&t||t&&!x.isFunction(t)&&t};return r.duration=x.fx.off?0:"number"==typeof r.duration?r.duration:r.duration in x.fx.speeds?x.fx.speeds[r.duration]:x.fx.speeds._default,(null==r.queue||r.queue===!0)&&(r.queue="fx"),r.old=r.complete,r.complete=function(){x.isFunction(r.old)&&r.old.call(this),r.queue&&x.dequeue(this,r.queue)},r},x.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2}},x.timers=[],x.fx=Ln.prototype.init,x.fx.tick=function(){var e,t=x.timers,n=0;for(xn=x.now();t.length>n;n++)e=t[n],e()||t[n]!==e||t.splice(n--,1);t.length||x.fx.stop(),xn=undefined},x.fx.timer=function(e){e()&&x.timers.push(e)&&x.fx.start()},x.fx.interval=13,x.fx.start=function(){bn||(bn=setInterval(x.fx.tick,x.fx.interval))},x.fx.stop=function(){clearInterval(bn),bn=null},x.fx.speeds={slow:600,fast:200,_default:400},x.fx.step={},x.expr&&x.expr.filters&&(x.expr.filters.animated=function(e){return x.grep(x.timers,function(t){return e===t.elem}).length}),x.fn.offset=function(e){if(arguments.length)return e===undefined?this:this.each(function(t){x.offset.setOffset(this,e,t)});var t,n,i=this[0],o={top:0,left:0},s=i&&i.ownerDocument;if(s)return t=s.documentElement,x.contains(t,i)?(typeof i.getBoundingClientRect!==r&&(o=i.getBoundingClientRect()),n=Hn(s),{top:o.top+n.pageYOffset-t.clientTop,left:o.left+n.pageXOffset-t.clientLeft}):o},x.offset={setOffset:function(e,t,n){var r,i,o,s,a,u,l,c=x.css(e,"position"),p=x(e),f={};"static"===c&&(e.style.position="relative"),a=p.offset(),o=x.css(e,"top"),u=x.css(e,"left"),l=("absolute"===c||"fixed"===c)&&(o+u).indexOf("auto")>-1,l?(r=p.position(),s=r.top,i=r.left):(s=parseFloat(o)||0,i=parseFloat(u)||0),x.isFunction(t)&&(t=t.call(e,n,a)),null!=t.top&&(f.top=t.top-a.top+s),null!=t.left&&(f.left=t.left-a.left+i),"using"in t?t.using.call(e,f):p.css(f)}},x.fn.extend({position:function(){if(this[0]){var e,t,n=this[0],r={top:0,left:0};return"fixed"===x.css(n,"position")?t=n.getBoundingClientRect():(e=this.offsetParent(),t=this.offset(),x.nodeName(e[0],"html")||(r=e.offset()),r.top+=x.css(e[0],"borderTopWidth",!0),r.left+=x.css(e[0],"borderLeftWidth",!0)),{top:t.top-r.top-x.css(n,"marginTop",!0),left:t.left-r.left-x.css(n,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||s;while(e&&!x.nodeName(e,"html")&&"static"===x.css(e,"position"))e=e.offsetParent;return e||s})}}),x.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,n){var r="pageYOffset"===n;x.fn[t]=function(i){return x.access(this,function(t,i,o){var s=Hn(t);return o===undefined?s?s[n]:t[i]:(s?s.scrollTo(r?e.pageXOffset:o,r?o:e.pageYOffset):t[i]=o,undefined)},t,i,arguments.length,null)}});function Hn(e){return x.isWindow(e)?e:9===e.nodeType&&e.defaultView}x.each({Height:"height",Width:"width"},function(e,t){x.each({padding:"inner"+e,content:t,"":"outer"+e},function(n,r){x.fn[r]=function(r,i){var o=arguments.length&&(n||"boolean"!=typeof r),s=n||(r===!0||i===!0?"margin":"border");return x.access(this,function(t,n,r){var i;return x.isWindow(t)?t.document.documentElement["client"+e]:9===t.nodeType?(i=t.documentElement,Math.max(t.body["scroll"+e],i["scroll"+e],t.body["offset"+e],i["offset"+e],i["client"+e])):r===undefined?x.css(t,n,s):x.style(t,n,r,s)},t,o?r:undefined,o,null)}})}),x.fn.size=function(){return this.length},x.fn.andSelf=x.fn.addBack,"object"==typeof module&&module&&"object"==typeof module.exports?module.exports=x:"function"==typeof define&&define.amd&&define("jquery",[],function(){return x}),"object"==typeof e&&"object"==typeof e.document&&(e.jQuery=e.$=x)})(window);
diff --git a/src/rustdoc_ng/html/static/main.css b/src/rustdoc_ng/html/static/main.css
new file mode 100644
index 00000000000..2b965168129
--- /dev/null
+++ b/src/rustdoc_ng/html/static/main.css
@@ -0,0 +1,270 @@
+/**
+ * Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+ * file at the top-level directory of this distribution and at
+ * http://rust-lang.org/COPYRIGHT.
+ *
+ * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ * option. This file may not be copied, modified, or distributed
+ * except according to those terms.
+ */
+
+@import "normalize.css";
+
+* {
+  -webkit-box-sizing: border-box;
+     -moz-box-sizing: border-box;
+          box-sizing: border-box;
+}
+
+/* Fonts */
+
+body {
+    font: 13px Arial, sans-serif;
+    line-height: 165%;
+}
+
+h1, .sidebar .location {
+    font: 700 22px "Oswald", Arial, sans-serif;
+}
+
+h2, h3, h4 {
+    font: 700 16px "Oswald", Arial, sans-serif;
+    text-transform: uppercase;
+}
+
+h2 code, h3 code, h4 code {
+    text-transform: none;
+    font-size: 1.2em;
+}
+
+code, pre, h1.fqn {
+    font: 15px "Inconsolata", "Consolas", "Courier New", monospace;
+}
+h1.fqn {
+    font-size: 26px;
+    font-weight: normal;
+}
+
+nav {
+    font: 700 26px "Oswald", Arial, sans-serif;
+    text-transform: uppercase;
+}
+
+nav.sub {
+    padding-top: 20px;
+    font: 700 16px "Oswald", Arial, sans-serif;
+    text-transform: uppercase;
+    text-align: right;
+}
+
+/* General structure */
+
+html, body {
+    min-height: 100%;
+    height: 100%;
+}
+
+body {
+    position: relative;
+    height: auto;
+    padding-bottom: 20px;
+}
+
+.sidebar {
+    width: 200px;
+    position: absolute;
+    left: 0;
+    top: 0;
+    min-height: 100%;
+}
+
+.content, nav { max-width: 960px; }
+
+/* Everything else */
+
+.js-only, .hidden { display: none; }
+
+.sidebar {
+    background: #e9e9e9;
+    padding: 10px;
+}
+
+.sidebar img {
+    margin: 20px auto;
+    display: block;
+}
+
+.sidebar .location { margin-bottom: 10px; }
+.sidebar .block, pre { background: #fff; }
+.sidebar .block, pre, .content { border-bottom: 2px solid black; }
+.trait { border-color: #fcae2b !important; }
+.mod { border-color: #809fc7 !important; }
+.enum { border-color: #93bc99 !important; }
+.struct { border-color: #e53700 !important; }
+.fn { border-color: #a2777f !important; }
+
+.block {
+    padding: 10px;
+    margin-bottom: 10px;
+}
+.block h2 { margin-top: 0; }
+
+.content {
+    background: #f3f3f3;
+    padding: 20px 20px 20px 40px;
+}
+.content h1 { margin-top: 0; }
+.content h1, .content h2 { margin-left: -20px; }
+.content pre { padding: 20px; }
+
+.content .highlighted {
+    cursor: pointer;
+    color: #000 !important;
+    background-color: #ccc;
+}
+.content .highlighted a { color: #000 !important; }
+.content .highlighted.trait { background-color: #fece7e; }
+.content .highlighted.mod { background-color: #afc6e4; }
+.content .highlighted.enum { background-color: #b4d1b9; }
+.content .highlighted.struct { background-color: #e7b1a0; }
+.content .highlighted.fn { background-color: #c6afb3; }
+
+.docblock.short.nowrap {
+    display: block;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+}
+.docblock.short p {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    margin: 0;
+}
+
+.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5 {
+    margin-left: 0;
+}
+
+.docblock h1 { font-size: 1.1em; }
+.docblock h2 { font-size: 1.05em; }
+.docblock h3, .docblock h4, .docblock h5 { font-size: 1em; }
+
+.content .source { float: right; }
+.content table {
+    border-spacing: 0 5px;
+    border-collapse: separate;
+}
+.content td { vertical-align: top; }
+.content td:first-child { padding-right: 20px; }
+.content td p:first-child { margin-top: 0; }
+.content td h1, .content td h2 { margin-left: 0; font-size: 1.1em; }
+
+.content .item-list {
+    list-style-type: none;
+    padding: 0;
+}
+
+.content .item-list li { margin-bottom: 3px; }
+
+.content .multi-column {
+    -moz-column-count: 5;
+    -moz-column-gap: 2.5em;
+    -webkit-column-count: 5;
+    -webkit-column-gap: 2.5em;
+    column-count: 5;
+    column-gap: 2.5em;
+}
+.content .multi-column li { width: 100%; display: inline-block; }
+
+.content .method { font-size: 1em; }
+.content .methods { margin-left: 20px; }
+.content .methods .docblock { margin-left: 20px; }
+
+nav {
+    border-bottom: 1px solid #e0e0e0;
+    padding-bottom: 10px;
+    margin-bottom: 10px;
+}
+nav.main {
+    padding: 20px 0;
+    text-align: center;
+}
+nav.main .current {
+    border-top: 1px solid #000;
+    border-bottom: 1px solid #000;
+}
+nav.main .separator {
+    border: 1px solid #000;
+    display: inline-block;
+    height: 23px;
+    margin: 0 20px;
+}
+nav.sum { text-align: right; }
+nav.sub form { display: inline; }
+
+nav, .content {
+    margin-left: 220px;
+    margin-right: 20px;
+}
+
+a {
+    text-decoration: none;
+    color: #000;
+}
+
+.content a, .block a.current { font-weight: bold; }
+
+.content a.trait, .block a.current.trait { color: #ed9603; }
+.content a.mod, .block a.current.mod { color: #4d76ae; }
+.content a.enum, .block a.current.enum { color: #5e9766; }
+.content a.struct, .block a.current.struct { color: #e53700; }
+.content a.fn, .block a.current.fn { color: #8c6067; }
+
+.search-input {
+    border: 2px solid #f2f2f2;
+    border-radius: 2px;
+    width: 350px;
+}
+.search-results .desc {
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    display: block;
+}
+
+#help {
+    background: #e9e9e9;
+    border-radius: 4px;
+    box-shadow: 0 0 6px rgba(0,0,0,.2);
+
+    position: absolute;
+    top: 300px;
+    left: 50%;
+    margin-top: -125px;
+    margin-left: -275px;
+    width: 550px;
+    height: 250px;
+    border: 1px solid #bfbfbf;
+}
+
+#help dt {
+    float: left;
+    border-radius: 3px;
+    border: 1px solid #bfbfbf;
+    background: #fff;
+    width: 23px;
+    text-align: center;
+    clear: left;
+    display: block;
+    margin-top: -1px;
+}
+#help dd { margin: 5px 33px; }
+#help .infos { padding-left: 0; }
+#help h1 { margin-top: 0; }
+#help div {
+    width: 50%;
+    float: left;
+    padding: 20px;
+}
diff --git a/src/rustdoc_ng/html/static/main.js b/src/rustdoc_ng/html/static/main.js
new file mode 100644
index 00000000000..b5ae3dadd77
--- /dev/null
+++ b/src/rustdoc_ng/html/static/main.js
@@ -0,0 +1,420 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*jslint browser: true, es5: true */
+/*globals $: true, searchIndex: true, rootPath: true, allPaths: true */
+
+(function () {
+    "use strict";
+    var resizeTimeout, interval;
+
+    $('.js-only').removeClass('js-only');
+
+    function resizeShortBlocks() {
+        if (resizeTimeout) {
+            clearTimeout(resizeTimeout);
+        }
+        resizeTimeout = setTimeout(function () {
+            var contentWidth = $('.content').width();
+            $('.docblock.short').width(function () {
+                return contentWidth - 40 - $(this).prev().width();
+            }).addClass('nowrap');
+        }, 150);
+    }
+    resizeShortBlocks();
+    $(window).on('resize', resizeShortBlocks);
+
+    $(document).on('keyup', function (e) {
+        if (document.activeElement.tagName === 'INPUT') {
+            return;
+        }
+
+        if (e.keyCode === 188 && $('#help').hasClass('hidden')) { // question mark
+            e.preventDefault();
+            $('#help').removeClass('hidden');
+        } else if (e.keyCode === 27 && !$('#help').hasClass('hidden')) { // esc
+            e.preventDefault();
+            $('#help').addClass('hidden');
+        } else if (e.keyCode === 83) { // S
+            e.preventDefault();
+            $('.search-input').focus();
+        }
+    }).on('click', function (e) {
+        if (!$(e.target).closest('#help').length) {
+            $('#help').addClass('hidden');
+        }
+    });
+
+    $('.version-selector').on('change', function () {
+        var i, match,
+            url = document.location.href,
+            stripped = '',
+            len = rootPath.match(/\.\.\//g).length + 1;
+
+        for (i = 0; i < len; i += 1) {
+            match = url.match(/\/[^\/]*$/);
+            if (i < len - 1) {
+                stripped = match[0] + stripped;
+            }
+            url = url.substring(0, url.length - match[0].length);
+        }
+
+        url += '/' + $('.version-selector').val() + stripped;
+
+        document.location.href = url;
+    });
+
+    function initSearch(searchIndex) {
+        var currentResults, index;
+
+        // clear cached values from the search bar
+        $(".search-input")[0].value = '';
+
+        function execQuery(query, max, searchWords) {
+            var valLower = query.query.toLowerCase(),
+                val = valLower,
+                typeFilter = query.type,
+                results = [],
+                aa = 0,
+                bb = 0;
+
+            // quoted values mean literal search
+            bb = searchWords.length;
+            if ((val.charAt(0) === "\"" || val.charAt(0) === "'") && val.charAt(val.length - 1) === val.charAt(0)) {
+                val = val.substr(1, val.length - 2);
+                for (aa = 0; aa < bb; aa += 1) {
+                    if (searchWords[aa] === val) {
+                        // filter type: ... queries
+                        if (!typeFilter || typeFilter === searchIndex[aa].ty) {
+                            results.push([aa, -1]);
+                        }
+                    }
+                    if (results.length === max) {
+                        break;
+                    }
+                }
+            } else {
+                // gather matching search results up to a certain maximum
+                val = val.replace(/\_/g, "");
+                for (aa = 0; aa < bb; aa += 1) {
+                    if (searchWords[aa].indexOf(val) > -1 || searchWords[aa].replace(/_/g, "").indexOf(val) > -1) {
+                        // filter type: ... queries
+                        if (!typeFilter || typeFilter === searchIndex[aa].ty) {
+                            results.push([aa, searchWords[aa].replace(/_/g, "").indexOf(val)]);
+                        }
+                    }
+                    if (results.length === max) {
+                        break;
+                    }
+                }
+            }
+            bb = results.length;
+            for (aa = 0; aa < bb; aa += 1) {
+                results[aa].push(searchIndex[results[aa][0]].ty);
+            }
+            for (aa = 0; aa < bb; aa += 1) {
+                results[aa].push(searchIndex[results[aa][0]].path);
+            }
+
+            // if there are no results then return to default and fail
+            if (results.length === 0) {
+                return [];
+            }
+
+            // sort by exact match
+            results.sort(function search_complete_sort0(aaa, bbb) {
+                if (searchWords[aaa[0]] === valLower && searchWords[bbb[0]] !== valLower) {
+                    return 1;
+                }
+            });
+            // first sorting attempt
+            // sort by item name length
+            results.sort(function search_complete_sort1(aaa, bbb) {
+                if (searchWords[aaa[0]].length > searchWords[bbb[0]].length) {
+                    return 1;
+                }
+            });
+            // second sorting attempt
+            // sort by item name
+            results.sort(function search_complete_sort1(aaa, bbb) {
+                if (searchWords[aaa[0]].length === searchWords[bbb[0]].length && searchWords[aaa[0]] > searchWords[bbb[0]]) {
+                    return 1;
+                }
+            });
+            // third sorting attempt
+            // sort by index of keyword in item name
+            if (results[0][1] !== -1) {
+                results.sort(function search_complete_sort1(aaa, bbb) {
+                    if (aaa[1] > bbb[1] && bbb[1] === 0) {
+                        return 1;
+                    }
+                });
+            }
+            // fourth sorting attempt
+            // sort by type
+            results.sort(function search_complete_sort3(aaa, bbb) {
+                if (searchWords[aaa[0]] === searchWords[bbb[0]] && aaa[2] > bbb[2]) {
+                    return 1;
+                }
+            });
+            // fifth sorting attempt
+            // sort by path
+            results.sort(function search_complete_sort4(aaa, bbb) {
+                if (searchWords[aaa[0]] === searchWords[bbb[0]] && aaa[2] === bbb[2] && aaa[3] > bbb[3]) {
+                    return 1;
+                }
+            });
+            // sixth sorting attempt
+            // remove duplicates, according to the data provided
+            for (aa = results.length - 1; aa > 0; aa -= 1) {
+                if (searchWords[results[aa][0]] === searchWords[results[aa - 1][0]] && results[aa][2] === results[aa - 1][2] && results[aa][3] === results[aa - 1][3]) {
+                    results[aa][0] = -1;
+                }
+            }
+
+            return results;
+        }
+
+        function getQuery() {
+            var matches, type, query = $('.search-input').val();
+
+            matches = query.match(/^(fn|mod|str(uct)?|enum|trait|t(ype)?d(ef)?)\s*:\s*/i);
+            if (matches) {
+                type = matches[1].replace(/^td$/, 'typedef').replace(/^str$/, 'struct').replace(/^tdef$/, 'typedef').replace(/^typed$/, 'typedef');
+                query = query.substring(matches[0].length);
+            }
+
+            return {
+                query: query,
+                type: type,
+                id: query + type,
+            };
+        }
+
+        function initSearchNav() {
+            var hoverTimeout, $results = $('.search-results .result');
+
+            $results.on('click', function () {
+                document.location.href = $(this).find('a').prop('href');
+            }).on('mouseover', function () {
+                var $el = $(this);
+                clearTimeout(hoverTimeout);
+                hoverTimeout = setTimeout(function () {
+                    $results.removeClass('highlighted');
+                    $el.addClass('highlighted');
+                }, 20);
+            });
+
+            $(document).off('keyup.searchnav');
+            $(document).on('keyup.searchnav', function (e) {
+                var $active = $results.filter('.highlighted');
+
+                if (e.keyCode === 38) { // up
+                    e.preventDefault();
+                    if (!$active.length || !$active.prev()) {
+                        return;
+                    }
+
+                    $active.prev().addClass('highlighted');
+                    $active.removeClass('highlighted');
+                } else if (e.keyCode === 40) { // down
+                    e.preventDefault();
+                    if (!$active.length) {
+                        $results.first().addClass('highlighted');
+                    } else if ($active.next().length) {
+                        $active.next().addClass('highlighted');
+                        $active.removeClass('highlighted');
+                    }
+                } else if (e.keyCode === 13) { // return
+                    e.preventDefault();
+                    if ($active.length) {
+                        document.location.href = $active.find('a').prop('href');
+                    }
+                }
+            });
+        }
+
+        function showResults(results) {
+            var output, shown, query = getQuery();
+
+            currentResults = query.id;
+            output = '<h1>Results for ' + query.query + (query.type ? ' (type: ' + query.type + ')' : '') + '</h1>';
+            output += '<table class="search-results">';
+
+            if (results.length > 0) {
+                shown = [];
+
+                results.forEach(function (item) {
+                    var name, type;
+
+                    if (shown.indexOf(item) !== -1) {
+                        return;
+                    }
+
+                    shown.push(item);
+                    name = item.name;
+                    type = item.ty;
+
+                    output += '<tr class="' + type + ' result"><td>';
+
+                    if (type === 'mod') {
+                        output += item.path + '::<a href="' + rootPath + item.path.replace(/::/g, '/') + '/' + name + '/index.html" class="' + type + '">' + name + '</a>';
+                    } else if (type === 'static' || type === 'reexport') {
+                        output += item.path + '::<a href="' + rootPath + item.path.replace(/::/g, '/') + '/index.html" class="' + type + '">' + name + '</a>';
+                    } else if (item.parent !== undefined) {
+                        var myparent = allPaths[item.parent];
+                        output += item.path + '::' + myparent.name + '::<a href="' + rootPath + item.path.replace(/::/g, '/') + '/' + myparent.type + '.' + myparent.name + '.html" class="' + type + '">' + name + '</a>';
+                    } else {
+                        output += item.path + '::<a href="' + rootPath + item.path.replace(/::/g, '/') + '/' + type + '.' + name + '.html" class="' + type + '">' + name + '</a>';
+                    }
+
+                    output += '</td><td><span class="desc">' + item.desc + '</span></td></tr>';
+                });
+            } else {
+                output += 'No results :( <a href="https://duckduckgo.com/?q=' + encodeURIComponent('rust ' + query.query) + '">Try on DuckDuckGo?</a>';
+            }
+
+            output += "</p>";
+            $('.content').html(output);
+            $('.search-results .desc').width($('.content').width() - 40 - $('.content td:first-child').first().width());
+            initSearchNav();
+        }
+
+        function search(e) {
+            var query, filterdata = [], obj, i, len,
+                results = [],
+                maxResults = 200,
+                resultIndex;
+
+            query = getQuery();
+            if (e) {
+                e.preventDefault();
+            }
+
+            if (!query.query || query.id === currentResults) {
+                return;
+            }
+
+            resultIndex = execQuery(query, 20000, index);
+            len = resultIndex.length;
+            for (i = 0; i < len; i += 1) {
+                if (resultIndex[i][0] > -1) {
+                    obj = searchIndex[resultIndex[i][0]];
+                    filterdata.push([obj.name, obj.ty, obj.path, obj.desc]);
+                    results.push(obj);
+                }
+                if (results.length >= maxResults) {
+                    break;
+                }
+            }
+
+            // TODO add sorting capability through this function?
+            //
+            //            // the handler for the table heading filtering
+            //            filterdraw = function search_complete_filterdraw(node) {
+            //                var name = "",
+            //                    arrow = "",
+            //                    op = 0,
+            //                    tbody = node.parentNode.parentNode.nextSibling,
+            //                    anchora = {},
+            //                    tra = {},
+            //                    tha = {},
+            //                    td1a = {},
+            //                    td2a = {},
+            //                    td3a = {},
+            //                    aaa = 0,
+            //                    bbb = 0;
+            //
+            //                // the 4 following conditions set the rules for each
+            //                // table heading
+            //                if (node === ths[0]) {
+            //                    op = 0;
+            //                    name = "name";
+            //                    ths[1].innerHTML = ths[1].innerHTML.split(" ")[0];
+            //                    ths[2].innerHTML = ths[2].innerHTML.split(" ")[0];
+            //                    ths[3].innerHTML = ths[3].innerHTML.split(" ")[0];
+            //                }
+            //                if (node === ths[1]) {
+            //                    op = 1;
+            //                    name = "type";
+            //                    ths[0].innerHTML = ths[0].innerHTML.split(" ")[0];
+            //                    ths[2].innerHTML = ths[2].innerHTML.split(" ")[0];
+            //                    ths[3].innerHTML = ths[3].innerHTML.split(" ")[0];
+            //                }
+            //                if (node === ths[2]) {
+            //                    op = 2;
+            //                    name = "path";
+            //                    ths[0].innerHTML = ths[0].innerHTML.split(" ")[0];
+            //                    ths[1].innerHTML = ths[1].innerHTML.split(" ")[0];
+            //                    ths[3].innerHTML = ths[3].innerHTML.split(" ")[0];
+            //                }
+            //                if (node === ths[3]) {
+            //                    op = 3;
+            //                    name = "description";
+            //                    ths[0].innerHTML = ths[0].innerHTML.split(" ")[0];
+            //                    ths[1].innerHTML = ths[1].innerHTML.split(" ")[0];
+            //                    ths[2].innerHTML = ths[2].innerHTML.split(" ")[0];
+            //                }
+            //
+            //                // ascending or descending search
+            //                arrow = node.innerHTML.split(" ")[1];
+            //                if (arrow === undefined || arrow === "\u25b2") {
+            //                    arrow = "\u25bc";
+            //                } else {
+            //                    arrow = "\u25b2";
+            //                }
+            //
+            //                // filter the data
+            //                filterdata.sort(function search_complete_filterDraw_sort(xx, yy) {
+            //                    if ((arrow === "\u25b2" && xx[op].toLowerCase() < yy[op].toLowerCase()) || (arrow === "\u25bc" && xx[op].toLowerCase() > yy[op].toLowerCase())) {
+            //                        return 1;
+            //                    }
+            //                });
+            //            };
+
+            showResults(results);
+        }
+
+        function buildIndex(searchIndex) {
+            var len = searchIndex.length,
+                i = 0,
+                searchWords = [];
+
+            // before any analysis is performed lets gather the search terms to
+            // search against apart from the rest of the data.  This is a quick
+            // operation that is cached for the life of the page state so that
+            // all other search operations have access to this cached data for
+            // faster analysis operations
+            for (i = 0; i < len; i += 1) {
+                if (typeof searchIndex[i].name === "string") {
+                    searchWords.push(searchIndex[i].name.toLowerCase());
+                } else {
+                    searchWords.push("");
+                }
+            }
+
+            return searchWords;
+        }
+
+        function startSearch() {
+            var keyUpTimeout;
+            $('.do-search').on('click', search);
+            $('.search-input').on('keyup', function () {
+                clearTimeout(keyUpTimeout);
+                keyUpTimeout = setTimeout(search, 100);
+            });
+        }
+
+        index = buildIndex(searchIndex);
+        startSearch();
+    }
+
+    initSearch(searchIndex);
+}());
diff --git a/src/rustdoc_ng/html/static/normalize.css b/src/rustdoc_ng/html/static/normalize.css
new file mode 100644
index 00000000000..6adf56e7985
--- /dev/null
+++ b/src/rustdoc_ng/html/static/normalize.css
@@ -0,0 +1,396 @@
+/*! normalize.css v2.1.2 | MIT License | git.io/normalize */
+
+/* ==========================================================================
+   HTML5 display definitions
+   ========================================================================== */
+
+/**
+ * Correct `block` display not defined in IE 8/9.
+ */
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+main,
+nav,
+section,
+summary {
+    display: block;
+}
+
+/**
+ * Correct `inline-block` display not defined in IE 8/9.
+ */
+
+audio,
+canvas,
+video {
+    display: inline-block;
+}
+
+/**
+ * Prevent modern browsers from displaying `audio` without controls.
+ * Remove excess height in iOS 5 devices.
+ */
+
+audio:not([controls]) {
+    display: none;
+    height: 0;
+}
+
+/**
+ * Address styling not present in IE 8/9.
+ */
+
+[hidden] {
+    display: none;
+}
+
+/* ==========================================================================
+   Base
+   ========================================================================== */
+
+/**
+ * 1. Set default font family to sans-serif.
+ * 2. Prevent iOS text size adjust after orientation change, without disabling
+ *    user zoom.
+ */
+
+html {
+    font-family: sans-serif; /* 1 */
+    -ms-text-size-adjust: 100%; /* 2 */
+    -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/**
+ * Remove default margin.
+ */
+
+body {
+    margin: 0;
+}
+
+/* ==========================================================================
+   Links
+   ========================================================================== */
+
+/**
+ * Address `outline` inconsistency between Chrome and other browsers.
+ */
+
+a:focus {
+    outline: thin dotted;
+}
+
+/**
+ * Improve readability when focused and also mouse hovered in all browsers.
+ */
+
+a:active,
+a:hover {
+    outline: 0;
+}
+
+/* ==========================================================================
+   Typography
+   ========================================================================== */
+
+/**
+ * Address variable `h1` font-size and margin within `section` and `article`
+ * contexts in Firefox 4+, Safari 5, and Chrome.
+ */
+
+h1 {
+    font-size: 2em;
+    margin: 0.67em 0;
+}
+
+/**
+ * Address styling not present in IE 8/9, Safari 5, and Chrome.
+ */
+
+abbr[title] {
+    border-bottom: 1px dotted;
+}
+
+/**
+ * Address style set to `bolder` in Firefox 4+, Safari 5, and Chrome.
+ */
+
+b,
+strong {
+    font-weight: bold;
+}
+
+/**
+ * Address styling not present in Safari 5 and Chrome.
+ */
+
+dfn {
+    font-style: italic;
+}
+
+/**
+ * Address differences between Firefox and other browsers.
+ */
+
+hr {
+    -moz-box-sizing: content-box;
+    box-sizing: content-box;
+    height: 0;
+}
+
+/**
+ * Address styling not present in IE 8/9.
+ */
+
+mark {
+    background: #ff0;
+    color: #000;
+}
+
+/**
+ * Correct font family set oddly in Safari 5 and Chrome.
+ */
+
+code,
+kbd,
+pre,
+samp {
+    font-family: monospace, serif;
+    font-size: 1em;
+}
+
+/**
+ * Improve readability of pre-formatted text in all browsers.
+ */
+
+pre {
+    white-space: pre-wrap;
+}
+
+/**
+ * Set consistent quote types.
+ */
+
+q {
+    quotes: "\201C" "\201D" "\2018" "\2019";
+}
+
+/**
+ * Address inconsistent and variable font size in all browsers.
+ */
+
+small {
+    font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` affecting `line-height` in all browsers.
+ */
+
+sub,
+sup {
+    font-size: 75%;
+    line-height: 0;
+    position: relative;
+    vertical-align: baseline;
+}
+
+sup {
+    top: -0.5em;
+}
+
+sub {
+    bottom: -0.25em;
+}
+
+/* ==========================================================================
+   Embedded content
+   ========================================================================== */
+
+/**
+ * Remove border when inside `a` element in IE 8/9.
+ */
+
+img {
+    border: 0;
+}
+
+/**
+ * Correct overflow displayed oddly in IE 9.
+ */
+
+svg:not(:root) {
+    overflow: hidden;
+}
+
+/* ==========================================================================
+   Figures
+   ========================================================================== */
+
+/**
+ * Address margin not present in IE 8/9 and Safari 5.
+ */
+
+figure {
+    margin: 0;
+}
+
+/* ==========================================================================
+   Forms
+   ========================================================================== */
+
+/**
+ * Define consistent border, margin, and padding.
+ */
+
+fieldset {
+    border: 1px solid #c0c0c0;
+    margin: 0 2px;
+    padding: 0.35em 0.625em 0.75em;
+}
+
+/**
+ * 1. Correct `color` not being inherited in IE 8/9.
+ * 2. Remove padding so people aren't caught out if they zero out fieldsets.
+ */
+
+legend {
+    border: 0; /* 1 */
+    padding: 0; /* 2 */
+}
+
+/**
+ * 1. Correct font family not being inherited in all browsers.
+ * 2. Correct font size not being inherited in all browsers.
+ * 3. Address margins set differently in Firefox 4+, Safari 5, and Chrome.
+ */
+
+button,
+input,
+select,
+textarea {
+    font-family: inherit; /* 1 */
+    font-size: 100%; /* 2 */
+    margin: 0; /* 3 */
+}
+
+/**
+ * Address Firefox 4+ setting `line-height` on `input` using `!important` in
+ * the UA stylesheet.
+ */
+
+button,
+input {
+    line-height: normal;
+}
+
+/**
+ * Address inconsistent `text-transform` inheritance for `button` and `select`.
+ * All other form control elements do not inherit `text-transform` values.
+ * Correct `button` style inheritance in Chrome, Safari 5+, and IE 8+.
+ * Correct `select` style inheritance in Firefox 4+ and Opera.
+ */
+
+button,
+select {
+    text-transform: none;
+}
+
+/**
+ * 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
+ *    and `video` controls.
+ * 2. Correct inability to style clickable `input` types in iOS.
+ * 3. Improve usability and consistency of cursor style between image-type
+ *    `input` and others.
+ */
+
+button,
+html input[type="button"], /* 1 */
+input[type="reset"],
+input[type="submit"] {
+    -webkit-appearance: button; /* 2 */
+    cursor: pointer; /* 3 */
+}
+
+/**
+ * Re-set default cursor for disabled elements.
+ */
+
+button[disabled],
+html input[disabled] {
+    cursor: default;
+}
+
+/**
+ * 1. Address box sizing set to `content-box` in IE 8/9.
+ * 2. Remove excess padding in IE 8/9.
+ */
+
+input[type="checkbox"],
+input[type="radio"] {
+    box-sizing: border-box; /* 1 */
+    padding: 0; /* 2 */
+}
+
+/**
+ * 1. Address `appearance` set to `searchfield` in Safari 5 and Chrome.
+ * 2. Address `box-sizing` set to `border-box` in Safari 5 and Chrome
+ *    (include `-moz` to future-proof).
+ */
+
+input[type="search"] {
+    -webkit-appearance: textfield; /* 1 */
+    -moz-box-sizing: content-box;
+    -webkit-box-sizing: content-box; /* 2 */
+    box-sizing: content-box;
+}
+
+/**
+ * Remove inner padding and search cancel button in Safari 5 and Chrome
+ * on OS X.
+ */
+
+input[type="search"]::-webkit-search-cancel-button,
+input[type="search"]::-webkit-search-decoration {
+    -webkit-appearance: none;
+}
+
+/**
+ * Remove inner padding and border in Firefox 4+.
+ */
+
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+    border: 0;
+    padding: 0;
+}
+
+/**
+ * 1. Remove default vertical scrollbar in IE 8/9.
+ * 2. Improve readability and alignment in all browsers.
+ */
+
+textarea {
+    overflow: auto; /* 1 */
+    vertical-align: top; /* 2 */
+}
+
+/* ==========================================================================
+   Tables
+   ========================================================================== */
+
+/**
+ * Remove most spacing between table cells.
+ */
+
+table {
+    border-collapse: collapse;
+    border-spacing: 0;
+}
diff --git a/src/rustdoc_ng/passes.rs b/src/rustdoc_ng/passes.rs
index da6128a7610..e580ab0719c 100644
--- a/src/rustdoc_ng/passes.rs
+++ b/src/rustdoc_ng/passes.rs
@@ -8,7 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std;
+use std::num;
+use std::uint;
+
 use clean;
 use syntax::ast;
 use clean::Item;
@@ -16,11 +18,6 @@ use plugins;
 use fold;
 use fold::DocFolder;
 
-/// A sample pass showing the minimum required work for a plugin.
-pub fn noop(crate: clean::Crate) -> plugins::PluginResult {
-    (crate, None)
-}
-
 /// Strip items marked `#[doc(hidden)]`
 pub fn strip_hidden(crate: clean::Crate) -> plugins::PluginResult {
     struct Stripper;
@@ -32,7 +29,7 @@ pub fn strip_hidden(crate: clean::Crate) -> plugins::PluginResult {
                         for innerattr in l.iter() {
                             match innerattr {
                                 &clean::Word(ref s) if "hidden" == *s => {
-                                    info!("found one in strip_hidden; removing");
+                                    debug!("found one in strip_hidden; removing");
                                     return None;
                                 },
                                 _ => (),
@@ -50,7 +47,7 @@ pub fn strip_hidden(crate: clean::Crate) -> plugins::PluginResult {
     (crate, None)
 }
 
-pub fn clean_comments(crate: clean::Crate) -> plugins::PluginResult {
+pub fn unindent_comments(crate: clean::Crate) -> plugins::PluginResult {
     struct CommentCleaner;
     impl fold::DocFolder for CommentCleaner {
         fn fold_item(&mut self, i: Item) -> Option<Item> {
@@ -59,7 +56,7 @@ pub fn clean_comments(crate: clean::Crate) -> plugins::PluginResult {
             for attr in i.attrs.iter() {
                 match attr {
                     &clean::NameValue(~"doc", ref s) => avec.push(
-                        clean::NameValue(~"doc", clean_comment_body(s.clone()))),
+                        clean::NameValue(~"doc", unindent(*s))),
                     x => avec.push(x.clone())
                 }
             }
@@ -124,80 +121,111 @@ pub fn collapse_docs(crate: clean::Crate) -> plugins::PluginResult {
     (crate, None)
 }
 
-//Utility
-enum CleanCommentStates {
-    Collect,
-    Strip,
-    Stripped,
-}
-
-/// Returns the index of the last character all strings have common in their
-/// prefix.
-fn longest_common_prefix(s: ~[~str]) -> uint {
-    // find the longest common prefix
+// n.b. this is copied from src/librustdoc/unindent_pass.rs
+pub fn unindent(s: &str) -> ~str {
+    let lines = s.any_line_iter().collect::<~[&str]>();
+    let mut saw_first_line = false;
+    let mut saw_second_line = false;
+    let min_indent = do lines.iter().fold(uint::max_value) |min_indent, line| {
+
+        // After we see the first non-whitespace line, look at
+        // the line we have. If it is not whitespace, and therefore
+        // part of the first paragraph, then ignore the indentation
+        // level of the first line
+        let ignore_previous_indents =
+            saw_first_line &&
+            !saw_second_line &&
+            !line.is_whitespace();
+
+        let min_indent = if ignore_previous_indents {
+            uint::max_value
+        } else {
+            min_indent
+        };
 
-    debug!("lcp: looking into %?", s);
-    // index of the last character all the strings share
-    let mut index = 0u;
+        if saw_first_line {
+            saw_second_line = true;
+        }
 
-    if s.len() <= 1 {
-        return 0;
+        if line.is_whitespace() {
+            min_indent
+        } else {
+            saw_first_line = true;
+            let mut spaces = 0;
+            do line.iter().all |char| {
+                // Only comparing against space because I wouldn't
+                // know what to do with mixed whitespace chars
+                if char == ' ' {
+                    spaces += 1;
+                    true
+                } else {
+                    false
+                }
+            };
+            num::min(min_indent, spaces)
+        }
+    };
+
+    match lines {
+        [head, .. tail] => {
+            let mut unindented = ~[ head.trim() ];
+            unindented.push_all(do tail.map |&line| {
+                if line.is_whitespace() {
+                    line
+                } else {
+                    assert!(line.len() >= min_indent);
+                    line.slice_from(min_indent)
+                }
+            });
+            unindented.connect("\n")
+        }
+        [] => s.to_owned()
     }
+}
 
-    // whether one of the strings has been exhausted of characters yet
-    let mut exhausted = false;
-
-    // character iterators for all the lines
-    let mut lines = s.iter().filter(|x| x.len() != 0).map(|x| x.iter()).to_owned_vec();
+#[cfg(test)]
+mod unindent_tests {
+    use super::unindent;
 
-    'outer: loop {
-        // because you can't label a while loop
-        if exhausted == true {
-            break;
-        }
-        debug!("lcp: index %u", index);
-        let mut lines = lines.mut_iter();
-        let ch = match lines.next().unwrap().next() {
-            Some(c) => c,
-            None => { exhausted = true; loop },
-        };
-        debug!("looking for char %c", ch);
-        for line in lines {
-            match line.next() {
-                Some(c) => if c == ch { loop } else { exhausted = true; loop 'outer },
-                None => { exhausted = true; loop 'outer }
-            }
-        }
-        index += 1;
+    #[test]
+    fn should_unindent() {
+        let s = ~"    line1\n    line2";
+        let r = unindent(s);
+        assert_eq!(r, ~"line1\nline2");
     }
 
-    debug!("lcp: last index %u", index);
-    index
-}
+    #[test]
+    fn should_unindent_multiple_paragraphs() {
+        let s = ~"    line1\n\n    line2";
+        let r = unindent(s);
+        assert_eq!(r, ~"line1\n\nline2");
+    }
 
-fn clean_comment_body(s: ~str) -> ~str {
-    // FIXME #31: lots of copies in here.
-    let lines = s.line_iter().to_owned_vec();
-    match lines.len() {
-        0 => return ~"",
-        1 => return lines[0].slice_from(2).trim().to_owned(),
-        _ => (),
+    #[test]
+    fn should_leave_multiple_indent_levels() {
+        // Line 2 is indented another level beyond the
+        // base indentation and should be preserved
+        let s = ~"    line1\n\n        line2";
+        let r = unindent(s);
+        assert_eq!(r, ~"line1\n\n    line2");
     }
 
-    let mut ol = std::vec::with_capacity(lines.len());
-    for line in lines.clone().move_iter() {
-        // replace meaningless things with a single newline
-        match line {
-            x if ["/**", "/*!", "///", "//!", "*/"].contains(&x.trim()) => ol.push(~""),
-            x if x.trim() == "" => ol.push(~""),
-            x => ol.push(x.to_owned())
-        }
+    #[test]
+    fn should_ignore_first_line_indent() {
+        // Thi first line of the first paragraph may not be indented as
+        // far due to the way the doc string was written:
+        //
+        // #[doc = "Start way over here
+        //          and continue here"]
+        let s = ~"line1\n    line2";
+        let r = unindent(s);
+        assert_eq!(r, ~"line1\nline2");
     }
-    let li = longest_common_prefix(ol.clone());
 
-    let x = ol.iter()
-         .filter(|x| { debug!("cleaning line: %s", **x); true })
-         .map(|x| if x.len() == 0 { ~"" } else { x.slice_chars(li, x.char_len()).to_owned() })
-         .to_owned_vec().connect("\n");
-    x.trim().to_owned()
+    #[test]
+    fn should_not_ignore_first_line_indent_in_a_single_line_para() {
+        let s = ~"line1\n\n    line2";
+        let r = unindent(s);
+        assert_eq!(r, ~"line1\n\n    line2");
+    }
 }
diff --git a/src/rustdoc_ng/rustdoc_ng.rs b/src/rustdoc_ng/rustdoc_ng.rs
index a4e3bc50d11..4bff60c71b7 100644
--- a/src/rustdoc_ng/rustdoc_ng.rs
+++ b/src/rustdoc_ng/rustdoc_ng.rs
@@ -22,20 +22,34 @@ extern mod rustc;
 extern mod extra;
 
 use extra::serialize::Encodable;
+use extra::time;
 use std::cell::Cell;
+use std::rt::io;
+use std::rt::io::Writer;
+use std::rt::io::file::FileInfo;
 
+pub mod clean;
 pub mod core;
 pub mod doctree;
-pub mod clean;
-pub mod visit_ast;
 pub mod fold;
-pub mod plugins;
+pub mod html {
+    pub mod render;
+    pub mod layout;
+    pub mod markdown;
+    pub mod format;
+}
 pub mod passes;
+pub mod plugins;
+pub mod visit_ast;
 
 pub static SCHEMA_VERSION: &'static str = "0.8.0";
 
 local_data_key!(pub ctxtkey: @core::DocContext)
 
+enum OutputFormat {
+    HTML, JSON
+}
+
 pub fn main() {
     main_args(std::os::args());
 }
@@ -44,65 +58,132 @@ pub fn main_args(args: &[~str]) {
     use extra::getopts::groups::*;
 
     let opts = ~[
-        optmulti("L", "library-path", "directory to add to crate search path", "DIR"),
-        optmulti("p", "plugin", "plugin to load and run", "NAME"),
+        optmulti("L", "library-path", "directory to add to crate search path",
+                 "DIR"),
         optmulti("", "plugin-path", "directory to load plugins from", "DIR"),
-        // auxillary pass (defaults to hidden_strip
-        optmulti("a", "pass", "auxillary pass to run", "NAME"),
-        optflag("n", "no-defult-passes", "do not run the default passes"),
+        optmulti("", "passes", "space separated list of passes to also run",
+                 "PASSES"),
+        optmulti("", "plugins", "space separated list of plugins to also load",
+                 "PLUGINS"),
         optflag("h", "help", "show this help message"),
+        optflag("", "nodefaults", "don't run the default passes"),
+        optopt("o", "output", "where to place the output", "PATH"),
     ];
 
     let matches = getopts(args.tail(), opts).unwrap();
 
-    if matches.opt_present("h") || matches.opt_present("help") {
-        println(usage(args[0], opts));
-        return;
-    }
-
-    let libs = Cell::new(matches.opt_strs("L").map(|s| Path(*s)));
-
-    let mut passes = if matches.opt_present("n") {
-        ~[]
-    } else {
-        ~[~"collapse-docs", ~"clean-comments", ~"collapse-privacy" ]
+    let myusage = || {
+        println(usage(format!("{} [options] [html|json] <crate>", args[0]), opts));
     };
 
-    matches.opt_strs("a").map(|x| passes.push(x.clone()));
-
-    if matches.free.len() != 1 {
-        println(usage(args[0], opts));
+    if matches.opt_present("h") || matches.opt_present("help") {
+        myusage();
         return;
     }
 
-    let cr = Cell::new(Path(matches.free[0]));
+    let (format, cratefile) = match matches.free.clone() {
+        [~"json", crate] => (JSON, crate),
+        [~"html", crate] => (HTML, crate),
+        [s, _] => {
+            println!("Unknown output format: `{}`", s);
+            myusage();
+            exit(1);
+        }
+        [_, .._] => {
+            println!("Expected exactly one crate to process");
+            myusage();
+            exit(1);
+        }
+        _ => {
+            println!("Expected an output format and then one crate");
+            myusage();
+            exit(1);
+        }
+    };
 
+    // First, parse the crate and extract all relevant information.
+    let libs = Cell::new(matches.opt_strs("L").map(|s| Path(*s)));
+    let cr = Cell::new(Path(cratefile));
+    info2!("starting to run rustc");
     let crate = do std::task::try {
         let cr = cr.take();
         core::run_core(libs.take(), &cr)
     }.unwrap();
+    info2!("finished with rustc");
+
+    // Process all of the crate attributes, extracting plugin metadata along
+    // with the passes which we are supposed to run.
+    let mut default_passes = !matches.opt_present("nodefaults");
+    let mut passes = matches.opt_strs("passes");
+    let mut plugins = matches.opt_strs("plugins");
+    match crate.module.get_ref().doc_list() {
+        Some(nested) => {
+            for inner in nested.iter() {
+                match *inner {
+                    clean::Word(~"no_default_passes") => {
+                        default_passes = false;
+                    }
+                    clean::NameValue(~"passes", ref value) => {
+                        for pass in value.word_iter() {
+                            passes.push(pass.to_owned());
+                        }
+                    }
+                    clean::NameValue(~"plugins", ref value) => {
+                        for p in value.word_iter() {
+                            plugins.push(p.to_owned());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+        None => {}
+    }
+    if default_passes {
+        passes.unshift(~"collapse-docs");
+        passes.unshift(~"unindent-comments");
+    }
 
-    // { "schema": version, "crate": { parsed crate ... }, "plugins": { output of plugins ... }}
-    let mut json = ~extra::treemap::TreeMap::new();
-    json.insert(~"schema", extra::json::String(SCHEMA_VERSION.to_owned()));
-
+    // Load all plugins/passes into a PluginManager
     let mut pm = plugins::PluginManager::new(Path("/tmp/rustdoc_ng/plugins"));
-
     for pass in passes.iter() {
-        pm.add_plugin(match pass.as_slice() {
+        let plugin = match pass.as_slice() {
             "strip-hidden" => passes::strip_hidden,
-            "clean-comments" => passes::clean_comments,
+            "unindent-comments" => passes::unindent_comments,
             "collapse-docs" => passes::collapse_docs,
             "collapse-privacy" => passes::collapse_privacy,
-            s => { error!("unknown pass %s, skipping", s); passes::noop },
-        })
+            s => { error!("unknown pass %s, skipping", s); loop },
+        };
+        pm.add_plugin(plugin);
     }
-
-    for pname in matches.opt_strs("p").move_iter() {
+    info2!("loading plugins...");
+    for pname in plugins.move_iter() {
         pm.load_plugin(pname);
     }
 
+    // Run everything!
+    info2!("Executing passes/plugins");
     let (crate, res) = pm.run_plugins(crate);
+
+    info2!("going to format");
+    let started = time::precise_time_ns();
+    let output = matches.opt_str("o").map(|s| Path(*s));
+    match format {
+        HTML => { html::render::run(crate, output.unwrap_or(Path("doc"))) }
+        JSON => { jsonify(crate, res, output.unwrap_or(Path("doc.json"))) }
+    }
+    let ended = time::precise_time_ns();
+    info2!("Took {:.03f}s", (ended as f64 - started as f64) / 1000000000f64);
+}
+
+fn jsonify(crate: clean::Crate, res: ~[plugins::PluginJson], dst: Path) {
+    // {
+    //   "schema": version,
+    //   "crate": { parsed crate ... },
+    //   "plugins": { output of plugins ... }
+    // }
+    let mut json = ~extra::treemap::TreeMap::new();
+    json.insert(~"schema", extra::json::String(SCHEMA_VERSION.to_owned()));
     let plugins_json = ~res.move_iter().filter_map(|opt| opt).collect();
 
     // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode
@@ -118,5 +199,13 @@ pub fn main_args(args: &[~str]) {
     json.insert(~"crate", crate_json);
     json.insert(~"plugins", extra::json::Object(plugins_json));
 
-    println(extra::json::Object(json).to_str());
+    let mut file = dst.open_writer(io::Create).unwrap();
+    let output = extra::json::Object(json).to_str();
+    file.write(output.as_bytes());
+}
+
+fn exit(status: int) -> ! {
+    #[fixed_stack_segment]; #[inline(never)];
+    use std::libc;
+    unsafe { libc::exit(status as libc::c_int) }
 }