diff --git a/README.md b/README.md index 6712b2a..5066abe 100644 --- a/README.md +++ b/README.md @@ -30,6 +30,10 @@ required to rehost Lisp 1.5 on a different platform would be to reimplement * host.clj * read.clj +The objective this is to make it fairly easy to implement Lisp 1.5 on top of +any of the many [Make A Lisp](https://github.com/kanaka/mal) +implementations. + #### beowulf/boostrap.clj This file is essentially Lisp as defined in Chapter 1 (pages 1-14) of the @@ -75,6 +79,17 @@ for modern machines. Because I'm barking mad, and this is therapy. +### Commentary + +What's surprised me in working on this is how much more polished Lisp 1.5 is +than legend had led me to believe. The language is remarkably close to +[Portable Standard Lisp](http://www.softwarepreservation.org/projects/LISP/standard_lisp_family/#Portable_Standard_LISP_) +which is in my opinion one of the best and most usable early Lisp +implementations. I'm convinced you could still use Lisp 1.5 for interesting +and useful software (which isn't to say that some modern Lisps aren't better, +but this is software which is almost sixty years old). + + ## Installation At present, clone the source and build it using @@ -97,6 +112,17 @@ The `Lisp 1.5 Programmer's Manual` is still [in print, ISBN 13 978-0-262-13011-0](https://mitpress.mit.edu/books/lisp-15-programmers-manual); but it's also [available online](http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf). +## Other Lisp 1.5 resources + +The main resource I'm aware of is the Software Preservation Society's site, +[here](http://www.softwarepreservation.org/projects/LISP/lisp1.5). It has lots +of fascinating stuff including full assembler listings for various obsolete +processors, but I failed to find the Lisp source of Lisp functions as a text +file, which is why `resources/lisp1.5.lsp` is largely copytyped and +reconstructed from the manual. + +I'm not at this time aware of any other working Lisp 1.5 implementations. + ## License Copyright © 2019 Simon Brooke. Licensed under the GNU General Public License, diff --git a/docs/cloverage/beowulf/bootstrap.clj.html b/docs/cloverage/beowulf/bootstrap.clj.html new file mode 100644 index 0000000..288a122 --- /dev/null +++ b/docs/cloverage/beowulf/bootstrap.clj.html @@ -0,0 +1,995 @@ + + + + beowulf/bootstrap.clj + + + + 001  (ns beowulf.bootstrap +
+ + 002    "Lisp as defined in Chapter 1 (pages 1-14) of the +
+ + 003     `Lisp 1.5 Programmer's Manual`; that is to say, a very simple Lisp language," +
+ + 004    (:require [clojure.tools.trace :refer :all] +
+ + 005              [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell NIL T F]])) +
+ + 006   +
+ + 007  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 008  ;;; +
+ + 009  ;;; This file is essentially Lisp as defined in Chapter 1 (pages 1-14) of the +
+ + 010  ;;; Lisp 1.5 Programmer's Manual; that is to say, a very simple Lisp language, +
+ + 011  ;;; which should, I believe, be sufficient in conjunction with the functions +
+ + 012  ;;; provided by `beowulf.host`, be sufficient to bootstrap the full Lisp 1.5 +
+ + 013  ;;; interpreter. +
+ + 014  ;;; +
+ + 015  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 016   +
+ + 017  (declare EVAL) +
+ + 018   +
+ + 019  (def oblist +
+ + 020    "The default environment; modified certainly be `LABEL` (which seems to +
+ + 021    be Lisp 1.5's EQuivalent of `SETQ`), possibly by other things." +
+ + 022    (atom NIL)) +
+ + 023   +
+ + 024  (def ^:dynamic *options* +
+ + 025    "Command line options from invocation." +
+ + 026    {}) +
+ + 027   +
+ + 028  (defmacro NULL +
+ + 029    [x] +
+ + 030    `(if (= ~x NIL) T F)) +
+ + 031   +
+ + 032  (defmacro ATOM +
+ + 033    "It is not clear to me from the documentation whether `(ATOM 7)` should return +
+ + 034    `T` or `F`. I'm going to assume `T`." +
+ + 035    [x] +
+ + 036    `(if (or (symbol? ~x) (number? ~x)) T F)) +
+ + 037   +
+ + 038  (defmacro ATOM? +
+ + 039    "The convention of returning `F` from predicates, rather than `NIL`, is going +
+ + 040    to tie me in knots. This is a variant of `ATOM` which returns `NIL` +
+ + 041    on failure." +
+ + 042    [x] +
+ + 043    `(if (or (symbol? ~x) (number? ~x)) T NIL)) +
+ + 044   +
+ + 045  (defn CAR +
+ + 046    "Return the item indicated by the first pointer of a pair. NIL is treated +
+ + 047    specially: the CAR of NIL is NIL." +
+ + 048    [x] +
+ + 049    (cond +
+ + 050      (= x NIL) NIL +
+ + 051      (instance? beowulf.cons_cell.ConsCell x) (.CAR x) +
+ + 052      :else +
+ + 053      (throw +
+ + 054        (Exception. +
+ + 055          (str "Cannot take CAR of `" x "` (" (.getName (.getClass x)) ")"))))) +
+ + 056   +
+ + 057  (defn CDR +
+ + 058    "Return the item indicated by the second pointer of a pair. NIL is treated +
+ + 059    specially: the CDR of NIL is NIL." +
+ + 060    [x] +
+ + 061    (cond +
+ + 062      (= x NIL) NIL +
+ + 063      (instance? beowulf.cons_cell.ConsCell x) (.CDR x) +
+ + 064      :else +
+ + 065      (throw +
+ + 066        (Exception. +
+ + 067          (str "Cannot take CDR of `" x "` (" (.getName (.getClass x)) ")"))))) +
+ + 068   +
+ + 069  (defn uaf +
+ + 070    "Universal access function; `l` is expected to be an arbitrary list, `path` +
+ + 071    a (clojure) list of the characters `a` and `d`. Intended to make declaring +
+ + 072    all those fiddly `#'c[ad]+r'` functions a bit easier" +
+ + 073    [l path] +
+ + 074    (cond +
+ + 075      (= l NIL) NIL +
+ + 076      (empty? path) l +
+ + 077      :else (case (last path) +
+ + 078              \a (uaf (CAR l) (butlast path)) +
+ + 079              \d (uaf (CDR l) (butlast path))))) +
+ + 080   +
+ + 081  (defn CAAR [x] (uaf x (seq "aa"))) +
+ + 082  (defn CADR [x] (uaf x (seq "ad"))) +
+ + 083  (defn CDDR [x] (uaf x (seq "dd"))) +
+ + 084  (defn CDAR [x] (uaf x (seq "da"))) +
+ + 085   +
+ + 086  (defn CAAAR [x] (uaf x (seq "aaa"))) +
+ + 087  (defn CAADR [x] (uaf x (seq "aad"))) +
+ + 088  (defn CADAR [x] (uaf x (seq "ada"))) +
+ + 089  (defn CADDR [x] (uaf x (seq "add"))) +
+ + 090  (defn CDDAR [x] (uaf x (seq "dda"))) +
+ + 091  (defn CDDDR [x] (uaf x (seq "ddd"))) +
+ + 092  (defn CDAAR [x] (uaf x (seq "daa"))) +
+ + 093  (defn CDADR [x] (uaf x (seq "dad"))) +
+ + 094   +
+ + 095  (defn CAAAAR [x] (uaf x (seq "aaaa"))) +
+ + 096  (defn CAADAR [x] (uaf x (seq "aada"))) +
+ + 097  (defn CADAAR [x] (uaf x (seq "adaa"))) +
+ + 098  (defn CADDAR [x] (uaf x (seq "adda"))) +
+ + 099  (defn CDDAAR [x] (uaf x (seq "ddaa"))) +
+ + 100  (defn CDDDAR [x] (uaf x (seq "ddda"))) +
+ + 101  (defn CDAAAR [x] (uaf x (seq "daaa"))) +
+ + 102  (defn CDADAR [x] (uaf x (seq "dada"))) +
+ + 103  (defn CAAADR [x] (uaf x (seq "aaad"))) +
+ + 104  (defn CAADDR [x] (uaf x (seq "aadd"))) +
+ + 105  (defn CADADR [x] (uaf x (seq "adad"))) +
+ + 106  (defn CADDDR [x] (uaf x (seq "addd"))) +
+ + 107  (defn CDDADR [x] (uaf x (seq "ddad"))) +
+ + 108  (defn CDDDDR [x] (uaf x (seq "dddd"))) +
+ + 109  (defn CDAADR [x] (uaf x (seq "daad"))) +
+ + 110  (defn CDADDR [x] (uaf x (seq "dadd"))) +
+ + 111   +
+ + 112  (defn EQ +
+ + 113    ;; For some reason providing a doc string for this function breaks the +
+ + 114    ;; Clojure parser! +
+ + 115    [x y] +
+ + 116    (if (and (= (ATOM x) T) (= x y)) T F)) +
+ + 117   +
+ + 118  (defn EQUAL +
+ + 119    "This is a predicate that is true if its two arguments are identical +
+ + 120    S-expressions, and false if they are different. (The elementary predicate +
+ + 121    `EQ` is defined only for atomic arguments.) The definition of `EQUAL` is +
+ + 122    an example of a conditional expression inside a conditional expression. +
+ + 123   +
+ + 124    NOTE: returns F on failure, not NIL" +
+ + 125    [x y] +
+ + 126    (cond +
+ + 127      (= (ATOM x) T) (EQ x y) +
+ + 128      (= (EQUAL (CAR x) (CAR y)) T) (EQUAL (CDR x) (CDR y)) +
+ + 129      :else F)) +
+ + 130   +
+ + 131  (defn SUBST +
+ + 132    "This function gives the result of substituting the S-expression `x` for +
+ + 133    all occurrences of the atomic symbol `y` in the S-expression `z`." +
+ + 134    [x y z] +
+ + 135    (cond +
+ + 136      (= (EQUAL y z) T) x +
+ + 137      (= (ATOM? z) T) z ;; NIL is a symbol +
+ + 138      :else +
+ + 139      (make-cons-cell (SUBST x y (CAR z)) (SUBST x y (CDR z))))) +
+ + 140   +
+ + 141  (defn APPEND +
+ + 142    "Append the the elements of `y` to the elements of `x`. +
+ + 143   +
+ + 144    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 145    See page 11 of the Lisp 1.5 Programmers Manual." +
+ + 146    [x y] +
+ + 147    (cond +
+ + 148      (= x NIL) y +
+ + 149      :else +
+ + 150      (make-cons-cell (CAR x) (APPEND (CDR x) y)))) +
+ + 151   +
+ + 152   +
+ + 153  (defn MEMBER +
+ + 154    "This predicate is true if the S-expression `x` occurs among the elements +
+ + 155    of the list `y`. +
+ + 156   +
+ + 157    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. +
+ + 158    See page 11 of the Lisp 1.5 Programmers Manual." +
+ + 159    [x y] +
+ + 160    (cond +
+ + 161      (= y NIL) F ;; NOTE: returns F on falsity, not NIL +
+ + 162      (= (EQUAL x (CAR y)) T) T +
+ + 163      :else (MEMBER x (CDR y)))) +
+ + 164   +
+ + 165  (defn PAIRLIS +
+ + 166    "This function gives the list of pairs of corresponding elements of the +
+ + 167    lists `x` and `y`, and APPENDs this to the list `a`. The resultant list +
+ + 168    of pairs, which is like a table with two columns, is called an +
+ + 169    association list. +
+ + 170   +
+ + 171    Eessentially, it builds the environment on the stack, implementing shallow +
+ + 172    binding. +
+ + 173   +
+ + 174    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 175    See page 12 of the Lisp 1.5 Programmers Manual." +
+ + 176    [x y a] +
+ + 177    (cond +
+ + 178      ;; the original tests only x; testing y as well will be a little more +
+ + 179      ;; robust if `x` and `y` are not the same length. +
+ + 180      (or (= NIL x) (= NIL y)) a +
+ + 181      :else (make-cons-cell +
+ + 182              (make-cons-cell (CAR x) (CAR y)) +
+ + 183              (PAIRLIS (CDR x) (CDR y) a)))) +
+ + 184   +
+ + 185  (defn ASSOC +
+ + 186    "If a is an association list such as the one formed by PAIRLIS in the above +
+ + 187    example, then assoc will produce the first pair whose first term is x. Thus +
+ + 188    it is a table searching function. +
+ + 189   +
+ + 190    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 191    See page 12 of the Lisp 1.5 Programmers Manual." +
+ + 192    [x a] +
+ + 193    (cond +
+ + 194      (= NIL a) NIL ;; this clause is not present in the original but is added for +
+ + 195      ;; robustness. +
+ + 196      (= (EQUAL (CAAR a) x) T) (CAR a) +
+ + 197      :else +
+ + 198      (ASSOC x (CDR a)))) +
+ + 199   +
+ + 200  (defn- SUB2 +
+ + 201    "Internal to `SUBLIS`, q.v., which SUBSTitutes into a list from a store. +
+ + 202    ? I think this is doing variable binding in the stack frame?" +
+ + 203    [a z] +
+ + 204    (cond +
+ + 205      (= NIL a) z +
+ + 206      (= (CAAR a) z) (CDAR a) ;; TODO: this looks definitely wrong +
+ + 207      :else +
+ + 208      (SUB2 (CDR a) z))) +
+ + 209   +
+ + 210  (defn SUBLIS +
+ + 211    "Here `a` is assumed to be an association list of the form +
+ + 212    `((ul . vl)...(un . vn))`, where the `u`s are atomic, and `y` is any +
+ + 213    S-expression. What `SUBLIS` does, is to treat the `u`s as variables when +
+ + 214    they occur in `y`, and to SUBSTitute the corresponding `v`s from the pair +
+ + 215    list. +
+ + 216   +
+ + 217    My interpretation is that this is variable binding in the stack frame. +
+ + 218   +
+ + 219    All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 220    See page 12 of the Lisp 1.5 Programmers Manual." +
+ + 221    [a y] +
+ + 222    (cond +
+ + 223      (= (ATOM? y) T) (SUB2 a y) +
+ + 224      :else +
+ + 225      (make-cons-cell (SUBLIS a (CAR y)) (SUBLIS a (CDR y))))) +
+ + 226   +
+ + 227  (defn APPLY +
+ + 228    "For bootstrapping, at least, a version of APPLY written in Clojure. +
+ + 229    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. +
+ + 230    See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 231    [function args environment] +
+ + 232    (cond +
+ + 233      (= +
+ + 234        (ATOM? function) +
+ + 235        T)(cond +
+ + 236             ;; TODO: doesn't check whether `function` is bound in the environment; +
+ + 237             ;; we'll need that before we can bootstrap. +
+ + 238             (= function 'CAR) (CAAR args) +
+ + 239             (= function 'CDR) (CDAR args) +
+ + 240             (= function 'CONS) (make-cons-cell (CAR args) (CADR args)) +
+ + 241             (= function 'ATOM) (if (ATOM? (CAR args)) T NIL) +
+ + 242             (= function 'EQ) (if (= (CAR args) (CADR args)) T NIL) +
+ + 243             :else +
+ + 244             (APPLY +
+ + 245               (EVAL function environment) +
+ + 246               args +
+ + 247               environment)) +
+ + 248      (= (first function) 'LAMBDA) (EVAL +
+ + 249                                     (CADDR function) +
+ + 250                                     (PAIRLIS (CADR function) args environment)) +
+ + 251      (= (first function) 'LABEL) (APPLY +
+ + 252                                    (CADDR function) +
+ + 253                                    args +
+ + 254                                    (make-cons-cell +
+ + 255                                      (make-cons-cell +
+ + 256                                        (CADR function) +
+ + 257                                        (CADDR function)) +
+ + 258                                      environment)))) +
+ + 259   +
+ + 260  (defn- EVCON +
+ + 261    "Inner guts of primitive COND. All args are assumed to be +
+ + 262    `beowulf.cons-cell/ConsCell` objects. +
+ + 263    See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 264    [clauses env] +
+ + 265    (if +
+ + 266      (not= (EVAL (CAAR clauses) env) NIL) +
+ + 267      (EVAL (CADAR clauses) env) +
+ + 268      (EVCON (CDR clauses) env))) +
+ + 269   +
+ + 270  (defn- EVLIS +
+ + 271    "Map `EVAL` across this list of `args` in the context of this +
+ + 272    `env`ironment.All args are assumed to be `beowulf.cons-cell/ConsCell` objects. +
+ + 273    See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 274    [args env] +
+ + 275    (cond +
+ + 276      (= NIL args) NIL +
+ + 277      :else +
+ + 278      (make-cons-cell +
+ + 279        (EVAL (CAR args) env) +
+ + 280        (EVLIS (CDR args) env)))) +
+ + 281   +
+ + 282  (deftrace traced-eval +
+ + 283    "Essentially, identical to EVAL except traced." +
+ + 284    [expr env] +
+ + 285    (cond +
+ + 286      (= +
+ + 287        (ATOM? expr) T) +
+ + 288      (CDR (ASSOC expr env)) +
+ + 289      (= +
+ + 290        (ATOM? (CAR expr)) +
+ + 291        T)(cond +
+ + 292             (= (CAR expr) 'QUOTE) (CADR expr) +
+ + 293             (= (CAR expr) 'COND) (EVCON (CDR expr) env) +
+ + 294             :else (APPLY +
+ + 295                     (CAR expr) +
+ + 296                     (EVLIS (CDR expr) env) +
+ + 297                     env)) +
+ + 298      :else (APPLY +
+ + 299              (CAR expr) +
+ + 300              (EVLIS (CDR expr) env) +
+ + 301              env))) +
+ + 302   +
+ + 303  (defn EVAL +
+ + 304    "For bootstrapping, at least, a version of EVAL written in Clojure. +
+ + 305    All args are assumed to be symbols or `beowulf.cons-cell/ConsCell` objects. +
+ + 306    See page 13 of the Lisp 1.5 Programmers Manual." +
+ + 307    [expr env] +
+ + 308    (cond +
+ + 309      (true? (:trace *options*)) +
+ + 310      (traced-eval expr env) +
+ + 311      (= +
+ + 312        (ATOM? expr) T) +
+ + 313      (CDR (ASSOC expr env)) +
+ + 314      (= +
+ + 315        (ATOM? (CAR expr)) +
+ + 316        T)(cond +
+ + 317             (= (CAR expr) 'QUOTE) (CADR expr) +
+ + 318             (= (CAR expr) 'COND) (EVCON (CDR expr) env) +
+ + 319             :else (APPLY +
+ + 320                     (CAR expr) +
+ + 321                     (EVLIS (CDR expr) env) +
+ + 322                     env)) +
+ + 323      :else (APPLY +
+ + 324              (CAR expr) +
+ + 325              (EVLIS (CDR expr) env) +
+ + 326              env))) +
+ + 327   +
+ + 328   +
+ + 329   +
+ + diff --git a/docs/cloverage/beowulf/cons_cell.clj.html b/docs/cloverage/beowulf/cons_cell.clj.html new file mode 100644 index 0000000..c820206 --- /dev/null +++ b/docs/cloverage/beowulf/cons_cell.clj.html @@ -0,0 +1,455 @@ + + + + beowulf/cons_cell.clj + + + + 001  (ns beowulf.cons-cell +
+ + 002    "The fundamental cons cell on which all Lisp structures are built. +
+ + 003    Lisp 1.5 lists do not necessarily have a sequence as their CDR, so +
+ + 004    cannot be implemented on top of Clojure lists.") +
+ + 005   +
+ + 006  (def NIL (symbol "NIL")) +
+ + 007   +
+ + 008  (def T (symbol "T")) ;; true. +
+ + 009   +
+ + 010  (def F (symbol "F")) ;; false as distinct from nil +
+ + 011   +
+ + 012  (deftype ConsCell [CAR CDR] +
+ + 013    clojure.lang.ISeq +
+ + 014    (cons [this x] (ConsCell. x this)) +
+ + 015    (first [this] (.CAR this)) +
+ + 016    ;; next and more must return ISeq: +
+ + 017    ;; https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/ISeq.java +
+ + 018    (more [this] (if +
+ + 019                   (seq? (.CDR this)) +
+ + 020                   (.CDR this) +
+ + 021                   clojure.lang.PersistentList/EMPTY)) +
+ + 022    (next [this] (if +
+ + 023                   (seq? (.CDR this)) +
+ + 024                   (.CDR this) +
+ + 025                   nil ;; next returns nil when empty +
+ + 026                   )) +
+ + 027   +
+ + 028    clojure.lang.Seqable +
+ + 029    (seq [this] this) +
+ + 030   +
+ + 031    ;; for some reason this marker protocol is needed otherwise compiler complains +
+ + 032    ;; that `nth not supported on ConsCell` +
+ + 033    clojure.lang.Sequential +
+ + 034   +
+ + 035    clojure.lang.IPersistentCollection +
+ + 036    (count [this] (if +
+ + 037                    (coll? (.CDR this)) +
+ + 038                    (inc (.count (.CDR this))) +
+ + 039                    1)) +
+ + 040    (empty [this] false) ;; a cons cell is by definition not empty. +
+ + 041    (equiv [this other] (if +
+ + 042                          (seq? other) +
+ + 043                          (and +
+ + 044                            (if +
+ + 045                              (and +
+ + 046                                (seq? (first this)) +
+ + 047                                (seq? (first other))) +
+ + 048                              (.equiv (first this) (first other)) +
+ + 049                              (= (first this) (first other))) +
+ + 050                            (if +
+ + 051                              (and +
+ + 052                                (seq? (rest this)) +
+ + 053                                (seq? (rest other))) +
+ + 054                              (.equiv (rest this) (rest other)) +
+ + 055                              (= (rest this) (rest other)))) +
+ + 056                          false))) +
+ + 057   +
+ + 058  (defn- to-string +
+ + 059    "Printing ConsCells gave me a *lot* of trouble. This is an internal function +
+ + 060    used by the print-method override (below) in order that the standard Clojure +
+ + 061    `print` and `str` functions will print ConsCells correctly. The argument +
+ + 062    `cell` must, obviously, be an instance of `ConsCell`." +
+ + 063    [cell] +
+ + 064    (loop [c cell +
+ + 065           n 0 +
+ + 066           s "("] +
+ + 067      (if +
+ + 068        (instance? beowulf.cons_cell.ConsCell c) +
+ + 069        (let [car (.CAR c) +
+ + 070              cdr (.CDR c) +
+ + 071              cons? (instance? beowulf.cons_cell.ConsCell cdr) +
+ + 072              ss (str +
+ + 073                   s +
+ + 074                   (to-string car) +
+ + 075                   (cond +
+ + 076                     cons? +
+ + 077                     " " +
+ + 078                     (or (nil? cdr) (= cdr 'NIL)) +
+ + 079                     ")" +
+ + 080                     :else +
+ + 081                     (str " . " (to-string cdr) ")")))] +
+ + 082          (if +
+ + 083            cons? +
+ + 084            (recur cdr (inc n) ss) +
+ + 085            ss)) +
+ + 086        (str c)))) +
+ + 087   +
+ + 088  (defn pretty-print +
+ + 089    "This isn't the world's best pretty printer but it sort of works." +
+ + 090    ([^beowulf.cons_cell.ConsCell cell] +
+ + 091     (println (pretty-print cell 80 0))) +
+ + 092    ([^beowulf.cons_cell.ConsCell cell width level] +
+ + 093     (loop [c cell +
+ + 094            n (inc level) +
+ + 095            s "("] +
+ + 096       (if +
+ + 097         (instance? beowulf.cons_cell.ConsCell c) +
+ + 098         (let [car (.CAR c) +
+ + 099               cdr (.CDR c) +
+ + 100               cons? (instance? beowulf.cons_cell.ConsCell cdr) +
+ + 101               print-width (count (print-str c)) +
+ + 102               indent (apply str (repeat n "  ")) +
+ + 103               ss (str +
+ + 104                    s +
+ + 105                    (pretty-print car width n) +
+ + 106                    (cond +
+ + 107                      cons? +
+ + 108                      (if +
+ + 109                        (< (+ (count indent) print-width) width) +
+ + 110                        " " +
+ + 111                        (str "\n" indent)) +
+ + 112                      (or (nil? cdr) (= cdr 'NIL)) +
+ + 113                      ")" +
+ + 114                      :else +
+ + 115                      (str " . " (pretty-print cdr width n) ")")))] +
+ + 116           (if +
+ + 117             cons? +
+ + 118             (recur cdr n ss) +
+ + 119             ss)) +
+ + 120         (str c))))) +
+ + 121   +
+ + 122   +
+ + 123   +
+ + 124  (defmethod clojure.core/print-method +
+ + 125    ;;; I have not worked out how to document defmethod without blowing up the world. +
+ + 126    beowulf.cons_cell.ConsCell +
+ + 127    [this writer] +
+ + 128    (.write writer (to-string this))) +
+ + 129   +
+ + 130   +
+ + 131  (defmacro make-cons-cell +
+ + 132    "Construct a new instance of cons cell with this `car` and `cdr`." +
+ + 133    [car cdr] +
+ + 134    `(ConsCell. ~car ~cdr)) +
+ + 135   +
+ + 136  (defn make-beowulf-list +
+ + 137    "Construct a linked list of cons cells with the same content as the +
+ + 138    sequence `x`." +
+ + 139    [x] +
+ + 140    (cond +
+ + 141      (empty? x) NIL +
+ + 142      (coll? x) (ConsCell. +
+ + 143                  (if +
+ + 144                    (seq? (first x)) +
+ + 145                    (make-beowulf-list (first x)) +
+ + 146                    (first x)) +
+ + 147                  (make-beowulf-list (rest x))) +
+ + 148      :else +
+ + 149      NIL)) +
+ + diff --git a/docs/cloverage/beowulf/core.clj.html b/docs/cloverage/beowulf/core.clj.html new file mode 100644 index 0000000..ab4e3d0 --- /dev/null +++ b/docs/cloverage/beowulf/core.clj.html @@ -0,0 +1,239 @@ + + + + beowulf/core.clj + + + + 001  (ns beowulf.core +
+ + 002    (:require [beowulf.bootstrap :refer [EVAL oblist *options*]] +
+ + 003              [beowulf.read :refer [READ]] +
+ + 004              [clojure.java.io :as io] +
+ + 005              [clojure.pprint :refer [pprint]] +
+ + 006              [clojure.tools.cli :refer [parse-opts]] +
+ + 007              [environ.core :refer [env]]) +
+ + 008    (:gen-class)) +
+ + 009   +
+ + 010  (def cli-options +
+ + 011    [["-h" "--help"] +
+ + 012     ["-p PROMPT" "--prompt PROMPT" "Set the REPL prompt to PROMPT" +
+ + 013      :default "Sprecan::"] +
+ + 014     ["-r INITFILE" "--read INITFILE" "Read Lisp functions from the file INITFILE" +
+ + 015      :validate [#(and +
+ + 016                    (.exists (io/file %)) +
+ + 017                    (.canRead (io/file %))) +
+ + 018                 "Could not find initfile"]] +
+ + 019     ["-s" "--strict" "Strictly interpret the Lisp 1.5 language, without extensions."] +
+ + 020     ["-t" "--trace" "Trace Lisp evaluation."]]) +
+ + 021   +
+ + 022  (defn repl +
+ + 023    "Read/eval/print loop." +
+ + 024    [prompt] +
+ + 025    (loop [] +
+ + 026      (print prompt) +
+ + 027      (flush) +
+ + 028      (try +
+ + 029        (let [input (read-line)] +
+ + 030          (cond +
+ + 031            (= input "quit") (throw (ex-info "\nFærwell!" {:cause :quit})) +
+ + 032            input (println (str ">  " (print-str (EVAL (READ input) @oblist)))) +
+ + 033            :else (println))) +
+ + 034        (catch +
+ + 035          Exception +
+ + 036          e +
+ + 037          (let [data (ex-data e)] +
+ + 038            (println (.getMessage e)) +
+ + 039            (if +
+ + 040              data +
+ + 041              (case (:cause data) +
+ + 042                :parse-failure (println (:failure data)) +
+ + 043                :strict nil ;; the message, which has already been printed, is enough. +
+ + 044                :quit (throw e) +
+ + 045                ;; default +
+ + 046                (pprint data)))))) +
+ + 047      (recur))) +
+ + 048   +
+ + 049  (defn -main +
+ + 050    [& opts] +
+ + 051    (let [args (parse-opts opts cli-options)] +
+ + 052      (println +
+ + 053        (str +
+ + 054          "\nHider wilcuman. Béowulf is mín nama.\n" +
+ + 055          (if +
+ + 056            (System/getProperty "beowulf.version") +
+ + 057            (str "Síðe " (System/getProperty "beowulf.version") "\n")) +
+ + 058          (if +
+ + 059            (:help (:options args)) +
+ + 060            (:summary args)) +
+ + 061          (if (:errors args) +
+ + 062            (apply str (interpose "; " (:errors args)))) +
+ + 063          "\nSprecan 'quit' tó laéfan\n")) +
+ + 064      (binding [*options* (:options args)] +
+ + 065        (try +
+ + 066          (repl (str (:prompt (:options args)) " ")) +
+ + 067          (catch +
+ + 068            Exception +
+ + 069            e +
+ + 070            (let [data (ex-data e)] +
+ + 071              (if +
+ + 072                data +
+ + 073                (case (:cause data) +
+ + 074                  :quit nil +
+ + 075                  ;; default +
+ + 076                  (pprint data)) +
+ + 077                (println e)))))))) +
+ + diff --git a/docs/cloverage/beowulf/host.clj.html b/docs/cloverage/beowulf/host.clj.html new file mode 100644 index 0000000..5671aa2 --- /dev/null +++ b/docs/cloverage/beowulf/host.clj.html @@ -0,0 +1,35 @@ + + + + beowulf/host.clj + + + + 001  (ns beowulf.host) +
+ + 002   +
+ + 003  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 004  ;;; +
+ + 005  ;;; This file provides Lisp 1.5 functions which can't be (or can't efficiently +
+ + 006  ;;; be) implemented in Lisp 1.5, which therefore need to be implemented in the +
+ + 007  ;;; host language, in this case Clojure. +
+ + 008  ;;; +
+ + 009  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + diff --git a/docs/cloverage/beowulf/read.clj.html b/docs/cloverage/beowulf/read.clj.html new file mode 100644 index 0000000..673b400 --- /dev/null +++ b/docs/cloverage/beowulf/read.clj.html @@ -0,0 +1,911 @@ + + + + beowulf/read.clj + + + + 001  (ns beowulf.read +
+ + 002    (:require [beowulf.bootstrap :refer [*options*]] +
+ + 003              [clojure.math.numeric-tower :refer [expt]] +
+ + 004              [clojure.string :refer [starts-with? upper-case]] +
+ + 005              [instaparse.core :as i] +
+ + 006              [beowulf.cons-cell :refer [make-beowulf-list make-cons-cell NIL]])) +
+ + 007   +
+ + 008  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 009  ;;; +
+ + 010  ;;; This file provides the reader required for boostrapping. It's not a bad +
+ + 011  ;;; reader - it provides feedback on errors found in the input - but it isn't +
+ + 012  ;;; the real Lisp reader. +
+ + 013  ;;; +
+ + 014  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +
+ + 015   +
+ + 016  (declare generate) +
+ + 017   +
+ + 018  (def parse +
+ + 019    "Parse a string presented as argument into a parse tree which can then +
+ + 020    be operated upon further." +
+ + 021    (i/parser +
+ + 022      (str +
+ + 023        ;; top level: we accept mexprs as well as sexprs. +
+ + 024        "expr := mexpr | sexpr;" +
+ + 025   +
+ + 026        ;; mexprs. I'm pretty clear that Lisp 1.5 could never read these, +
+ + 027        ;; but it's a convenience. +
+ + 028        "mexpr := λexpr | fncall | defn | cond | mvar | mexpr comment; +
+ + 029        λexpr := λ lsqb bindings semi-colon body rsqb; +
+ + 030        λ := 'λ'; +
+ + 031        bindings := lsqb args rsqb; +
+ + 032        body := (expr semi-colon opt-space)* expr; +
+ + 033        fncall := fn-name lsqb args rsqb; +
+ + 034        lsqb := '['; +
+ + 035        rsqb := ']'; +
+ + 036        defn := mexpr opt-space '=' opt-space mexpr; +
+ + 037        cond := lsqb (cond-clause semi-colon opt-space)* cond-clause rsqb; +
+ + 038        cond-clause := expr opt-space arrow opt-space expr; +
+ + 039        arrow := '->'; +
+ + 040        args := (expr semi-colon opt-space)* expr; +
+ + 041        fn-name := mvar; +
+ + 042        mvar := #'[a-z]+'; +
+ + 043        semi-colon := ';';" +
+ + 044   +
+ + 045        ;; comments. I'm pretty confident Lisp 1.5 did NOT have these. +
+ + 046        "comment := opt-space <';;'> #'[^\\n\\r]*';" +
+ + 047   +
+ + 048        ;; sexprs. Note it's not clear to me whether Lisp 1.5 had the quote macro, +
+ + 049        ;; but I've included it on the basis that it can do little harm. +
+ + 050        "sexpr := quoted-expr | atom | number | dotted-pair | list | sexpr comment; +
+ + 051        list := lpar sexpr rpar | lpar (sexpr sep)* rpar | lpar (sexpr sep)* dot-terminal; +
+ + 052        dotted-pair := lpar dot-terminal ; +
+ + 053        dot := '.'; +
+ + 054        lpar := '('; +
+ + 055        rpar := ')'; +
+ + 056        quoted-expr := quote sexpr; +
+ + 057        quote := '\\''; +
+ + 058        dot-terminal := sexpr space dot space sexpr rpar; +
+ + 059        space := #'\\p{javaWhitespace}+'; +
+ + 060        opt-space := #'\\p{javaWhitespace}*'; +
+ + 061        sep := ',' | opt-space; +
+ + 062        atom := #'[A-Z][A-Z0-9]*';" +
+ + 063   +
+ + 064        ;; Lisp 1.5 supported octal as well as decimal and scientific notation +
+ + 065        "number := integer | decimal | scientific | octal; +
+ + 066        integer := #'-?[1-9][0-9]*'; +
+ + 067        decimal := #'-?[1-9][0-9]*\\.?[0-9]*' | #'0.[0-9]*'; +
+ + 068        scientific := coefficient e exponent; +
+ + 069        coefficient := decimal; +
+ + 070        exponent := integer; +
+ + 071        e := 'E'; +
+ + 072        octal := #'[+-]?[0-7]+{1,12}' q scale-factor; +
+ + 073        q := 'Q'; +
+ + 074        scale-factor := #'[0-9]*'"))) +
+ + 075   +
+ + 076  (defn simplify +
+ + 077    "Simplify this parse tree `p`. If `p` is an instaparse failure object, throw +
+ + 078    an `ex-info`, with `p` as the value of its `:failure` key." +
+ + 079    ([p] +
+ + 080     (if +
+ + 081       (instance? instaparse.gll.Failure p) +
+ + 082       (throw (ex-info "Ic ne behæfd" {:cause :parse-failure :failure p})) +
+ + 083       (simplify p :sexpr))) +
+ + 084    ([p context] +
+ + 085    (if +
+ + 086      (coll? p) +
+ + 087      (apply +
+ + 088        vector +
+ + 089        (remove +
+ + 090          #(if (coll? %) (empty? %)) +
+ + 091          (case (first p) +
+ + 092            (:arg :expr :coefficient :fn-name :number :sexpr) (simplify (second p) context) +
+ + 093            (:λexpr +
+ + 094              :args :bindings :body :cond :cond-clause :dot-terminal +
+ + 095              :fncall :octal :quoted-expr :scientific) (map #(simplify % context) p) +
+ + 096            (:arrow :dot :e :lpar :lsqb :opt-space :q :quote :rpar :rsqb +
+ + 097              :semi-colon :sep :space) nil +
+ + 098            :atom (if +
+ + 099                    (= context :mexpr) +
+ + 100                    [:quoted-expr p] +
+ + 101                    p) +
+ + 102            :comment (if +
+ + 103                       (:strict *options*) +
+ + 104                       (throw +
+ + 105                         (ex-info "Cannot parse comments in strict mode" +
+ + 106                                  {:cause :strict}))) +
+ + 107            :dotted-pair (if +
+ + 108                           (= context :mexpr) +
+ + 109                           [:fncall +
+ + 110                            [:mvar "cons"] +
+ + 111                            [:args +
+ + 112                             (simplify (nth p 1) context) +
+ + 113                             (simplify (nth p 2) context)]] +
+ + 114                           (map simplify p)) +
+ + 115            :mexpr (if +
+ + 116                     (:strict *options*) +
+ + 117                     (throw +
+ + 118                       (ex-info "Cannot parse meta expressions in strict mode" +
+ + 119                                {:cause :strict})) +
+ + 120                     (simplify (second p) :mexpr)) +
+ + 121            :list (if +
+ + 122                    (= context :mexpr) +
+ + 123                    [:fncall +
+ + 124                     [:mvar "list"] +
+ + 125                     [:args (apply vector (map simplify (rest p)))]] +
+ + 126                    (map #(simplify % context) p)) +
+ + 127            ;;default +
+ + 128            p))) +
+ + 129      p))) +
+ + 130   +
+ + 131   +
+ + 132  ;; # From Lisp 1.5 Programmers Manual, page 10 +
+ + 133  ;; Note that I've retyped much of this, since copy/pasting out of PDF is less +
+ + 134  ;; than reliable. Any typos are mine. Quote starts [[ +
+ + 135   +
+ + 136  ;; We are now in a position to define the universal LISP function +
+ + 137  ;; evalquote[fn;args], When evalquote is given a function and a list of arguments +
+ + 138  ;; for that function, it computes the value of the function applied to the arguments. +
+ + 139  ;; LISP functions have S-expressions as arguments. In particular, the argument "fn" +
+ + 140  ;; of the function evalquote must be an S-expression. Since we have been +
+ + 141  ;; writing functions as M-expressions, it is necessary to translate them into +
+ + 142  ;; S-expressions. +
+ + 143   +
+ + 144  ;; The following rules define a method of translating functions written in the +
+ + 145  ;; meta-language into S-expressions. +
+ + 146  ;; 1. If the function is represented by its name, it is translated by changing +
+ + 147  ;;    all of the letters to upper case, making it an atomic symbol. Thus is +
+ + 148  ;;    translated to CAR. +
+ + 149  ;; 2. If the function uses the lambda notation, then the expression +
+ + 150  ;;    λ[[x ..;xn]; ε] is translated into (LAMBDA (X1 ...XN) ε*), where ε* is the translation +
+ + 151  ;;    of ε. +
+ + 152  ;; 3. If the function begins with label, then the translation of +
+ + 153  ;;    label[α;ε] is (LABEL α* ε*). +
+ + 154   +
+ + 155  ;; Forms are translated as follows: +
+ + 156  ;; 1. A variable, like a function name, is translated by using uppercase letters. +
+ + 157  ;;    Thus the translation of varl is VAR1. +
+ + 158  ;; 2. The obvious translation of letting a constant translate into itself will not +
+ + 159  ;;    work. Since the translation of x is X, the translation of X must be something +
+ + 160  ;;    else to avoid ambiguity. The solution is to quote it. Thus X is translated +
+ + 161  ;;    into (QUOTE X). +
+ + 162  ;; 3. The form fn[argl;. ..;argn] is translated into (fn* argl* ...argn*) +
+ + 163  ;; 4. The conditional expression [pl-el;...;pn-en] is translated into +
+ + 164  ;;    (COND (p1* e1*)...(pn* en*)) +
+ + 165   +
+ + 166  ;; ## Examples +
+ + 167   +
+ + 168  ;; M-expressions                                S-expressions +
+ + 169  ;; x                                            X +
+ + 170  ;; car                                          CAR +
+ + 171  ;; car[x]                                       (CAR X) +
+ + 172  ;; T                                            (QUOTE T) +
+ + 173  ;; ff[car [x]]                                  (FF (CAR X)) +
+ + 174  ;; [atom[x]->x; T->ff[car[x]]]                  (COND ((ATOM X) X) +
+ + 175  ;;                                                ((QUOTE T)(FF (CAR X)))) +
+ + 176  ;; label[ff;λ[[x];[atom[x]->x; T->ff[car[x]]]]] (LABEL FF (LAMBDA (X) (COND +
+ + 177  ;;                                                ((ATOM X) X) +
+ + 178  ;;                                                ((QUOTE T)(FF (CAR X)))))) +
+ + 179   +
+ + 180  ;; ]] quote ends +
+ + 181   +
+ + 182  (defn gen-cond-clause +
+ + 183    "Generate a cond clause from this simplified parse tree fragment `p`; +
+ + 184    returns `nil` if `p` does not represent a cond clause." +
+ + 185    [p] +
+ + 186    (if +
+ + 187      (and (coll? p)(= :cond-clause (first p))) +
+ + 188      (make-beowulf-list +
+ + 189        (list (generate (nth p 1)) +
+ + 190                       (generate (nth p 2)))))) +
+ + 191   +
+ + 192  (defn gen-cond +
+ + 193    "Generate a cond statement from this simplified parse tree fragment `p`; +
+ + 194    returns `nil` if `p` does not represent a (MEXPR) cond statement." +
+ + 195    [p] +
+ + 196    (if +
+ + 197      (and (coll? p)(= :cond (first p))) +
+ + 198      (make-beowulf-list +
+ + 199        (cons +
+ + 200          'COND +
+ + 201          (map +
+ + 202            gen-cond-clause +
+ + 203            (rest p)))))) +
+ + 204   +
+ + 205  (defn gen-fn-call +
+ + 206    "Generate a function call from this simplified parse tree fragment `p`; +
+ + 207    returns `nil` if `p` does not represent a (MEXPR) function call. +
+ + 208    TODO: I'm not yet certain but it appears that args in mexprs are +
+ + 209    implicitly quoted; this function does not (yet) do that." +
+ + 210    [p] +
+ + 211    (if +
+ + 212      (and (coll? p)(= :fncall (first p))(= :mvar (first (second p)))) +
+ + 213      (make-cons-cell +
+ + 214        (generate (second p)) +
+ + 215        (generate (nth p 2))))) +
+ + 216   +
+ + 217   +
+ + 218  (defn gen-dot-terminated-list +
+ + 219    "Generate a list, which may be dot-terminated, from this partial parse tree +
+ + 220    'p'. Note that the function acts recursively and progressively decapitates +
+ + 221    its argument, so that the argument will not always be a valid parse tree." +
+ + 222    [p] +
+ + 223    (cond +
+ + 224      (empty? p) +
+ + 225      NIL +
+ + 226      (and (coll? (first p)) (= :dot-terminal (first (first p)))) +
+ + 227      (let [dt (first p)] +
+ + 228        (make-cons-cell +
+ + 229          (generate (nth dt 1)) +
+ + 230          (generate (nth dt 2)))) +
+ + 231      :else +
+ + 232      (make-cons-cell +
+ + 233        (generate (first p)) +
+ + 234        (gen-dot-terminated-list (rest p))))) +
+ + 235   +
+ + 236   +
+ + 237  (defn strip-leading-zeros +
+ + 238    "`read-string` interprets strings with leading zeros as octal; strip +
+ + 239    any from this string `s`. If what's left is empty (i.e. there were +
+ + 240    only zeros, return `\"0\"`." +
+ + 241    ([s] +
+ + 242     (strip-leading-zeros s "")) +
+ + 243    ([s prefix] +
+ + 244     (if +
+ + 245       (empty? s) "0" +
+ + 246       (case (first s) +
+ + 247         (\+ \-)(strip-leading-zeros (subs s 1) (str (first s) prefix)) +
+ + 248         "0" (strip-leading-zeros (subs s 1) prefix) +
+ + 249         (str prefix s))))) +
+ + 250   +
+ + 251  (defn generate +
+ + 252    "Generate lisp structure from this parse tree `p`. It is assumed that +
+ + 253    `p` has been simplified." +
+ + 254    [p] +
+ + 255    (if +
+ + 256      (coll? p) +
+ + 257      (case (first p) +
+ + 258        :λ "LAMBDA" +
+ + 259        :λexpr (make-cons-cell +
+ + 260                 (generate (nth p 1)) +
+ + 261                 (make-cons-cell (generate (nth p 2)) +
+ + 262                                 (generate (nth p 3)))) +
+ + 263        (:args :list) (gen-dot-terminated-list (rest p)) +
+ + 264        :atom (symbol (second p)) +
+ + 265        :bindings (generate (second p)) +
+ + 266        :body (make-beowulf-list (map generate (rest p))) +
+ + 267        :cond (gen-cond p) +
+ + 268        (:decimal :integer) (read-string (strip-leading-zeros (second p))) +
+ + 269        :dotted-pair (make-cons-cell +
+ + 270                       (generate (nth p 1)) +
+ + 271                       (generate (nth p 2))) +
+ + 272        :exponent (generate (second p)) +
+ + 273        :fncall (gen-fn-call p) +
+ + 274        :mvar (symbol (upper-case (second p))) +
+ + 275        :octal (let [n (read-string (strip-leading-zeros (second p) "0")) +
+ + 276                     scale (generate (nth p 2))] +
+ + 277                 (* n (expt 8 scale))) +
+ + 278   +
+ + 279        ;; the quote read macro (which probably didn't exist in Lisp 1.5, but...) +
+ + 280        :quoted-expr (make-beowulf-list (list 'QUOTE (generate (second p)))) +
+ + 281        :scale-factor (if +
+ + 282                        (empty? (second p)) 0 +
+ + 283                        (read-string (strip-leading-zeros (second p)))) +
+ + 284        :scientific (let [n (generate (second p)) +
+ + 285                          exponent (generate (nth p 2))] +
+ + 286                      (* n (expt 10 exponent))) +
+ + 287   +
+ + 288        ;; default +
+ + 289        (throw (Exception. (str "Cannot yet generate " (first p))))) +
+ + 290      p)) +
+ + 291   +
+ + 292  (defmacro gsp +
+ + 293    "Shortcut macro - the internals of read; or, if you like, read-string. +
+ + 294    Argument `s` should be a string representation of a valid Lisp +
+ + 295    expression." +
+ + 296    [s] +
+ + 297    `(generate (simplify (parse ~s)))) +
+ + 298   +
+ + 299  (defn READ +
+ + 300    [input] +
+ + 301    (gsp (or input (read-line)))) +
+ + diff --git a/docs/cloverage/coverage.css b/docs/cloverage/coverage.css new file mode 100644 index 0000000..2be4e57 --- /dev/null +++ b/docs/cloverage/coverage.css @@ -0,0 +1,40 @@ +.covered { + font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace; + background-color: #558B55; +} + +.not-covered { + font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace; + background-color: red; +} + +.partial { + font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace; + background-color: orange; +} + +.not-tracked { + font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace; +} + +.blank { + font-family: 'Bitstream Vera Sans Mono', 'Courier', monospace; +} + +td { + padding-right: 10px; +} + +td.with-bar { + width: 250px; + text-align: center; +} + +td.with-number { + text-align: right; +} + +td.ns-name { + min-width: 150px; + padding-right: 25px; +} diff --git a/docs/cloverage/index.html b/docs/cloverage/index.html new file mode 100644 index 0000000..2afcfff --- /dev/null +++ b/docs/cloverage/index.html @@ -0,0 +1,104 @@ + + + + + Coverage Summary + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Namespace Forms Forms % Lines Lines %TotalBlankInstrumented
beowulf.bootstrap
752
363
67.44 %
103
41
32
81.82 %32939176
beowulf.cons-cell
129
98
56.83 %
36
3
26
60.00 %1491565
beowulf.core
170
17
90.91 %
43
1
5
89.80 %77349
beowulf.host
1
100.00 %
1
100.00 %911
beowulf.read
588
130
81.89 %
93
10
23
81.75 %30128126
Totals:72.95 %79.38 %
+ + diff --git a/docs/codox/beowulf.bootstrap.html b/docs/codox/beowulf.bootstrap.html new file mode 100644 index 0000000..1ae62c3 --- /dev/null +++ b/docs/codox/beowulf.bootstrap.html @@ -0,0 +1,11 @@ + +beowulf.bootstrap documentation

Project

Topics

Namespaces

Public Vars

beowulf.bootstrap

TODO: write docs

*options*

dynamic

Command line options from invocation.

view source

APPEND

(APPEND x y)

Append the the elements of y to the elements of x.

+

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 11 of the Lisp 1.5 Programmers Manual.

view source

APPLY

(APPLY function args environment)

For bootstrapping, at least, a version of APPLY written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.

view source

ASSOC

(ASSOC x a)

If a is an association list such as the one formed by PAIRLIS in the above example, then assoc will produce the first pair whose first term is x. Thus it is a table searching function.

+

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual.

view source

ATOM

(ATOM x)

It is not clear to me from the documentation whether (ATOM 7) should return 'T or 'F. I’m going to assume 'T.

view source

ATOM?

(ATOM? x)

The convention of returning 'F from predicates, rather than NIL, is going to tie me in knots. This is a variant of ATOM which returns NIL on failure.

view source

CAAAAR

(CAAAAR x)

TODO: write docs

view source

CAAADR

(CAAADR x)

TODO: write docs

view source

CAAAR

(CAAAR x)

TODO: write docs

view source

CAADAR

(CAADAR x)

TODO: write docs

view source

CAADDR

(CAADDR x)

TODO: write docs

view source

CAADR

(CAADR x)

TODO: write docs

view source

CAAR

(CAAR x)

TODO: write docs

view source

CADAAR

(CADAAR x)

TODO: write docs

view source

CADADR

(CADADR x)

TODO: write docs

view source

CADAR

(CADAR x)

TODO: write docs

view source

CADDAR

(CADDAR x)

TODO: write docs

view source

CADDDR

(CADDDR x)

TODO: write docs

view source

CADDR

(CADDR x)

TODO: write docs

view source

CADR

(CADR x)

TODO: write docs

view source

CAR

(CAR x)

Return the item indicated by the first pointer of a pair. NIL is treated specially: the CAR of NIL is NIL.

view source

CDAAAR

(CDAAAR x)

TODO: write docs

view source

CDAADR

(CDAADR x)

TODO: write docs

view source

CDAAR

(CDAAR x)

TODO: write docs

view source

CDADAR

(CDADAR x)

TODO: write docs

view source

CDADDR

(CDADDR x)

TODO: write docs

view source

CDADR

(CDADR x)

TODO: write docs

view source

CDAR

(CDAR x)

TODO: write docs

view source

CDDAAR

(CDDAAR x)

TODO: write docs

view source

CDDADR

(CDDADR x)

TODO: write docs

view source

CDDAR

(CDDAR x)

TODO: write docs

view source

CDDDAR

(CDDDAR x)

TODO: write docs

view source

CDDDDR

(CDDDDR x)

TODO: write docs

view source

CDDDR

(CDDDR x)

TODO: write docs

view source

CDDR

(CDDR x)

TODO: write docs

view source

CDR

(CDR x)

Return the item indicated by the second pointer of a pair. NIL is treated specially: the CDR of NIL is NIL.

view source

EQ

(EQ x y)

TODO: write docs

view source

EQUAL

(EQUAL x y)

This is a predicate that is true if its two arguments are identical S-expressions, and false if they are different. (The elementary predicate EQ is defined only for atomic arguments.) The definition of EQUAL is an example of a conditional expression inside a conditional expression.

+

NOTE: returns F on failure, not NIL

view source

EVAL

(EVAL expr env)

For bootstrapping, at least, a version of EVAL written in Clojure. All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 13 of the Lisp 1.5 Programmers Manual.

view source

MEMBER

(MEMBER x y)

This predicate is true if the S-expression x occurs among the elements of the list y.

+

All args are assumed to be symbols or beowulf.cons-cell/ConsCell objects. See page 11 of the Lisp 1.5 Programmers Manual.

view source

NULL

(NULL x)

TODO: write docs

view source

oblist

The default environment; modified certainly be LABEL (which seems to be Lisp 1.5’s EQuivalent of SETQ), possibly by other things.

view source

PAIRLIS

(PAIRLIS x y a)

This function gives the list of pairs of corresponding elements of the lists x and y, and APPENDs this to the list a. The resultant list of pairs, which is like a table with two columns, is called an association list.

+

Eessentially, it builds the environment on the stack, implementing shallow binding.

+

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual.

view source

SUBLIS

(SUBLIS a y)

Here a is assumed to be an association list of the form ((ul . vl)...(un . vn)), where the us are atomic, and y is any S-expression. What SUBLIS does, is to treat the us as variables when they occur in y, and to SUBSTitute the corresponding vs from the pair list.

+

My interpretation is that this is variable binding in the stack frame.

+

All args are assumed to be beowulf.cons-cell/ConsCell objects. See page 12 of the Lisp 1.5 Programmers Manual.

view source

SUBST

(SUBST x y z)

This function gives the result of substituting the S-expression x for all occurrences of the atomic symbol y in the S-expression z.

view source

traced-eval

(traced-eval & args__2883__auto__)

Essentially, identical to EVAL except traced.

view source

uaf

(uaf l path)

Universal access function; l is expected to be an arbitrary list, path a (clojure) list of the characters a and d. Intended to make declaring all those fiddly #'c[ad]+r' functions a bit easier

view source
\ No newline at end of file diff --git a/docs/codox/beowulf.cons-cell.html b/docs/codox/beowulf.cons-cell.html new file mode 100644 index 0000000..a87a569 --- /dev/null +++ b/docs/codox/beowulf.cons-cell.html @@ -0,0 +1,3 @@ + +beowulf.cons-cell documentation

Project

Topics

Namespaces

Public Vars

beowulf.cons-cell

TODO: write docs

F

TODO: write docs

view source

make-beowulf-list

(make-beowulf-list x)

TODO: write docs

view source

make-cons-cell

(make-cons-cell a d)

TODO: write docs

view source

NIL

TODO: write docs

view source

pretty-print

(pretty-print cell)(pretty-print cell width level)

This isn’t the world’s best pretty printer but it sort of works.

view source

T

TODO: write docs

view source
\ No newline at end of file diff --git a/docs/codox/beowulf.core.html b/docs/codox/beowulf.core.html new file mode 100644 index 0000000..1f30171 --- /dev/null +++ b/docs/codox/beowulf.core.html @@ -0,0 +1,3 @@ + +beowulf.core documentation

Project

Topics

Namespaces

Public Vars

beowulf.core

TODO: write docs

-main

(-main & opts)

TODO: write docs

view source

cli-options

TODO: write docs

view source

repl

(repl prompt)

Read/eval/print loop.

view source
\ No newline at end of file diff --git a/docs/codox/beowulf.host.html b/docs/codox/beowulf.host.html new file mode 100644 index 0000000..a8c02cc --- /dev/null +++ b/docs/codox/beowulf.host.html @@ -0,0 +1,3 @@ + +beowulf.host documentation

Project

Topics

Namespaces

Public Vars

beowulf.host

TODO: write docs

\ No newline at end of file diff --git a/docs/codox/beowulf.read.html b/docs/codox/beowulf.read.html new file mode 100644 index 0000000..6d6d131 --- /dev/null +++ b/docs/codox/beowulf.read.html @@ -0,0 +1,3 @@ + +beowulf.read documentation

Project

Topics

Namespaces

Public Vars

beowulf.read

TODO: write docs

gen-cond

(gen-cond p)

Generate a cond statement from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) cond statement.

view source

gen-cond-clause

(gen-cond-clause p)

Generate a cond clause from this simplified parse tree fragment p; returns nil if p does not represent a cond clause.

view source

gen-dot-terminated-list

(gen-dot-terminated-list p)

Generate a list, which may be dot-terminated, from this partial parse tree ‘p’. Note that the function acts recursively and progressively decapitates its argument, so that the argument will not always be a valid parse tree.

view source

gen-fn-call

(gen-fn-call p)

Generate a function call from this simplified parse tree fragment p; returns nil if p does not represent a (MEXPR) function call. TODO: I’m not yet certain but it appears that args in mexprs are implicitly quoted; this function does not (yet) do that.

view source

generate

(generate p)

Generate lisp structure from this parse tree p. It is assumed that p has been simplified.

view source

gsp

macro

(gsp s)

Shortcut macro - the internals of read; or, if you like, read-string. Argument s should be a string representation of a valid Lisp expression.

view source

parse

Parse a string presented as argument into a parse tree which can then be operated upon further.

view source

READ

(READ input)

TODO: write docs

view source

simplify

(simplify p)(simplify p context)

Simplify this parse tree p. If p is an instaparse failure object, throw an ex-info, with p as the value of its :failure key.

view source

strip-leading-zeros

(strip-leading-zeros s)(strip-leading-zeros s prefix)

read-string interprets strings with leading zeros as octal; strip any from this string s. If what’s left is empty (i.e. there were only zeros, return "0".

view source
\ No newline at end of file diff --git a/docs/codox/css/default.css b/docs/codox/css/default.css new file mode 100644 index 0000000..33f78fe --- /dev/null +++ b/docs/codox/css/default.css @@ -0,0 +1,551 @@ +body { + font-family: Helvetica, Arial, sans-serif; + font-size: 15px; +} + +pre, code { + font-family: Monaco, DejaVu Sans Mono, Consolas, monospace; + font-size: 9pt; + margin: 15px 0; +} + +h1 { + font-weight: normal; + font-size: 29px; + margin: 10px 0 2px 0; + padding: 0; +} + +h2 { + font-weight: normal; + font-size: 25px; +} + +h5.license { + margin: 9px 0 22px 0; + color: #555; + font-weight: normal; + font-size: 12px; + font-style: italic; +} + +.document h1, .namespace-index h1 { + font-size: 32px; + margin-top: 12px; +} + +#header, #content, .sidebar { + position: fixed; +} + +#header { + top: 0; + left: 0; + right: 0; + height: 22px; + color: #f5f5f5; + padding: 5px 7px; +} + +#content { + top: 32px; + right: 0; + bottom: 0; + overflow: auto; + background: #fff; + color: #333; + padding: 0 18px; +} + +.sidebar { + position: fixed; + top: 32px; + bottom: 0; + overflow: auto; +} + +.sidebar.primary { + background: #e2e2e2; + border-right: solid 1px #cccccc; + left: 0; + width: 250px; +} + +.sidebar.secondary { + background: #f2f2f2; + border-right: solid 1px #d7d7d7; + left: 251px; + width: 200px; +} + +#content.namespace-index, #content.document { + left: 251px; +} + +#content.namespace-docs { + left: 452px; +} + +#content.document { + padding-bottom: 10%; +} + +#header { + background: #3f3f3f; + box-shadow: 0 0 8px rgba(0, 0, 0, 0.4); + z-index: 100; +} + +#header h1 { + margin: 0; + padding: 0; + font-size: 18px; + font-weight: lighter; + text-shadow: -1px -1px 0px #333; +} + +#header h1 .project-version { + font-weight: normal; +} + +.project-version { + padding-left: 0.15em; +} + +#header a, .sidebar a { + display: block; + text-decoration: none; +} + +#header a { + color: #f5f5f5; +} + +.sidebar a { + color: #333; +} + +#header h2 { + float: right; + font-size: 9pt; + font-weight: normal; + margin: 4px 3px; + padding: 0; + color: #bbb; +} + +#header h2 a { + display: inline; +} + +.sidebar h3 { + margin: 0; + padding: 10px 13px 0 13px; + font-size: 19px; + font-weight: lighter; +} + +.sidebar h3 a { + color: #444; +} + +.sidebar h3.no-link { + color: #636363; +} + +.sidebar ul { + padding: 7px 0 6px 0; + margin: 0; +} + +.sidebar ul.index-link { + padding-bottom: 4px; +} + +.sidebar li { + display: block; + vertical-align: middle; +} + +.sidebar li a, .sidebar li .no-link { + border-left: 3px solid transparent; + padding: 0 10px; + white-space: nowrap; +} + +.sidebar li .no-link { + display: block; + color: #777; + font-style: italic; +} + +.sidebar li .inner { + display: inline-block; + padding-top: 7px; + height: 24px; +} + +.sidebar li a, .sidebar li .tree { + height: 31px; +} + +.depth-1 .inner { padding-left: 2px; } +.depth-2 .inner { padding-left: 6px; } +.depth-3 .inner { padding-left: 20px; } +.depth-4 .inner { padding-left: 34px; } +.depth-5 .inner { padding-left: 48px; } +.depth-6 .inner { padding-left: 62px; } + +.sidebar li .tree { + display: block; + float: left; + position: relative; + top: -10px; + margin: 0 4px 0 0; + padding: 0; +} + +.sidebar li.depth-1 .tree { + display: none; +} + +.sidebar li .tree .top, .sidebar li .tree .bottom { + display: block; + margin: 0; + padding: 0; + width: 7px; +} + +.sidebar li .tree .top { + border-left: 1px solid #aaa; + border-bottom: 1px solid #aaa; + height: 19px; +} + +.sidebar li .tree .bottom { + height: 22px; +} + +.sidebar li.branch .tree .bottom { + border-left: 1px solid #aaa; +} + +.sidebar.primary li.current a { + border-left: 3px solid #a33; + color: #a33; +} + +.sidebar.secondary li.current a { + border-left: 3px solid #33a; + color: #33a; +} + +.namespace-index h2 { + margin: 30px 0 0 0; +} + +.namespace-index h3 { + font-size: 16px; + font-weight: bold; + margin-bottom: 0; +} + +.namespace-index .topics { + padding-left: 30px; + margin: 11px 0 0 0; +} + +.namespace-index .topics li { + padding: 5px 0; +} + +.namespace-docs h3 { + font-size: 18px; + font-weight: bold; +} + +.public h3 { + margin: 0; + float: left; +} + +.usage { + clear: both; +} + +.public { + margin: 0; + border-top: 1px solid #e0e0e0; + padding-top: 14px; + padding-bottom: 6px; +} + +.public:last-child { + margin-bottom: 20%; +} + +.members .public:last-child { + margin-bottom: 0; +} + +.members { + margin: 15px 0; +} + +.members h4 { + color: #555; + font-weight: normal; + font-variant: small-caps; + margin: 0 0 5px 0; +} + +.members .inner { + padding-top: 5px; + padding-left: 12px; + margin-top: 2px; + margin-left: 7px; + border-left: 1px solid #bbb; +} + +#content .members .inner h3 { + font-size: 12pt; +} + +.members .public { + border-top: none; + margin-top: 0; + padding-top: 6px; + padding-bottom: 0; +} + +.members .public:first-child { + padding-top: 0; +} + +h4.type, +h4.dynamic, +h4.added, +h4.deprecated { + float: left; + margin: 3px 10px 15px 0; + font-size: 15px; + font-weight: bold; + font-variant: small-caps; +} + +.public h4.type, +.public h4.dynamic, +.public h4.added, +.public h4.deprecated { + font-size: 13px; + font-weight: bold; + margin: 3px 0 0 10px; +} + +.members h4.type, +.members h4.added, +.members h4.deprecated { + margin-top: 1px; +} + +h4.type { + color: #717171; +} + +h4.dynamic { + color: #9933aa; +} + +h4.added { + color: #508820; +} + +h4.deprecated { + color: #880000; +} + +.namespace { + margin-bottom: 30px; +} + +.namespace:last-child { + margin-bottom: 10%; +} + +.index { + padding: 0; + font-size: 80%; + margin: 15px 0; + line-height: 16px; +} + +.index * { + display: inline; +} + +.index p { + padding-right: 3px; +} + +.index li { + padding-right: 5px; +} + +.index ul { + padding-left: 0; +} + +.type-sig { + clear: both; + color: #088; +} + +.type-sig pre { + padding-top: 10px; + margin: 0; +} + +.usage code { + display: block; + color: #008; + margin: 2px 0; +} + +.usage code:first-child { + padding-top: 10px; +} + +p { + margin: 15px 0; +} + +.public p:first-child, .public pre.plaintext { + margin-top: 12px; +} + +.doc { + margin: 0 0 26px 0; + clear: both; +} + +.public .doc { + margin: 0; +} + +.namespace-index .doc { + margin-bottom: 20px; +} + +.namespace-index .namespace .doc { + margin-bottom: 10px; +} + +.markdown p, .markdown li, .markdown dt, .markdown dd, .markdown td { + line-height: 22px; +} + +.markdown li { + padding: 2px 0; +} + +.markdown h2 { + font-weight: normal; + font-size: 25px; + margin: 30px 0 10px 0; +} + +.markdown h3 { + font-weight: normal; + font-size: 20px; + margin: 30px 0 0 0; +} + +.markdown h4 { + font-size: 15px; + margin: 22px 0 -4px 0; +} + +.doc, .public, .namespace .index { + max-width: 680px; + overflow-x: visible; +} + +.markdown pre > code { + display: block; + padding: 10px; +} + +.markdown pre > code, .src-link a { + border: 1px solid #e4e4e4; + border-radius: 2px; +} + +.markdown code:not(.hljs), .src-link a { + background: #f6f6f6; +} + +pre.deps { + display: inline-block; + margin: 0 10px; + border: 1px solid #e4e4e4; + border-radius: 2px; + padding: 10px; + background-color: #f6f6f6; +} + +.markdown hr { + border-style: solid; + border-top: none; + color: #ccc; +} + +.doc ul, .doc ol { + padding-left: 30px; +} + +.doc table { + border-collapse: collapse; + margin: 0 10px; +} + +.doc table td, .doc table th { + border: 1px solid #dddddd; + padding: 4px 6px; +} + +.doc table th { + background: #f2f2f2; +} + +.doc dl { + margin: 0 10px 20px 10px; +} + +.doc dl dt { + font-weight: bold; + margin: 0; + padding: 3px 0; + border-bottom: 1px solid #ddd; +} + +.doc dl dd { + padding: 5px 0; + margin: 0 0 5px 10px; +} + +.doc abbr { + border-bottom: 1px dotted #333; + font-variant: none; + cursor: help; +} + +.src-link { + margin-bottom: 15px; +} + +.src-link a { + font-size: 70%; + padding: 1px 4px; + text-decoration: none; + color: #5555bb; +} diff --git a/docs/codox/css/highlight.css b/docs/codox/css/highlight.css new file mode 100644 index 0000000..d0cdaa3 --- /dev/null +++ b/docs/codox/css/highlight.css @@ -0,0 +1,97 @@ +/* +github.com style (c) Vasily Polovnyov +*/ + +.hljs { + display: block; + overflow-x: auto; + padding: 0.5em; + color: #333; + background: #f8f8f8; +} + +.hljs-comment, +.hljs-quote { + color: #998; + font-style: italic; +} + +.hljs-keyword, +.hljs-selector-tag, +.hljs-subst { + color: #333; + font-weight: bold; +} + +.hljs-number, +.hljs-literal, +.hljs-variable, +.hljs-template-variable, +.hljs-tag .hljs-attr { + color: #008080; +} + +.hljs-string, +.hljs-doctag { + color: #d14; +} + +.hljs-title, +.hljs-section, +.hljs-selector-id { + color: #900; + font-weight: bold; +} + +.hljs-subst { + font-weight: normal; +} + +.hljs-type, +.hljs-class .hljs-title { + color: #458; + font-weight: bold; +} + +.hljs-tag, +.hljs-name, +.hljs-attribute { + color: #000080; + font-weight: normal; +} + +.hljs-regexp, +.hljs-link { + color: #009926; +} + +.hljs-symbol, +.hljs-bullet { + color: #990073; +} + +.hljs-built_in, +.hljs-builtin-name { + color: #0086b3; +} + +.hljs-meta { + color: #999; + font-weight: bold; +} + +.hljs-deletion { + background: #fdd; +} + +.hljs-addition { + background: #dfd; +} + +.hljs-emphasis { + font-style: italic; +} + +.hljs-strong { + font-weight: bold; +} diff --git a/docs/codox/index.html b/docs/codox/index.html new file mode 100644 index 0000000..c25387a --- /dev/null +++ b/docs/codox/index.html @@ -0,0 +1,3 @@ + +Beowulf 0.2.0-SNAPSHOT

Project

Topics

Namespaces

Beowulf 0.2.0-SNAPSHOT

Released under the GPL-2.0-or-later

An implementation of LISP 1.5 in Clojure.

Installation

To install, add the following dependency to your project or build file:

[beowulf "0.2.0-SNAPSHOT"]

Topics

Namespaces

beowulf.bootstrap

TODO: write docs

Public variables and functions:

beowulf.cons-cell

TODO: write docs

Public variables and functions:

beowulf.core

TODO: write docs

Public variables and functions:

beowulf.host

TODO: write docs

Public variables and functions:

    beowulf.read

    TODO: write docs

    Public variables and functions:

    \ No newline at end of file diff --git a/docs/codox/intro.html b/docs/codox/intro.html new file mode 100644 index 0000000..441a126 --- /dev/null +++ b/docs/codox/intro.html @@ -0,0 +1,4 @@ + +Introduction to beowulf

    Project

    Topics

    Namespaces

    Introduction to beowulf

    +

    TODO: write great documentation

    \ No newline at end of file diff --git a/docs/codox/js/highlight.min.js b/docs/codox/js/highlight.min.js new file mode 100644 index 0000000..6486ffd --- /dev/null +++ b/docs/codox/js/highlight.min.js @@ -0,0 +1,2 @@ +/*! highlight.js v9.6.0 | BSD3 License | git.io/hljslicense */ +!function(e){var n="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof exports?e(exports):n&&(n.hljs=e({}),"function"==typeof define&&define.amd&&define([],function(){return n.hljs}))}(function(e){function n(e){return e.replace(/[&<>]/gm,function(e){return I[e]})}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0===t.index}function a(e){return k.test(e)}function i(e){var n,t,r,i,o=e.className+" ";if(o+=e.parentNode?e.parentNode.className:"",t=B.exec(o))return R(t[1])?t[1]:"no-highlight";for(o=o.split(/\s+/),n=0,r=o.length;r>n;n++)if(i=o[n],a(i)||R(i))return i}function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t];return r}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3===i.nodeType?a+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!==r[0].offset?e[0].offset"}function u(e){l+=""}function c(e){("start"===e.event?o:u)(e.node)}for(var s=0,l="",f=[];e.length||r.length;){var g=i();if(l+=n(a.substr(s,g[0].offset-s)),s=g[0].offset,g===e){f.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g===e&&g.length&&g[0].offset===s);f.reverse().forEach(o)}else"start"===g[0].event?f.push(g[0].node):f.pop(),c(g.splice(0,1)[0])}return l+n(a.substr(s))}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var u={},c=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");u[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?c("keyword",a.k):E(a.k).forEach(function(e){c(e,a.k[e])}),a.k=u}a.lR=t(a.l||/\w+/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),null==a.r&&(a.r=1),a.c||(a.c=[]);var s=[];a.c.forEach(function(e){e.v?e.v.forEach(function(n){s.push(o(e,n))}):s.push("self"===e?a:e)}),a.c=s,a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var l=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=l.length?t(l.join("|"),!0):{exec:function(){return null}}}}r(e)}function l(e,t,a,i){function o(e,n){var t,a;for(t=0,a=n.c.length;a>t;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function g(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function h(e,n,t,r){var a=r?"":y.classPrefix,i='',i+n+o}function p(){var e,t,r,a;if(!E.k)return n(B);for(a="",t=0,E.lR.lastIndex=0,r=E.lR.exec(B);r;)a+=n(B.substr(t,r.index-t)),e=g(E,r),e?(M+=e[1],a+=h(e[0],n(r[0]))):a+=n(r[0]),t=E.lR.lastIndex,r=E.lR.exec(B);return a+n(B.substr(t))}function d(){var e="string"==typeof E.sL;if(e&&!x[E.sL])return n(B);var t=e?l(E.sL,B,!0,L[E.sL]):f(B,E.sL.length?E.sL:void 0);return E.r>0&&(M+=t.r),e&&(L[E.sL]=t.top),h(t.language,t.value,!1,!0)}function b(){k+=null!=E.sL?d():p(),B=""}function v(e){k+=e.cN?h(e.cN,"",!0):"",E=Object.create(e,{parent:{value:E}})}function m(e,n){if(B+=e,null==n)return b(),0;var t=o(n,E);if(t)return t.skip?B+=n:(t.eB&&(B+=n),b(),t.rB||t.eB||(B=n)),v(t,n),t.rB?0:n.length;var r=u(E,n);if(r){var a=E;a.skip?B+=n:(a.rE||a.eE||(B+=n),b(),a.eE&&(B=n));do E.cN&&(k+=C),E.skip||(M+=E.r),E=E.parent;while(E!==r.parent);return r.starts&&v(r.starts,""),a.rE?0:n.length}if(c(n,E))throw new Error('Illegal lexeme "'+n+'" for mode "'+(E.cN||"")+'"');return B+=n,n.length||1}var N=R(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var w,E=i||N,L={},k="";for(w=E;w!==N;w=w.parent)w.cN&&(k=h(w.cN,"",!0)+k);var B="",M=0;try{for(var I,j,O=0;;){if(E.t.lastIndex=O,I=E.t.exec(t),!I)break;j=m(t.substr(O,I.index-O),I[0]),O=I.index+j}for(m(t.substr(O)),w=E;w.parent;w=w.parent)w.cN&&(k+=C);return{r:M,value:k,language:e,top:E}}catch(T){if(T.message&&-1!==T.message.indexOf("Illegal"))return{r:0,value:n(t)};throw T}}function f(e,t){t=t||y.languages||E(x);var r={r:0,value:n(e)},a=r;return t.filter(R).forEach(function(n){var t=l(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}),a.language&&(r.second_best=a),r}function g(e){return y.tabReplace||y.useBR?e.replace(M,function(e,n){return y.useBR&&"\n"===e?"
    ":y.tabReplace?n.replace(/\t/g,y.tabReplace):void 0}):e}function h(e,n,t){var r=n?L[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function p(e){var n,t,r,o,s,p=i(e);a(p)||(y.useBR?(n=document.createElementNS("http://www.w3.org/1999/xhtml","div"),n.innerHTML=e.innerHTML.replace(/\n/g,"").replace(//g,"\n")):n=e,s=n.textContent,r=p?l(p,s,!0):f(s),t=u(n),t.length&&(o=document.createElementNS("http://www.w3.org/1999/xhtml","div"),o.innerHTML=r.value,r.value=c(t,u(o),s)),r.value=g(r.value),e.innerHTML=r.value,e.className=h(e.className,p,r.language),e.result={language:r.language,re:r.r},r.second_best&&(e.second_best={language:r.second_best.language,re:r.second_best.r}))}function d(e){y=o(y,e)}function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("pre code");w.forEach.call(e,p)}}function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener("load",b,!1)}function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e){L[e]=n})}function N(){return E(x)}function R(e){return e=(e||"").toLowerCase(),x[e]||x[L[e]]}var w=[],E=Object.keys,x={},L={},k=/^(no-?highlight|plain|text)$/i,B=/\blang(?:uage)?-([\w-]+)\b/i,M=/((^(<[^>]+>|\t|)+|(?:\n)))/gm,C="    ",y={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0},I={"&":"&","<":"<",">":">"};return e.highlight=l,e.highlightAuto=f,e.fixMarkup=g,e.highlightBlock=p,e.configure=d,e.initHighlighting=b,e.initHighlightingOnLoad=v,e.registerLanguage=m,e.listLanguages=N,e.getLanguage=R,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|like)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",b:"(?:TODO|FIXME|NOTE|BUG|XXX):",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e.METHOD_GUARD={b:"\\.\\s*"+e.UIR,r:0},e});hljs.registerLanguage("clojure",function(e){var t={"builtin-name":"def defonce cond apply if-not if-let if not not= = < > <= >= == + / * - rem quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last drop-while while intern condp case reduced cycle split-at split-with repeat replicate iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter monitor-exit defmacro defn defn- macroexpand macroexpand-1 for dosync and or when when-not when-let comp juxt partial sequence memoize constantly complement identity assert peek pop doto proxy defstruct first rest cons defprotocol cast coll deftype defrecord last butlast sigs reify second ffirst fnext nfirst nnext defmulti defmethod meta with-meta ns in-ns create-ns import refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize"},r="a-zA-Z_\\-!.?+*=<>&#'",n="["+r+"]["+r+"0-9/;:]*",a="[-+]?\\d+(\\.\\d+)?",o={b:n,r:0},s={cN:"number",b:a,r:0},i=e.inherit(e.QSM,{i:null}),c=e.C(";","$",{r:0}),d={cN:"literal",b:/\b(true|false|nil)\b/},l={b:"[\\[\\{]",e:"[\\]\\}]"},m={cN:"comment",b:"\\^"+n},p=e.C("\\^\\{","\\}"),u={cN:"symbol",b:"[:]{1,2}"+n},f={b:"\\(",e:"\\)"},h={eW:!0,r:0},y={k:t,l:n,cN:"name",b:n,starts:h},b=[f,i,m,p,c,u,l,s,d,o];return f.c=[e.C("comment",""),y,h],h.c=b,l.c=b,{aliases:["clj"],i:/\S/,c:[f,i,m,p,c,u,l,s,d]}});hljs.registerLanguage("clojure-repl",function(e){return{c:[{cN:"meta",b:/^([\w.-]+|\s*#_)=>/,starts:{e:/$/,sL:"clojure"}}]}}); \ No newline at end of file diff --git a/docs/codox/js/jquery.min.js b/docs/codox/js/jquery.min.js new file mode 100644 index 0000000..73f33fb --- /dev/null +++ b/docs/codox/js/jquery.min.js @@ -0,0 +1,4 @@ +/*! jQuery v1.11.0 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */ +!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k="".trim,l={},m="1.11.0",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return n.each(this,a,b)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(n.isPlainObject(c)||(b=n.isArray(c)))?(b?(b=!1,f=a&&n.isArray(a)?a:[]):f=a&&n.isPlainObject(a)?a:{},g[d]=n.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray||function(a){return"array"===n.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){return a-parseFloat(a)>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==n.type(a)||a.nodeType||n.isWindow(a))return!1;try{if(a.constructor&&!j.call(a,"constructor")&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(l.ownLast)for(b in a)return j.call(a,b);for(b in a);return void 0===b||j.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(b){b&&n.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:k&&!k.call("\ufeff\xa0")?function(a){return null==a?"":k.call(a)}:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(g)return g.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(f=a[b],b=a,a=f),n.isFunction(a)?(c=d.call(arguments,2),e=function(){return a.apply(b||this,c.concat(d.call(arguments)))},e.guid=a.guid=a.guid||n.guid++,e):void 0},now:function(){return+new Date},support:l}),n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b=a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s="sizzle"+-new Date,t=a.document,u=0,v=0,w=eb(),x=eb(),y=eb(),z=function(a,b){return a===b&&(j=!0),0},A="undefined",B=1<<31,C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=D.indexOf||function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]===a)return b;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",M=L.replace("w","w#"),N="\\["+K+"*("+L+")"+K+"*(?:([*^$|!~]?=)"+K+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+M+")|)|)"+K+"*\\]",O=":("+L+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+N.replace(3,8)+")*)|.*)\\)|)",P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(O),U=new RegExp("^"+M+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L.replace("w","w*")+")"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+O),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=/'|\\/g,ab=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),bb=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)};try{G.apply(D=H.call(t.childNodes),t.childNodes),D[t.childNodes.length].nodeType}catch(cb){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function db(a,b,d,e){var f,g,h,i,j,m,p,q,u,v;if((b?b.ownerDocument||b:t)!==l&&k(b),b=b||l,d=d||[],!a||"string"!=typeof a)return d;if(1!==(i=b.nodeType)&&9!==i)return[];if(n&&!e){if(f=Z.exec(a))if(h=f[1]){if(9===i){if(g=b.getElementById(h),!g||!g.parentNode)return d;if(g.id===h)return d.push(g),d}else if(b.ownerDocument&&(g=b.ownerDocument.getElementById(h))&&r(b,g)&&g.id===h)return d.push(g),d}else{if(f[2])return G.apply(d,b.getElementsByTagName(a)),d;if((h=f[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(h)),d}if(c.qsa&&(!o||!o.test(a))){if(q=p=s,u=b,v=9===i&&a,1===i&&"object"!==b.nodeName.toLowerCase()){m=ob(a),(p=b.getAttribute("id"))?q=p.replace(_,"\\$&"):b.setAttribute("id",q),q="[id='"+q+"'] ",j=m.length;while(j--)m[j]=q+pb(m[j]);u=$.test(a)&&mb(b.parentNode)||b,v=m.join(",")}if(v)try{return G.apply(d,u.querySelectorAll(v)),d}catch(w){}finally{p||b.removeAttribute("id")}}}return xb(a.replace(P,"$1"),b,d,e)}function eb(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function fb(a){return a[s]=!0,a}function gb(a){var b=l.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function hb(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function ib(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||B)-(~a.sourceIndex||B);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function jb(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function kb(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function lb(a){return fb(function(b){return b=+b,fb(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function mb(a){return a&&typeof a.getElementsByTagName!==A&&a}c=db.support={},f=db.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},k=db.setDocument=function(a){var b,e=a?a.ownerDocument||a:t,g=e.defaultView;return e!==l&&9===e.nodeType&&e.documentElement?(l=e,m=e.documentElement,n=!f(e),g&&g!==g.top&&(g.addEventListener?g.addEventListener("unload",function(){k()},!1):g.attachEvent&&g.attachEvent("onunload",function(){k()})),c.attributes=gb(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=gb(function(a){return a.appendChild(e.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(e.getElementsByClassName)&&gb(function(a){return a.innerHTML="
    ",a.firstChild.className="i",2===a.getElementsByClassName("i").length}),c.getById=gb(function(a){return m.appendChild(a).id=s,!e.getElementsByName||!e.getElementsByName(s).length}),c.getById?(d.find.ID=function(a,b){if(typeof b.getElementById!==A&&n){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){var c=typeof a.getAttributeNode!==A&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return typeof b.getElementsByTagName!==A?b.getElementsByTagName(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return typeof b.getElementsByClassName!==A&&n?b.getElementsByClassName(a):void 0},p=[],o=[],(c.qsa=Y.test(e.querySelectorAll))&&(gb(function(a){a.innerHTML="",a.querySelectorAll("[t^='']").length&&o.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||o.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll(":checked").length||o.push(":checked")}),gb(function(a){var b=e.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&o.push("name"+K+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||o.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),o.push(",.*:")})),(c.matchesSelector=Y.test(q=m.webkitMatchesSelector||m.mozMatchesSelector||m.oMatchesSelector||m.msMatchesSelector))&&gb(function(a){c.disconnectedMatch=q.call(a,"div"),q.call(a,"[s!='']:x"),p.push("!=",O)}),o=o.length&&new RegExp(o.join("|")),p=p.length&&new RegExp(p.join("|")),b=Y.test(m.compareDocumentPosition),r=b||Y.test(m.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},z=b?function(a,b){if(a===b)return j=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===e||a.ownerDocument===t&&r(t,a)?-1:b===e||b.ownerDocument===t&&r(t,b)?1:i?I.call(i,a)-I.call(i,b):0:4&d?-1:1)}:function(a,b){if(a===b)return j=!0,0;var c,d=0,f=a.parentNode,g=b.parentNode,h=[a],k=[b];if(!f||!g)return a===e?-1:b===e?1:f?-1:g?1:i?I.call(i,a)-I.call(i,b):0;if(f===g)return ib(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)k.unshift(c);while(h[d]===k[d])d++;return d?ib(h[d],k[d]):h[d]===t?-1:k[d]===t?1:0},e):l},db.matches=function(a,b){return db(a,null,null,b)},db.matchesSelector=function(a,b){if((a.ownerDocument||a)!==l&&k(a),b=b.replace(S,"='$1']"),!(!c.matchesSelector||!n||p&&p.test(b)||o&&o.test(b)))try{var d=q.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return db(b,l,null,[a]).length>0},db.contains=function(a,b){return(a.ownerDocument||a)!==l&&k(a),r(a,b)},db.attr=function(a,b){(a.ownerDocument||a)!==l&&k(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!n):void 0;return void 0!==f?f:c.attributes||!n?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},db.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},db.uniqueSort=function(a){var b,d=[],e=0,f=0;if(j=!c.detectDuplicates,i=!c.sortStable&&a.slice(0),a.sort(z),j){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return i=null,a},e=db.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=db.selectors={cacheLength:50,createPseudo:fb,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ab,bb),a[3]=(a[4]||a[5]||"").replace(ab,bb),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||db.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&db.error(a[0]),a},PSEUDO:function(a){var b,c=!a[5]&&a[2];return V.CHILD.test(a[0])?null:(a[3]&&void 0!==a[4]?a[2]=a[4]:c&&T.test(c)&&(b=ob(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ab,bb).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=w[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&w(a,function(a){return b.test("string"==typeof a.className&&a.className||typeof a.getAttribute!==A&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=db.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),t=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&t){k=q[s]||(q[s]={}),j=k[a]||[],n=j[0]===u&&j[1],m=j[0]===u&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[u,n,m];break}}else if(t&&(j=(b[s]||(b[s]={}))[a])&&j[0]===u)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(t&&((l[s]||(l[s]={}))[a]=[u,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||db.error("unsupported pseudo: "+a);return e[s]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?fb(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I.call(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:fb(function(a){var b=[],c=[],d=g(a.replace(P,"$1"));return d[s]?fb(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:fb(function(a){return function(b){return db(a,b).length>0}}),contains:fb(function(a){return function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:fb(function(a){return U.test(a||"")||db.error("unsupported lang: "+a),a=a.replace(ab,bb).toLowerCase(),function(b){var c;do if(c=n?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===m},focus:function(a){return a===l.activeElement&&(!l.hasFocus||l.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:lb(function(){return[0]}),last:lb(function(a,b){return[b-1]}),eq:lb(function(a,b,c){return[0>c?c+b:c]}),even:lb(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:lb(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:lb(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:lb(function(a,b,c){for(var d=0>c?c+b:c;++db;b++)d+=a[b].value;return d}function qb(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=v++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[u,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[s]||(b[s]={}),(h=i[d])&&h[0]===u&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function rb(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function sb(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function tb(a,b,c,d,e,f){return d&&!d[s]&&(d=tb(d)),e&&!e[s]&&(e=tb(e,f)),fb(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||wb(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:sb(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=sb(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I.call(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=sb(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ub(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],i=g||d.relative[" "],j=g?1:0,k=qb(function(a){return a===b},i,!0),l=qb(function(a){return I.call(b,a)>-1},i,!0),m=[function(a,c,d){return!g&&(d||c!==h)||((b=c).nodeType?k(a,c,d):l(a,c,d))}];f>j;j++)if(c=d.relative[a[j].type])m=[qb(rb(m),c)];else{if(c=d.filter[a[j].type].apply(null,a[j].matches),c[s]){for(e=++j;f>e;e++)if(d.relative[a[e].type])break;return tb(j>1&&rb(m),j>1&&pb(a.slice(0,j-1).concat({value:" "===a[j-2].type?"*":""})).replace(P,"$1"),c,e>j&&ub(a.slice(j,e)),f>e&&ub(a=a.slice(e)),f>e&&pb(a))}m.push(c)}return rb(m)}function vb(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,i,j,k){var m,n,o,p=0,q="0",r=f&&[],s=[],t=h,v=f||e&&d.find.TAG("*",k),w=u+=null==t?1:Math.random()||.1,x=v.length;for(k&&(h=g!==l&&g);q!==x&&null!=(m=v[q]);q++){if(e&&m){n=0;while(o=a[n++])if(o(m,g,i)){j.push(m);break}k&&(u=w)}c&&((m=!o&&m)&&p--,f&&r.push(m))}if(p+=q,c&&q!==p){n=0;while(o=b[n++])o(r,s,g,i);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=E.call(j));s=sb(s)}G.apply(j,s),k&&!f&&s.length>0&&p+b.length>1&&db.uniqueSort(j)}return k&&(u=w,h=t),r};return c?fb(f):f}g=db.compile=function(a,b){var c,d=[],e=[],f=y[a+" "];if(!f){b||(b=ob(a)),c=b.length;while(c--)f=ub(b[c]),f[s]?d.push(f):e.push(f);f=y(a,vb(e,d))}return f};function wb(a,b,c){for(var d=0,e=b.length;e>d;d++)db(a,b[d],c);return c}function xb(a,b,e,f){var h,i,j,k,l,m=ob(a);if(!f&&1===m.length){if(i=m[0]=m[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&c.getById&&9===b.nodeType&&n&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(ab,bb),b)||[])[0],!b)return e;a=a.slice(i.shift().value.length)}h=V.needsContext.test(a)?0:i.length;while(h--){if(j=i[h],d.relative[k=j.type])break;if((l=d.find[k])&&(f=l(j.matches[0].replace(ab,bb),$.test(i[0].type)&&mb(b.parentNode)||b))){if(i.splice(h,1),a=f.length&&pb(i),!a)return G.apply(e,f),e;break}}}return g(a,m)(f,b,!n,e,$.test(a)&&mb(b.parentNode)||b),e}return c.sortStable=s.split("").sort(z).join("")===s,c.detectDuplicates=!!j,k(),c.sortDetached=gb(function(a){return 1&a.compareDocumentPosition(l.createElement("div"))}),gb(function(a){return a.innerHTML="","#"===a.firstChild.getAttribute("href")})||hb("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&gb(function(a){return a.innerHTML="",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||hb("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),gb(function(a){return null==a.getAttribute("disabled")})||hb(J,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),db}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=n.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return n.inArray(a,b)>=0!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=[],d=this,e=d.length;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;e>b;b++)if(n.contains(d[b],this))return!0}));for(b=0;e>b;b++)n.find(a,d[b],c);return c=this.pushStack(e>1?n.unique(c):c),c.selector=this.selector?this.selector+" "+a:a,c},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?n(a):a||[],!1).length}});var y,z=a.document,A=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,B=n.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a.charAt(0)&&">"===a.charAt(a.length-1)&&a.length>=3?[null,a,null]:A.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:z,!0)),v.test(c[1])&&n.isPlainObject(b))for(c in b)n.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}if(d=z.getElementById(c[2]),d&&d.parentNode){if(d.id!==c[2])return y.find(a);this.length=1,this[0]=d}return this.context=z,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};B.prototype=n.fn,y=n(z);var C=/^(?:parents|prev(?:Until|All))/,D={children:!0,contents:!0,next:!0,prev:!0};n.extend({dir:function(a,b,c){var d=[],e=a[b];while(e&&9!==e.nodeType&&(void 0===c||1!==e.nodeType||!n(e).is(c)))1===e.nodeType&&d.push(e),e=e[b];return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),n.fn.extend({has:function(a){var b,c=n(a,this),d=c.length;return this.filter(function(){for(b=0;d>b;b++)if(n.contains(this,c[b]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.unique(f):f)},index:function(a){return a?"string"==typeof a?n.inArray(this[0],n(a)):n.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.unique(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function E(a,b){do a=a[b];while(a&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return n.dir(a,"parentNode")},parentsUntil:function(a,b,c){return n.dir(a,"parentNode",c)},next:function(a){return E(a,"nextSibling")},prev:function(a){return E(a,"previousSibling")},nextAll:function(a){return n.dir(a,"nextSibling")},prevAll:function(a){return n.dir(a,"previousSibling")},nextUntil:function(a,b,c){return n.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return n.dir(a,"previousSibling",c)},siblings:function(a){return n.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return n.sibling(a.firstChild)},contents:function(a){return n.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(D[a]||(e=n.unique(e)),C.test(a)&&(e=e.reverse())),this.pushStack(e)}});var F=/\S+/g,G={};function H(a){var b=G[a]={};return n.each(a.match(F)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?G[a]||H(a):n.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(c=a.memory&&l,d=!0,f=g||0,g=0,e=h.length,b=!0;h&&e>f;f++)if(h[f].apply(l[0],l[1])===!1&&a.stopOnFalse){c=!1;break}b=!1,h&&(i?i.length&&j(i.shift()):c?h=[]:k.disable())},k={add:function(){if(h){var d=h.length;!function f(b){n.each(b,function(b,c){var d=n.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&f(c)})}(arguments),b?e=h.length:c&&(g=d,j(c))}return this},remove:function(){return h&&n.each(arguments,function(a,c){var d;while((d=n.inArray(c,h,d))>-1)h.splice(d,1),b&&(e>=d&&e--,f>=d&&f--)}),this},has:function(a){return a?n.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],e=0,this},disable:function(){return h=i=c=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,c||k.disable(),this},locked:function(){return!i},fireWith:function(a,c){return!h||d&&!i||(c=c||[],c=[a,c.slice?c.slice():c],b?i.push(c):j(c)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!d}};return k},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&n.isFunction(a.promise)?e:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var I;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){if(a===!0?!--n.readyWait:!n.isReady){if(!z.body)return setTimeout(n.ready);n.isReady=!0,a!==!0&&--n.readyWait>0||(I.resolveWith(z,[n]),n.fn.trigger&&n(z).trigger("ready").off("ready"))}}});function J(){z.addEventListener?(z.removeEventListener("DOMContentLoaded",K,!1),a.removeEventListener("load",K,!1)):(z.detachEvent("onreadystatechange",K),a.detachEvent("onload",K))}function K(){(z.addEventListener||"load"===event.type||"complete"===z.readyState)&&(J(),n.ready())}n.ready.promise=function(b){if(!I)if(I=n.Deferred(),"complete"===z.readyState)setTimeout(n.ready);else if(z.addEventListener)z.addEventListener("DOMContentLoaded",K,!1),a.addEventListener("load",K,!1);else{z.attachEvent("onreadystatechange",K),a.attachEvent("onload",K);var c=!1;try{c=null==a.frameElement&&z.documentElement}catch(d){}c&&c.doScroll&&!function e(){if(!n.isReady){try{c.doScroll("left")}catch(a){return setTimeout(e,50)}J(),n.ready()}}()}return I.promise(b)};var L="undefined",M;for(M in n(l))break;l.ownLast="0"!==M,l.inlineBlockNeedsLayout=!1,n(function(){var a,b,c=z.getElementsByTagName("body")[0];c&&(a=z.createElement("div"),a.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",b=z.createElement("div"),c.appendChild(a).appendChild(b),typeof b.style.zoom!==L&&(b.style.cssText="border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1",(l.inlineBlockNeedsLayout=3===b.offsetWidth)&&(c.style.zoom=1)),c.removeChild(a),a=b=null)}),function(){var a=z.createElement("div");if(null==l.deleteExpando){l.deleteExpando=!0;try{delete a.test}catch(b){l.deleteExpando=!1}}a=null}(),n.acceptData=function(a){var b=n.noData[(a.nodeName+" ").toLowerCase()],c=+a.nodeType||1;return 1!==c&&9!==c?!1:!b||b!==!0&&a.getAttribute("classid")===b};var N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){if(void 0===c&&1===a.nodeType){var d="data-"+b.replace(O,"-$1").toLowerCase();if(c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}n.data(a,b,c)}else c=void 0}return c}function Q(a){var b;for(b in a)if(("data"!==b||!n.isEmptyObject(a[b]))&&"toJSON"!==b)return!1;return!0}function R(a,b,d,e){if(n.acceptData(a)){var f,g,h=n.expando,i=a.nodeType,j=i?n.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||n.guid++:h),j[k]||(j[k]=i?{}:{toJSON:n.noop}),("object"==typeof b||"function"==typeof b)&&(e?j[k]=n.extend(j[k],b):j[k].data=n.extend(j[k].data,b)),g=j[k],e||(g.data||(g.data={}),g=g.data),void 0!==d&&(g[n.camelCase(b)]=d),"string"==typeof b?(f=g[b],null==f&&(f=g[n.camelCase(b)])):f=g,f +}}function S(a,b,c){if(n.acceptData(a)){var d,e,f=a.nodeType,g=f?n.cache:a,h=f?a[n.expando]:n.expando;if(g[h]){if(b&&(d=c?g[h]:g[h].data)){n.isArray(b)?b=b.concat(n.map(b,n.camelCase)):b in d?b=[b]:(b=n.camelCase(b),b=b in d?[b]:b.split(" ")),e=b.length;while(e--)delete d[b[e]];if(c?!Q(d):!n.isEmptyObject(d))return}(c||(delete g[h].data,Q(g[h])))&&(f?n.cleanData([a],!0):l.deleteExpando||g!=g.window?delete g[h]:g[h]=null)}}}n.extend({cache:{},noData:{"applet ":!0,"embed ":!0,"object ":"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"},hasData:function(a){return a=a.nodeType?n.cache[a[n.expando]]:a[n.expando],!!a&&!Q(a)},data:function(a,b,c){return R(a,b,c)},removeData:function(a,b){return S(a,b)},_data:function(a,b,c){return R(a,b,c,!0)},_removeData:function(a,b){return S(a,b,!0)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=n.data(f),1===f.nodeType&&!n._data(f,"parsedAttrs"))){c=g.length;while(c--)d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d]));n._data(f,"parsedAttrs",!0)}return e}return"object"==typeof a?this.each(function(){n.data(this,a)}):arguments.length>1?this.each(function(){n.data(this,a,b)}):f?P(f,a,n.data(f,a)):void 0},removeData:function(a){return this.each(function(){n.removeData(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=n._data(a,b),c&&(!d||n.isArray(c)?d=n._data(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return n._data(a,c)||n._data(a,c,{empty:n.Callbacks("once memory").add(function(){n._removeData(a,b+"queue"),n._removeData(a,c)})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.lengthh;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},X=/^(?:checkbox|radio)$/i;!function(){var a=z.createDocumentFragment(),b=z.createElement("div"),c=z.createElement("input");if(b.setAttribute("className","t"),b.innerHTML="
    a",l.leadingWhitespace=3===b.firstChild.nodeType,l.tbody=!b.getElementsByTagName("tbody").length,l.htmlSerialize=!!b.getElementsByTagName("link").length,l.html5Clone="<:nav>"!==z.createElement("nav").cloneNode(!0).outerHTML,c.type="checkbox",c.checked=!0,a.appendChild(c),l.appendChecked=c.checked,b.innerHTML="",l.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue,a.appendChild(b),b.innerHTML="",l.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,l.noCloneEvent=!0,b.attachEvent&&(b.attachEvent("onclick",function(){l.noCloneEvent=!1}),b.cloneNode(!0).click()),null==l.deleteExpando){l.deleteExpando=!0;try{delete b.test}catch(d){l.deleteExpando=!1}}a=b=c=null}(),function(){var b,c,d=z.createElement("div");for(b in{submit:!0,change:!0,focusin:!0})c="on"+b,(l[b+"Bubbles"]=c in a)||(d.setAttribute(c,"t"),l[b+"Bubbles"]=d.attributes[c].expando===!1);d=null}();var Y=/^(?:input|select|textarea)$/i,Z=/^key/,$=/^(?:mouse|contextmenu)|click/,_=/^(?:focusinfocus|focusoutblur)$/,ab=/^([^.]*)(?:\.(.+)|)$/;function bb(){return!0}function cb(){return!1}function db(){try{return z.activeElement}catch(a){}}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n._data(a);if(r){c.handler&&(i=c,c=i.handler,e=i.selector),c.guid||(c.guid=n.guid++),(g=r.events)||(g=r.events={}),(k=r.handle)||(k=r.handle=function(a){return typeof n===L||a&&n.event.triggered===a.type?void 0:n.event.dispatch.apply(k.elem,arguments)},k.elem=a),b=(b||"").match(F)||[""],h=b.length;while(h--)f=ab.exec(b[h])||[],o=q=f[1],p=(f[2]||"").split(".").sort(),o&&(j=n.event.special[o]||{},o=(e?j.delegateType:j.bindType)||o,j=n.event.special[o]||{},l=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},i),(m=g[o])||(m=g[o]=[],m.delegateCount=0,j.setup&&j.setup.call(a,d,p,k)!==!1||(a.addEventListener?a.addEventListener(o,k,!1):a.attachEvent&&a.attachEvent("on"+o,k))),j.add&&(j.add.call(a,l),l.handler.guid||(l.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,l):m.push(l),n.event.global[o]=!0);a=null}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n.hasData(a)&&n._data(a);if(r&&(k=r.events)){b=(b||"").match(F)||[""],j=b.length;while(j--)if(h=ab.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=k[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),i=f=m.length;while(f--)g=m[f],!e&&q!==g.origType||c&&c.guid!==g.guid||h&&!h.test(g.namespace)||d&&d!==g.selector&&("**"!==d||!g.selector)||(m.splice(f,1),g.selector&&m.delegateCount--,l.remove&&l.remove.call(a,g));i&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete k[o])}else for(o in k)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(k)&&(delete r.handle,n._removeData(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,l,m,o=[d||z],p=j.call(b,"type")?b.type:b,q=j.call(b,"namespace")?b.namespace.split("."):[];if(h=l=d=d||z,3!==d.nodeType&&8!==d.nodeType&&!_.test(p+n.event.triggered)&&(p.indexOf(".")>=0&&(q=p.split("."),p=q.shift(),q.sort()),g=p.indexOf(":")<0&&"on"+p,b=b[n.expando]?b:new n.Event(p,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=q.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:n.makeArray(c,[b]),k=n.event.special[p]||{},e||!k.trigger||k.trigger.apply(d,c)!==!1)){if(!e&&!k.noBubble&&!n.isWindow(d)){for(i=k.delegateType||p,_.test(i+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),l=h;l===(d.ownerDocument||z)&&o.push(l.defaultView||l.parentWindow||a)}m=0;while((h=o[m++])&&!b.isPropagationStopped())b.type=m>1?i:k.bindType||p,f=(n._data(h,"events")||{})[b.type]&&n._data(h,"handle"),f&&f.apply(h,c),f=g&&h[g],f&&f.apply&&n.acceptData(h)&&(b.result=f.apply(h,c),b.result===!1&&b.preventDefault());if(b.type=p,!e&&!b.isDefaultPrevented()&&(!k._default||k._default.apply(o.pop(),c)===!1)&&n.acceptData(d)&&g&&d[p]&&!n.isWindow(d)){l=d[g],l&&(d[g]=null),n.event.triggered=p;try{d[p]()}catch(r){}n.event.triggered=void 0,l&&(d[g]=l)}return b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(n._data(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,g=0;while((e=f.handlers[g++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(e.namespace))&&(a.handleObj=e,a.data=e.data,c=((n.event.special[e.origType]||{}).handle||e.handler).apply(f.elem,i),void 0!==c&&(a.result=c)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!=this;i=i.parentNode||this)if(1===i.nodeType&&(i.disabled!==!0||"click"!==a.type)){for(e=[],f=0;h>f;f++)d=b[f],c=d.selector+" ",void 0===e[c]&&(e[c]=d.needsContext?n(c,this).index(i)>=0:n.find(c,this,null,[i]).length),e[c]&&e.push(d);e.length&&g.push({elem:i,handlers:e})}return h]","i"),ib=/^\s+/,jb=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,kb=/<([\w:]+)/,lb=/\s*$/g,sb={option:[1,""],legend:[1,"
    ","
    "],area:[1,"",""],param:[1,"",""],thead:[1,"","
    "],tr:[2,"","
    "],col:[2,"","
    "],td:[3,"","
    "],_default:l.htmlSerialize?[0,"",""]:[1,"X
    ","
    "]},tb=eb(z),ub=tb.appendChild(z.createElement("div"));sb.optgroup=sb.option,sb.tbody=sb.tfoot=sb.colgroup=sb.caption=sb.thead,sb.th=sb.td;function vb(a,b){var c,d,e=0,f=typeof a.getElementsByTagName!==L?a.getElementsByTagName(b||"*"):typeof a.querySelectorAll!==L?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||n.nodeName(d,b)?f.push(d):n.merge(f,vb(d,b));return void 0===b||b&&n.nodeName(a,b)?n.merge([a],f):f}function wb(a){X.test(a.type)&&(a.defaultChecked=a.checked)}function xb(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function yb(a){return a.type=(null!==n.find.attr(a,"type"))+"/"+a.type,a}function zb(a){var b=qb.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ab(a,b){for(var c,d=0;null!=(c=a[d]);d++)n._data(c,"globalEval",!b||n._data(b[d],"globalEval"))}function Bb(a,b){if(1===b.nodeType&&n.hasData(a)){var c,d,e,f=n._data(a),g=n._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)n.event.add(b,c,h[c][d])}g.data&&(g.data=n.extend({},g.data))}}function Cb(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!l.noCloneEvent&&b[n.expando]){e=n._data(b);for(d in e.events)n.removeEvent(b,d,e.handle);b.removeAttribute(n.expando)}"script"===c&&b.text!==a.text?(yb(b).text=a.text,zb(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),l.html5Clone&&a.innerHTML&&!n.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&X.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}}n.extend({clone:function(a,b,c){var d,e,f,g,h,i=n.contains(a.ownerDocument,a);if(l.html5Clone||n.isXMLDoc(a)||!hb.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(ub.innerHTML=a.outerHTML,ub.removeChild(f=ub.firstChild)),!(l.noCloneEvent&&l.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(d=vb(f),h=vb(a),g=0;null!=(e=h[g]);++g)d[g]&&Cb(e,d[g]);if(b)if(c)for(h=h||vb(a),d=d||vb(f),g=0;null!=(e=h[g]);g++)Bb(e,d[g]);else Bb(a,f);return d=vb(f,"script"),d.length>0&&Ab(d,!i&&vb(a,"script")),d=h=e=null,f},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k,m=a.length,o=eb(b),p=[],q=0;m>q;q++)if(f=a[q],f||0===f)if("object"===n.type(f))n.merge(p,f.nodeType?[f]:f);else if(mb.test(f)){h=h||o.appendChild(b.createElement("div")),i=(kb.exec(f)||["",""])[1].toLowerCase(),k=sb[i]||sb._default,h.innerHTML=k[1]+f.replace(jb,"<$1>")+k[2],e=k[0];while(e--)h=h.lastChild;if(!l.leadingWhitespace&&ib.test(f)&&p.push(b.createTextNode(ib.exec(f)[0])),!l.tbody){f="table"!==i||lb.test(f)?""!==k[1]||lb.test(f)?0:h:h.firstChild,e=f&&f.childNodes.length;while(e--)n.nodeName(j=f.childNodes[e],"tbody")&&!j.childNodes.length&&f.removeChild(j)}n.merge(p,h.childNodes),h.textContent="";while(h.firstChild)h.removeChild(h.firstChild);h=o.lastChild}else p.push(b.createTextNode(f));h&&o.removeChild(h),l.appendChecked||n.grep(vb(p,"input"),wb),q=0;while(f=p[q++])if((!d||-1===n.inArray(f,d))&&(g=n.contains(f.ownerDocument,f),h=vb(o.appendChild(f),"script"),g&&Ab(h),c)){e=0;while(f=h[e++])pb.test(f.type||"")&&c.push(f)}return h=null,o},cleanData:function(a,b){for(var d,e,f,g,h=0,i=n.expando,j=n.cache,k=l.deleteExpando,m=n.event.special;null!=(d=a[h]);h++)if((b||n.acceptData(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)m[e]?n.event.remove(d,e):n.removeEvent(d,e,g.handle);j[f]&&(delete j[f],k?delete d[i]:typeof d.removeAttribute!==L?d.removeAttribute(i):d[i]=null,c.push(f))}}}),n.fn.extend({text:function(a){return W(this,function(a){return void 0===a?n.text(this):this.empty().append((this[0]&&this[0].ownerDocument||z).createTextNode(a))},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?n.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||n.cleanData(vb(c)),c.parentNode&&(b&&n.contains(c.ownerDocument,c)&&Ab(vb(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&n.cleanData(vb(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&n.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return W(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(gb,""):void 0;if(!("string"!=typeof a||nb.test(a)||!l.htmlSerialize&&hb.test(a)||!l.leadingWhitespace&&ib.test(a)||sb[(kb.exec(a)||["",""])[1].toLowerCase()])){a=a.replace(jb,"<$1>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(vb(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,n.cleanData(vb(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,k=this.length,m=this,o=k-1,p=a[0],q=n.isFunction(p);if(q||k>1&&"string"==typeof p&&!l.checkClone&&ob.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(k&&(i=n.buildFragment(a,this[0].ownerDocument,!1,this),c=i.firstChild,1===i.childNodes.length&&(i=c),c)){for(g=n.map(vb(i,"script"),yb),f=g.length;k>j;j++)d=i,j!==o&&(d=n.clone(d,!0,!0),f&&n.merge(g,vb(d,"script"))),b.call(this[j],d,j);if(f)for(h=g[g.length-1].ownerDocument,n.map(g,zb),j=0;f>j;j++)d=g[j],pb.test(d.type||"")&&!n._data(d,"globalEval")&&n.contains(h,d)&&(d.src?n._evalUrl&&n._evalUrl(d.src):n.globalEval((d.text||d.textContent||d.innerHTML||"").replace(rb,"")));i=c=null}return this}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=0,e=[],g=n(a),h=g.length-1;h>=d;d++)c=d===h?this:this.clone(!0),n(g[d])[b](c),f.apply(e,c.get());return this.pushStack(e)}});var Db,Eb={};function Fb(b,c){var d=n(c.createElement(b)).appendTo(c.body),e=a.getDefaultComputedStyle?a.getDefaultComputedStyle(d[0]).display:n.css(d[0],"display");return d.detach(),e}function Gb(a){var b=z,c=Eb[a];return c||(c=Fb(a,b),"none"!==c&&c||(Db=(Db||n("