[(setf class-name)]	generic function	{822}
[(setf class-name)]	primary method	{822}
[(setf documentation)]	generic function	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[(setf documentation)]	primary method	{842}
[*]	function	{296}
[*]	variable	{495}
[**]	variable	{495}
[***]	variable	{495}
[*applyhook*]	variable	{491}
[*break-on-signals*]	variable	{888}
[*break-on-warnings*]	variable	{669}
[*compile-file-pathname*]	variable	{680}
[*compile-file-truename*]	variable	{680}
[*compile-print*]	variable	{680}
[*compile-verbose*]	variable	{680}
[*debug-io*]	variable	{498}
[*debugger-hook*]	variable	{915}
[*default-pathname-defaults*]	variable	{642}
[*error-output*]	variable	{498}
[*evalhook*]	variable	{491}
[*features*]	variable	{707}
[*gensym-counter*]	variable	{246}
[*load-pathname*]	variable	{658}
[*load-print*]	variable	{658}
[*load-truename*]	variable	{659}
[*load-verbose*]	variable	{658}
[*macroexpand-hook*]	variable	{204}
[*modules*]	variable	{277}
[*package*]	variable	{262}
[*print-array*]	variable	{565}
[*print-base*]	variable	{559}
[*print-case*]	variable	{560}
[*print-circle*]	variable	{559}
[*print-escape*]	variable	{558}
[*print-gensym*]	variable	{564}
[*print-length*]	variable	{564}
[*print-level*]	variable	{564}
[*print-lines*]	variable	{750}
[*print-miser-width*]	variable	{749}
[*print-pprint-dispatch*]	variable	{749}
[*print-pretty*]	variable	{559}
[*print-radix*]	variable	{560}
[*print-readably*]	variable	{557}
[*print-right-margin*]	variable	{749}
[*query-io*]	variable	{498}
[*random-state*]	variable	{367}
[*read-base*]	variable	{522}
[*read-default-float-format*]	variable	{569}
[*read-eval*]	variable	{524}
[*read-suppress*]	variable	{522}
[*readtable*]	variable	{540}
[*standard-input*]	variable	{497}
[*standard-output*]	variable	{498}
[*suppress-series-warnings*]	variable	{944}
[*terminal-io*]	variable	{498}
[*trace-output*]	variable	{499}
[+]	function	{295}
[+]	variable	{494}
[++]	variable	{494}
[+++]	variable	{494}
[-]	function	{295}
[-]	variable	{495}
[/]	function	{296}
[/]	variable	{495}
[//]	variable	{495}
[///]	variable	{495}
[/=]	function	{293}
[1+]	function	{297}
[1-]	function	{297}
[<]	function	{293}
[<=]	function	{293}
[=]	function	{293}
[>]	function	{293}
[>=]	function	{293}
[abort]	function	{913}
[abs]	function	{303}
[acons]	function	{431}
[acos]	function	{305}
[acosh]	function	{308}
[add-method]	generic function	{817}
[add-method]	primary method	{817}
[adjoin]	function	{427}
[adjust-array]	function	{456}
[adjustable-array-p]	function	{452}
[alpha-char-p]	function	{376}
[alphanumericp]	function	{378}
[alter]	function	{942}
[always]	loop clause	{727}
[and]	macro	{110}
[append]	function	{418}
[append]	loop clause	{732}
[appending]	loop clause	{732}
[apply]	function	{145}
[applyhook]	function	{492}
[apropos]	function	{701}
[apropos-list]	function	{701}
[aref]	function	{447}
[arithmetic-error]	type	{922}
[arithmetic-error-operands]	function	{922}
[arithmetic-error-operation]	function	{922}
[array-dimension]	function	{449}
[array-dimension-limit]	constant	{446}
[array-dimensions]	function	{449}
[array-element-type]	function	{448}
[array-has-fill-pointer-p]	function	{454}
[array-in-bounds-p]	function	{449}
[array-rank]	function	{448}
[array-rank-limit]	constant	{446}
[array-row-major-index]	function	{449}
[array-total-size]	function	{449}
[array-total-size-limit]	constant	{446}
[arrayp]	function	{102}
[as]	loop clause	{718}
[as]	loop clause	{720}
[as]	loop clause	{721}
[as]	loop clause	{722}
[as]	loop clause	{722}
[as]	loop clause	{723}
[as]	loop clause	{724}
[ash]	function	{360}
[asin]	function	{305}
[asinh]	function	{308}
[assert]	macro	{671}
[assert]	macro	{891}
[assoc]	function	{432}
[assoc-if]	function	{432}
[assoc-if]	function	{432}
[assoc-if-not]	function	{432}
[assoc-if-not]	function	{432}
[atan]	function	{305}
[atanh]	function	{308}
[atom]	function	{99}
[augment-environment]	function	{211}
[bit]	function	{452}
[bit-and]	function	{453}
[bit-andc1]	function	{453}
[bit-andc2]	function	{453}
[bit-eqv]	function	{453}
[bit-ior]	function	{453}
[bit-nand]	function	{453}
[bit-nor]	function	{453}
[bit-not]	function	{454}
[bit-orc1]	function	{453}
[bit-orc2]	function	{453}
[bit-vector-p]	function	{101}
[bit-xor]	function	{453}
[block]	special form	{161}
[boole]	function	{359}
[boole-1]	constant	{359}
[boole-2]	constant	{359}
[boole-and]	constant	{359}
[boole-andc1]	constant	{359}
[boole-andc2]	constant	{359}
[boole-c1]	constant	{359}
[boole-c2]	constant	{359}
[boole-clr]	constant	{359}
[boole-eqv]	constant	{359}
[boole-ior]	constant	{359}
[boole-nand]	constant	{359}
[boole-nor]	constant	{359}
[boole-orc1]	constant	{359}
[boole-orc2]	constant	{359}
[boole-set]	constant	{359}
[boole-xor]	constant	{359}
[both-case-p]	function	{377}
[boundp]	function	{120}
[break]	function	{669}
[break]	function	{914}
[broadcast-stream-streams]	function	{507}
[butlast]	function	{422}
[byte]	function	{362}
[byte-position]	function	{362}
[byte-size]	function	{362}
[caaaar]	function	{412}
[caaadr]	function	{412}
[caaar]	function	{412}
[caadar]	function	{412}
[caaddr]	function	{412}
[caadr]	function	{412}
[caar]	function	{412}
[cadaar]	function	{412}
[cadadr]	function	{412}
[cadar]	function	{412}
[caddar]	function	{412}
[cadddr]	function	{412}
[caddr]	function	{412}
[cadr]	function	{412}
[call-arguments-limit]	constant	{147}
[call-method]	macro	{817}
[call-next-method]	function	{818}
[car]	function	{411}
[case]	macro	{159}
[catch]	special form	{187}
[catenate]	function	{936}
[ccase]	macro	{674}
[ccase]	macro	{894}
[cdaaar]	function	{412}
[cdaadr]	function	{412}
[cdaar]	function	{412}
[cdadar]	function	{412}
[cdaddr]	function	{412}
[cdadr]	function	{412}
[cdar]	function	{412}
[cddaar]	function	{412}
[cddadr]	function	{412}
[cddar]	function	{412}
[cdddar]	function	{412}
[cddddr]	function	{412}
[cdddr]	function	{412}
[cddr]	function	{412}
[cdr]	function	{411}
[ceiling]	function	{351}
[cell-error]	type	{921}
[cell-error-name]	function	{921}
[cerror]	function	{666}
[cerror]	function	{887}
[change-class]	generic function	{820}
[change-class]	primary method	{820}
[change-class]	primary method	{820}
[char]	function	{461}
[char-bit]	function	{386}
[char-bits]	function	{381}
[char-bits-limit]	constant	{375}
[char-code]	function	{381}
[char-code-limit]	constant	{375}
[char-control-bit]	constant	{386}
[char-downcase]	function	{383}
[char-equal]	function	{380}
[char-font]	function	{382}
[char-font-limit]	constant	{375}
[char-greaterp]	function	{380}
[char-hyper-bit]	constant	{386}
[char-int]	function	{384}
[char-lessp]	function	{380}
[char-meta-bit]	constant	{386}
[char-name]	function	{385}
[char-not-equal]	function	{380}
[char-not-greaterp]	function	{380}
[char-not-lessp]	function	{380}
[char-super-bit]	constant	{386}
[char-upcase]	function	{383}
[char/=]	function	{378}
[char<]	function	{378}
[char<=]	function	{378}
[char=]	function	{378}
[char>]	function	{378}
[char>=]	function	{378}
[character]	function	{383}
[characterp]	function	{101}
[check-type]	macro	{670}
[check-type]	macro	{889}
[choose]	function	{935}
[choose-if]	function	{935}
[chunk]	function	{937}
[cis]	function	{304}
[class-name]	generic function	}821}
[class-name]	primary method	{821}
[class-of]	function	{822}
[clear-input]	function	{575}
[clear-output]	function	{579}
[close]	function	{505}
[clrhash]	function	{439}
[code-char]	function	{382}
[coerce]	function	{63}
[collect]	loop clause	{731}
[collect]	function	{939}
[collect]	function	{939}
[collect-alist]	function	{941}
[collect-and]	function	{939}
[collect-append]	function	{940}
[collect-append]	function	{940}
[collect-file]	function	{941}
[collect-first]	function	{938}
[collect-fn]	function	{941}
[collect-hash]	function	{941}
[collect-last]	function	{938}
[collect-length]	function	{938}
[collect-max]	function	{939}
[collect-min]	function	{939}
[collect-nconc]	function	{940}
[collect-nth]	function	{938}
[collect-or]	function	{939}
[collect-plist]	function	{941}
[collect-sum]	function	{939}
[collecting]	loop clause	{731}
[collecting-fn]	function	{934}
[commonp]	function	{103}
[compile]	function	{677}
[compile-file]	function	{677}
[compile-file]	function	{678}
[compile-file-pathname]	function	{633}
[compiled-function-p]	function	{103}
[compiler-let]	special form	{151}
[compiler-let]	macro	{151}
[compiler-macro-function]	function	{206}
[compiler-macroexpand]	function	{206}
[compiler-macroexpand-1]	function	{206}
[complement]	function	{392}
[complex]	function	{356}
[complexp]	function	{101}
[compute-applicable-methods]	function	{822}
[compute-restarts]	function	{910}
[concatenate]	function	{394}
[concatenated-stream-streams]	function	{507}
[cond]	macro	{158}
[condition]	type	{916}
[conjugate]	function	{298}
[cons]	function	{413}
[consp]	function	{100}
[constantp]	function	{494}
[continue]	function	{913}
[control-error]	type	{920}
[copy-alist]	function	{418}
[copy-list]	function	{418}
[copy-pprint-dispatch]	function	{766}
[copy-readtable]	function	{541}
[copy-seq]	function	{393}
[copy-symbol]	function	{244}
[copy-tree]	function	{418}
[cos]	function	{304}
[cosh]	function	{308}
[cotruncate]	function	{932}
[count]	function	{406}
[count]	loop clause	{733}
[count-if]	function	{406}
[count-if-not]	function	{406}
[counting]	loop clause	{733}
[ctypecase]	macro	{673}
[ctypecase]	macro	{893}
[decf]	macro	{297}
[declaim]	macro	{223}
[declaration-information]	function	{210}
[declare]	special form	{215}
[decode-float]	function	{354}
[decode-universal-time]	function	{704}
[defclass]	macro	{822}
[defconstant]	macro	{86}
[defgeneric]	macro	{826}
[define-compiler-macro]	macro	{205}
[define-condition]	macro	{898}
[define-declaration]	macro	{213}
[define-method-combination]	macro	{830}
[define-method-combination]	macro	{830}
[define-modify-macro]	macro	{137}
[define-setf-method]	macro	{141}
[defmacro]	macro	{195}
[defmethod]	macro	{838}
[defpackage]	macro	{270}
[defparameter]	macro	{86}
[defsetf]	macro	{138}
[defstruct]	macro	{471}
[deftype]	macro	{62}
[defun]	macro	{84}
[defvar]	macro	{86}
[delete]	function	{400}
[delete-duplicates]	function	{401}
[delete-file]	function	{653}
[delete-if]	function	{400}
[delete-if-not]	function	{400}
[delete-package]	function	{265}
[denominator]	function	{351}
[deposit-field]	function	{364}
[describe]	function	{697}
[describe]	function	{697}
[describe-object]	generic function	{698}
[describe-object]	primary method	{698}
[destructuring-bind]	macro	{205}
[digit-char]	function	{384}
[digit-char-p]	function	{377}
[directory]	function	{663}
[directory-namestring]	function	{644}
[disassemble]	function	{681}
[division-by-zero]	type	{922}
[do]	loop clause	{740}
[do]	macro	{164}
[do]	macro	{165}
[do*]	macro	{164}
[do*]	macro	{165}
[do-all-symbols]	macro	{275}
[do-external-symbols]	macro	{275}
[do-symbols]	macro	{274}
[documentation]	function	{695}
[documentation]	generic function	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[documentation]	primary method	{840}
[doing]	loop clause	{740}
[dolist]	macro	{169}
[dotimes]	macro	{169}
[double-float-epsilon]	constant	{370}
[double-float-negative-epsilon]	constant	{370}
[dpb]	function	{364}
[dribble]	function	{699}
[ecase]	macro	{674}
[ecase]	macro	{894}
[echo-stream-input-stream]	function	{507}
[echo-stream-output-stream]	function	{507}
[ed]	function	{699}
[eighth]	function	{415}
[elt]	function	{392}
[encapsulated]	macro	{955}
[enclose]	function	{214}
[encode-universal-time]	function	{704}
[end-of-file]	type	{921}
[endp]	function	{414}
[enough-namestring]	function	{644}
[ensure-generic-function]	function	{842}
[eq]	function	{103}
[eql]	function	{105}
[equal]	function	{106}
[equalp]	function	{108}
[error]	function	{666}
[error]	function	{886}
[error]	type	{918}
[etypecase]	macro	{673}
[etypecase]	macro	{892}
[eval]	function	{490}
[eval-when]	special form	{88}
[eval-when]	special form	{89}
[evalhook]	function	{492}
[evenp]	function	{292}
[every]	function	{396}
[exp]	function	{300}
[expand]	function	{935}
[export]	function	{267}
[expt]	function	{300}
[fboundp]	function	{120}
[fceiling]	function	{353}
[fdefinition]	function	{120}
[ffloor]	function	{353}
[fifth]	function	{415}
[file-author]	function	{655}
[file-error]	type	{921}
[file-error-pathname]	function	{921}
[file-length]	function	{656}
[file-namestring]	function	{644}
[file-position]	function	{655}
[file-string-length]	function	{656}
[file-write-date]	function	{655}
[fill]	function	{398}
[fill-pointer]	function	{455}
[finally]	loop clause	{745}
[finally]	loop clause	{745}
[find]	function	{404}
[find-all-symbols]	function	{274}
[find-class]	function	{843}
[find-if]	function	{404}
[find-if-not]	function	{404}
[find-method]	generic function	{844}
[find-method]	primary method	{844}
[find-package]	function	{264}
[find-restart]	function	{911}
[find-symbol]	function	{267}
[finish-output]	function	{579}
[first]	function	{415}
[flet]	special form	{152}
[flet]	macro	{155}
[float]	function	{350}
[float-digits]	function	{354}
[float-precision]	function	{354}
[float-radix]	function	{354}
[float-sign]	function	{354}
[floating-point-overflow]	type	{922}
[floating-point-underflow]	type	{922}
[floatp]	function	{101}
[floor]	function	{351}
[fmakunbound]	function	{123}
[for]	loop clause	{718}
[for]	loop clause	{720}
[for]	loop clause	{721}
[for]	loop clause	{722}
[for]	loop clause	{722}
[for]	loop clause	{723}
[for]	loop clause	{724}
[force-output]	function	{579}
[format]	function	{581}
[formatter]	macro	{764}
[fourth]	function	{415}
[fresh-line]	function	{579}
[fround]	function	{353}
[ftruncate]	function	{353}
[funcall]	function	{146}
[function]	special form	{115}
[function-information]	function	{209}
[function-keywords]	generic function	{844}
[function-keywords]	primary method	{844}
[function-lambda-expression]	function	{682}
[functionp]	function	{102}
[gatherer]	function	{957}
[gathering]	macro	{958}
[gcd]	function	{298}
[generator]	function	{957}
[generic-flet]	special form	{844}
[generic-function]	macro	{845}
[generic-labels]	special form	{846}
[gensym]	function	{245}
[gentemp]	function	{246}
[get]	function	{239}
[get-decoded-time]	function	{703}
[get-dispatch-macro-character]	function	{546}
[get-internal-real-time]	function	{705}
[get-internal-run-time]	function	{705}
[get-macro-character]	function	{542}
[get-output-stream-string]	function	{502}
[get-properties]	function	{242}
[get-setf-method]	function	{143}
[get-setf-method]	function	{144}
[get-setf-method-multiple-value]	function	{144}
[get-setf-method-multiple-value]	function	{145}
[get-universal-time]	function	{704}
[getf]	function	{242}
[gethash]	function	{438}
[go]	special form	{177}
[graphic-char-p]	function	{376}
[handler-bind]	macro	{898}
[handler-case]	macro	{895}
[hash-table-count]	function	{439}
[hash-table-p]	function	{438}
[hash-table-rehash-size]	function	{440}
[hash-table-rehash-threshold]	function	{440}
[hash-table-size]	function	{440}
[hash-table-test]	function	{440}
[host-namestring]	function	{644}
[identity]	function	{707}
[if]	loop clause	{738}
[if]	special form	{157}
[ignore-errors]	macro	{897}
[imagpart]	function	{356}
[import]	function	{268}
[in-package]	function	{263}
[in-package]	macro	{264}
[incf]	macro	{297}
[initialize-instance]	generic function	{847}
[initialize-instance]	primary method	{847}
[initially]	loop clause	{745}
[input-stream-p]	function	{505}
[inspect]	function	{698}
[int-char]	function	{385}
[integer-decode-float]	function	{354}
[integer-length]	function	{361}
[integerp]	function	{100}
[interactive-stream-p]	function	{507}
[intern]	function	{266}
[internal-time-units-per-second]	constant	{704}
[intersection]	function	{429}
[invalid-method-error]	function	{847}
[invoke-debugger]	function	{915}
[invoke-restart]	function	{911}
[invoke-restart-interactively]	function	{911}
[isqrt]	function	{302}
[iterate]	macro	{932}
[keywordp]	function	{246}
[labels]	special form	{152}
[labels]	macro	{155}
[lambda-list-keywords]	constant	{82}
[lambda-parameters-limit]	constant	{83}
[last]	function	{416}
[last]	function	{416}
[latch]	function	{933}
[lcm]	function	{298}
[ldb]	function	{362}
[ldb-test]	function	{363}
[ldiff]	function	{422}
[least-negative-double-float]	constant	{369}
[least-negative-long-float]	constant	{369}
[least-negative-normalized-double-float]	constant	{370}
[least-negative-normalized-long-float]	constant	{370}
[least-negative-normalized-short-float]	constant	{369}
[least-negative-normalized-single-float]	constant	{370}
[least-negative-short-float]	constant	{368}
[least-negative-single-float]	constant	{369}
[least-positive-double-float]	constant	{369}
[least-positive-long-float]	constant	{369}
[least-positive-normalized-double-float]	constant	{370}
[least-positive-normalized-long-float]	constant	{370}
[least-positive-normalized-short-float]	constant	{369}
[least-positive-normalized-single-float]	constant	{370}
[least-positive-short-float]	constant	{368}
[least-positive-single-float]	constant	{369}
[length]	function	{393}
[let]	special form	{148}
[let]	macro	{150}
[let*]	special form	{150}
[let*]	macro	{151}
[lisp-implementation-type]	function	{706}
[lisp-implementation-version]	function	{706}
[list]	function	{417}
[list*]	function	{417}
[list-all-packages]	function	{265}
[list-length]	function	{414}
[listen]	function	{574}
[listp]	function	{100}
[load]	function	{657}
[load-logical-pathname-translations]	function	{632}
[load-time-value]	special form	{680}
[locally]	macro	{220}
[locally]	special form	{221}
[log]	function	{301}
[logand]	function	{357}
[logandc1]	function	{358}
[logandc2]	function	{358}
[logbitp]	function	{360}
[logcount]	function	{361}
[logeqv]	function	{358}
[logical-pathname]	class	{628}
[logical-pathname]	function	{631}
[logical-pathname-translations]	function	{632}
[logior]	function	{357}
[lognand]	function	{358}
[lognor]	function	{358}
[lognot]	function	{360}
[logorc1]	function	{358}
[logorc2]	function	{358}
[logtest]	function	{360}
[logxor]	function	{357}
[long-float-epsilon]	constant	{370}
[long-float-negative-epsilon]	constant	{370}
[long-site-name]	function	{707}
[loop]	macro	{163}
[loop-finish]	macro	{729}
[lower-case-p]	function	{377}
[machine-instance]	function	{706}
[machine-type]	function	{706}
[machine-version]	function	{706}
[macro-function]	function	{194}
[macro-function]	function	{195}
[macroexpand]	function	{203}
[macroexpand-1]	function	{203}
[macrolet]	special form	{152}
[macrolet]	macro	{155}
[make-array]	function	{442}
[make-broadcast-stream]	function	{500}
[make-char]	function	{382}
[make-concatenated-stream]	function	{500}
[make-condition]	function	{901}
[make-dispatch-macro-character]	function	{546}
[make-echo-stream]	function	{501}
[make-hash-table]	function	{436}
[make-instance]	generic function	{848}
[make-instance]	primary method	{848}
[make-instance]	primary method	{848}
[make-instances-obsolete]	generic function	{848}
[make-instances-obsolete]	primary method	{848}
[make-instances-obsolete]	primary method	{848}
[make-list]	function	{418}
[make-load-form]	generic function	{659}
[make-load-form-saving-slots]	function	{662}
[make-package]	function	{262}
[make-pathname]	function	{643}
[make-pathname]	function	{643}
[make-random-state]	function	{367}
[make-sequence]	function	{394}
[make-string]	function	{464}
[make-string]	function	{464}
[make-string-input-stream]	function	{501}
[make-string-output-stream]	function	{501}
[make-string-output-stream]	function	{502}
[make-symbol]	function	{244}
[make-synonym-stream]	function	{500}
[make-two-way-stream]	function	{501}
[makunbound]	function	{123}
[map]	function	{395}
[map-fn]	function	{930}
[map-into]	function	{395}
[mapc]	function	{171}
[mapcan]	function	{171}
[mapcar]	function	{171}
[mapcon]	function	{171}
[maphash]	function	{438}
[mapl]	function	{171}
[maplist]	function	{171}
[mapping]	macro	{931}
[mask]	function	{937}
[mask-field]	function	{363}
[max]	function	{294}
[maximize]	loop clause	{734}
[maximizing]	loop clause	{734}
[member]	function	{426}
[member-if]	function	{426}
[member-if-not]	function	{426}
[merge]	function	{409}
[merge-pathnames]	function	{641}
[method-combination-error]	function	{849}
[method-qualifiers]	generic function	{849}
[method-qualifiers]	primary method	{849}
[min]	function	{294}
[mingle]	function	{937}
[minimize]	loop clause	{734}
[minimizing]	loop clause	{734}
[minusp]	function	{292}
[mismatch]	function	{407}
[mod]	function	{353}
[most-negative-double-float]	constant	{369}
[most-negative-fixnum]	constant	{368}
[most-negative-long-float]	constant	{369}
[most-negative-short-float]	constant	{368}
[most-negative-single-float]	constant	{369}
[most-positive-double-float]	constant	{369}
[most-positive-fixnum]	constant	{368}
[most-positive-long-float]	constant	{369}
[most-positive-short-float]	constant	{368}
[most-positive-single-float]	constant	{369}
[muffle-warning]	function	{913}
[multiple-value-bind]	macro	{183}
[multiple-value-call]	special form	{182}
[multiple-value-list]	macro	{182}
[multiple-value-prog1]	special form	{183}
[multiple-value-setq]	macro	{183}
[multiple-values-limit]	constant	{182}
[name-char]	function	{385}
[named]	loop clause	{746}
[namestring]	function	{644}
[nbutlast]	function	{422}
[nconc]	function	{419}
[nconc]	loop clause	{732}
[nconcing]	loop clause	{732}
[never]	loop clause	{727}
[next-in]	macro	{957}
[next-method-p]	function	{849}
[next-out]	function	{957}
[nil]	constant	{96}
[nintersection]	function	{429}
[ninth]	function	{415}
[no-applicable-method]	generic function	{850}
[no-applicable-method]	primary method	{850}
[no-next-method]	generic function	{850}
[no-next-method]	primary method	{850}
[not]	function	{110}
[notany]	function	{396}
[notevery]	function	{396}
[nreconc]	function	{420}
[nreverse]	function	{393}
[nset-difference]	function	{429}
[nset-exclusive-or]	function	{430}
[nstring-capitalize]	function	{466}
[nstring-downcase]	function	{466}
[nstring-upcase]	function	{466}
[nsublis]	function	{426}
[nsubst]	function	{425}
[nsubst-if]	function	{425}
[nsubst-if-not]	function	{425}
[nsubstitute]	function	{403}
[nsubstitute-if]	function	{403}
[nsubstitute-if-not]	function	{403}
[nth]	function	{415}
[nth-value]	macro	{184}
[nthcdr]	function	{416}
[null]	function	{99}
[numberp]	function	{100}
[numerator]	function	{351}
[nunion]	function	{428}
[oddp]	function	{292}
[off-line-port] \lowercase {Declaration specifier}}}{949}		
[open]	function	{646}
[open-stream-p]	function	{505}
[optimizable-series-function] \lowercase {Declaration specifier}}}{948}		
[or]	macro	{111}
[output-stream-p]	function	{505}
[package-error]	type	{920}
[package-error-package]	function	{920}
[package-name]	function	{264}
[package-nicknames]	function	{264}
[package-shadowing-symbols]	function	{265}
[package-use-list]	function	{265}
[package-used-by-list]	function	{265}
[packagep]	function	{102}
[pairlis]	function	{432}
[parse-integer]	function	{575}
[parse-macro]	function	{214}
[parse-namestring]	function	{639}
[pathname]	function	{638}
[pathname-device]	function	{644}
[pathname-device]	function	{644}
[pathname-directory]	function	{644}
[pathname-directory]	function	{644}
[pathname-host]	function	{644}
[pathname-host]	function	{644}
[pathname-match-p]	function	{623}
[pathname-name]	function	{644}
[pathname-name]	function	{644}
[pathname-type]	function	{644}
[pathname-type]	function	{644}
[pathname-version]	function	{644}
[pathname-version]	function	{644}
[pathnamep]	function	{643}
[peek-char]	function	{574}
[phase]	function	{303}
[pi]	constant	{307}
[plusp]	function	{292}
[pop]	macro	{421}
[position]	function	{404}
[position-if]	function	{404}
[position-if-not]	function	{404}
[positions]	function	{936}
[pprint]	function	{577}
[pprint-dispatch]	function	{766}
[pprint-exit-if-list-exhausted]	macro	{754}
[pprint-fill]	function	{756}
[pprint-indent]	function	{755}
[pprint-linear]	function	{756}
[pprint-logical-block]	macro	{752}
[pprint-newline]	function	{751}
[pprint-pop]	macro	{754}
[pprint-tab]	function	{756}
[pprint-tabular]	function	{756}
[previous]	function	{933}
[prin1]	function	{577}
[prin1-to-string]	function	{578}
[princ]	function	{577}
[princ-to-string]	function	{578}
[print]	function	{577}
[print-object]	generic function	{850}
[print-object]	primary method	{850}
[print-unreadable-object]	macro	{580}
[probe-file]	function	{654}
[proclaim]	function	{222}
[producing]	macro	{951}
[prog]	macro	{175}
[prog*]	macro	{175}
[prog1]	macro	{147}
[prog2]	macro	{148}
[progn]	special form	{147}
[program-error]	type	{920}
[progv]	special form	{152}
[propagate-alterability] \lowercase {Declaration specifier}}}{954}		
[provide]	function	{277}
[psetf]	macro	{129}
[psetq]	macro	{122}
[push]	macro	{420}
[pushnew]	macro	{420}
[quote]	special form	{115}
[random]	function	{365}
[random-state-p]	function	{368}
[rassoc]	function	{433}
[rassoc-if]	function	{433}
[rassoc-if]	function	{434}
[rassoc-if-not]	function	{433}
[rassoc-if-not]	function	{434}
[rational]	function	{350}
[rationalize]	function	{350}
[rationalp]	function	{101}
[read]	function	{569}
[read-byte]	function	{576}
[read-char]	function	{573}
[read-char-no-hang]	function	{574}
[read-delimited-list]	function	{571}
[read-from-string]	function	{575}
[read-line]	function	{572}
[read-preserving-whitespace]	function	{569}
[readtable-case]	function	{549}
[readtablep]	function	{541}
[realp]	function	{101}
[realpart]	function	{356}
[reduce]	function	{397}
[reinitialize-instance]	generic function	{852}
[reinitialize-instance]	primary method	{852}
[rem]	function	{353}
[remf]	macro	{242}
[remhash]	function	{438}
[remove]	function	{399}
[remove-duplicates]	function	{401}
[remove-if]	function	{399}
[remove-if-not]	function	{399}
[remove-method]	generic function	{853}
[remove-method]	primary method	{853}
[remprop]	function	{241}
[rename-file]	function	{653}
[rename-package]	function	{264}
[repeat]	loop clause	{725}
[replace]	function	{399}
[require]	function	{277}
[rest]	function	{416}
[restart]	type	{916}
[restart-bind]	macro	{909}
[restart-case]	macro	{903}
[restart-name]	function	{911}
[result-of]	function	{958}
[return]	loop clause	{741}
[return]	macro	{162}
[return-from]	special form	{162}
[revappend]	function	{419}
[reverse]	function	{393}
[room]	function	{699}
[rotatef]	macro	{131}
[round]	function	{351}
[row-major-aref]	function	{450}
[rplaca]	function	{423}
[rplacd]	function	{423}
[sbit]	function	{452}
[scale-float]	function	{354}
[scan]	function	{926}
[scan]	function	{926}
[scan-alist]	function	{928}
[scan-file]	function	{928}
[scan-fn]	function	{929}
[scan-fn-inclusive]	function	{930}
[scan-hash]	function	{928}
[scan-lists-of-lists]	function	{927}
[scan-lists-of-lists-fringe]	function	{927}
[scan-multiple]	function	{927}
[scan-plist]	function	{928}
[scan-range]	function	{926}
[scan-sublists]	function	{927}
[scan-symbols]	function	{928}
[schar]	function	{461}
[search]	function	{407}
[second]	function	{415}
[series] \lowercase {Type specifier}}}{925}		
[series]	function	{925}
[series-element-type] \lowercase {Type specifier}}}{950}		
[serious-condition]	type	{917}
[set]	function	{122}
[set-char-bit]	function	{387}
[set-difference]	function	{429}
[set-dispatch-macro-character]	function	{546}
[set-exclusive-or]	function	{430}
[set-macro-character]	function	{542}
[set-pprint-dispatch]	function	{766}
[set-syntax-from-char]	function	{541}
[setf]	macro	{124}
[setq]	special form	{121}
[seventh]	function	{415}
[shadow]	function	{269}
[shadowing-import]	function	{268}
[shared-initialize]	generic function	{853}
[shared-initialize]	primary method	{853}
[shiftf]	macro	{130}
[short-float-epsilon]	constant	{370}
[short-float-negative-epsilon]	constant	{370}
[short-site-name]	function	{707}
[signal]	function	{888}
[signum]	function	{304}
[simple-bit-vector-p]	function	{102}
[simple-condition]	type	{918}
[simple-condition-format-arguments]	function	{919}
[simple-condition-format-string]	function	{919}
[simple-error]	type	{918}
[simple-string-p]	function	{102}
[simple-type-error]	type	{919}
[simple-vector-p]	function	{102}
[simple-warning]	type	{918}
[sin]	function	{304}
[single-float-epsilon]	constant	{370}
[single-float-negative-epsilon]	constant	{370}
[sinh]	function	{308}
[sixth]	function	{415}
[sleep]	function	{705}
[slot-boundp]	function	{855}
[slot-exists-p]	function	{855}
[slot-makunbound]	function	{855}
[slot-missing]	generic function	{856}
[slot-missing]	primary method	{856}
[slot-unbound]	generic function	{856}
[slot-unbound]	primary method	{856}
[slot-value]	function	{857}
[software-type]	function	{706}
[software-version]	function	{706}
[some]	function	{396}
[sort]	function	{408}
[special-form-p]	function	{120}
[split]	function	{936}
[split-if]	function	{936}
[sqrt]	function	{302}
[stable-sort]	function	{408}
[standard-char-p]	function	{376}
[step]	macro	{696}
[storage-condition]	type	{919}
[store-value]	function	{913}
[stream-element-type]	function	{505}
[stream-error]	type	{920}
[stream-error-stream]	function	{920}
[stream-external-format]	function	{508}
[streamp]	function	{504}
[string]	function	{466}
[string-capitalize]	function	{465}
[string-char-p]	function	{376}
[string-downcase]	function	{465}
[string-equal]	function	{462}
[string-greaterp]	function	{463}
[string-left-trim]	function	{464}
[string-lessp]	function	{463}
[string-not-equal]	function	{463}
[string-not-greaterp]	function	{463}
[string-not-lessp]	function	{463}
[string-right-trim]	function	{464}
[string-trim]	function	{464}
[string-upcase]	function	{465}
[string/=]	function	{462}
[string<]	function	{462}
[string<=]	function	{462}
[string=]	function	{461}
[string>]	function	{462}
[string>=]	function	{462}
[stringp]	function	{101}
[sublis]	function	{425}
[subseq]	function	{393}
[subseries]	function	{936}
[subsetp]	function	{431}
[subst]	function	{424}
[subst-if]	function	{424}
[subst-if-not]	function	{424}
[substitute]	function	{402}
[substitute-if]	function	{402}
[substitute-if-not]	function	{402}
[subtypep]	function	{97}
[sum]	loop clause	{733}
[summing]	loop clause	{733}
[svref]	function	{448}
[sxhash]	function	{441}
[symbol-function]	function	{119}
[symbol-macrolet]	special form	{155}
[symbol-name]	function	{243}
[symbol-package]	function	{246}
[symbol-plist]	function	{241}
[symbol-value]	function	{119}
[symbolp]	function	{99}
[synonym-stream-symbol]	function	{507}
[t]	constant	{96}
[tagbody]	special form	{173}
[tailp]	function	{427}
[tan]	function	{304}
[tanh]	function	{308}
[tenth]	function	{415}
[terminate-producing]	macro	{954}
[terpri]	function	{579}
[the]	special form	{237}
[thereis]	loop clause	{727}
[third]	function	{415}
[throw]	special form	{192}
[time]	macro	{696}
[to-alter]	function	{942}
[trace]	macro	{695}
[translate-logical-pathname]	function	{631}
[translate-pathname]	function	{624}
[tree-equal]	function	{413}
[truename]	function	{639}
[truncate]	function	{351}
[two-way-stream-input-stream]	function	{507}
[two-way-stream-output-stream]	function	{507}
[type-error]	type	{919}
[type-error-datum]	function	{919}
[type-error-expected-type]	function	{919}
[type-of]	function	{65}
[typecase]	macro	{160}
[typep]	function	{96}
[unbound-variable]	type	{921}
[undefined-function]	type	{921}
[unexport]	function	{268}
[unintern]	function	{267}
[union]	function	{428}
[unless]	loop clause	{738}
[unless]	macro	{157}
[unread-char]	function	{573}
[until]	loop clause	{726}
[until]	function	{932}
[until-if]	function	{932}
[untrace]	macro	{695}
[unuse-package]	function	{269}
[unwind-protect]	special form	{188}
[update-instance-for-different-class]	generic function	{857}
[update-instance-for-different-class]	primary method	{857}
[update-instance-for-redefined-class]	generic function	{859}
[update-instance-for-redefined-class]	primary method	{859}
[upgraded-array-element-type]	function	{67}
[upgraded-complex-part-type]	function	{68}
[upper-case-p]	function	{377}
[use-package]	function	{269}
[use-value]	function	{914}
[user-homedir-pathname]	function	{645}
[values]	function	{181}
[values-list]	function	{182}
[variable-information]	function	{208}
[vector]	function	{447}
[vector-pop]	function	{455}
[vector-push]	function	{455}
[vector-push-extend]	function	{455}
[vectorp]	function	{102}
[warn]	function	{668}
[warn]	function	{912}
[warning]	type	{916}
[when]	loop clause	{738}
[when]	macro	{157}
[while]	loop clause	{726}
[wild-pathname-p]	function	{623}
[with]	loop clause	{737}
[with-accessors]	macro	{861}
[with-added-methods]	special form	{862}
[with-compilation-unit]	macro	{683}
[with-condition-restarts]	macro	{910}
[with-hash-table-iterator]	macro	{439}
[with-input-from-string]	macro	{502}
[with-open-file]	macro	{651}
[with-open-stream]	macro	{502}
[with-output-to-string]	macro	{503}
[with-output-to-string]	macro	{504}
[with-package-iterator]	macro	{275}
[with-simple-restart]	macro	{902}
[with-slots]	macro	{863}
[with-standard-io-syntax]	macro	{565}
[write]	function	{577}
[write]	function	{577}
[write-byte]	function	{581}
[write-char]	function	{579}
[write-line]	function	{579}
[write-string]	function	{579}
[write-to-string]	function	{578}
[write-to-string]	function	{579}
[y-or-n-p]	function	{609}
[yes-or-no-p]	function	{610}
[zerop]	function	{292}
