Symbol Index (ANSI Common Lisp)

Symbol Index

Jump to:	( * + - / 1 < = > A B C D E F G H I K L M N O P Q R S T U V W Y Z

	Index Entry	Section

(
	(setf class-name):	setf class-name
	(setf documentation):	documentation; setf documentation

*
	*:	* (Function)
	*:	; ; **
	**:	; ; **
	***:	; ; **
	break-on-signals:	break-on-signals
	compile-file-pathname:	compile-file-pathname; compile-file-truename
	compile-file-truename:	compile-file-pathname; compile-file-truename
	compile-print:	compile-print; compile-verbose
	compile-verbose:	compile-print; compile-verbose
	debug-io:	debug-io; error-output; query-io; standard-input; *standard-out+
	debugger-hook:	debugger-hook
	default-pathname-defaults:	default-pathname-defaults
	error-output:	debug-io; error-output; query-io; standard-input; *standard-out+
	features:	features
	gensym-counter:	gensym-counter
	load-pathname:	load-pathname; load-truename
	load-print:	load-print; load-verbose
	load-truename:	load-pathname; load-truename
	load-verbose:	load-print; load-verbose
	macroexpand-hook:	macroexpand-hook
	modules:	modules
	package:	package
	print-array:	print-array
	print-base:	print-base; print-radix
	print-case:	print-case
	print-circle:	print-circle
	print-escape:	print-escape
	print-gensym:	print-gensym
	print-length:	print-level; print-length
	print-level:	print-level; print-length
	print-lines:	print-lines
	print-miser-width:	print-miser-width
	print-pprint-dispatch:	print-pprint-dispatch
	print-pretty:	print-pretty
	print-radix:	print-base; print-radix
	print-readably:	print-readably
	print-right-margin:	print-right-margin
	query-io:	debug-io; error-output; query-io; standard-input; *standard-out+
	random-state:	random-state
	read-base:	read-base
	read-default-float-format:	read-default-float-format
	read-eval:	read-eval
	read-suppress:	read-suppress
	readtable:	readtable
	standard-input:	debug-io; error-output; query-io; standard-input; *standard-out+
	standard-output:	debug-io; error-output; query-io; standard-input; *standard-out+
	terminal-io:	terminal-io
	trace-output:	debug-io; error-output; query-io; standard-input; *standard-out+

+
	+:	+ (Function)
	+:	+; ++; +++
	++:	+; ++; +++
	+++:	+; ++; +++

-
	-:	- (Function)
	-:	- (Variable)

/
	/:	/ (Function)
	/:	/; //; ///
	//:	/; //; ///
	///:	/; //; ///
	/=:	=; /=; <; >; <=; >=

1
	1+:	1+; 1-
	1-:	1+; 1-

<
	<:	=; /=; <; >; <=; >=
	<=:	=; /=; <; >; <=; >=

=
	=:	=; /=; <; >; <=; >=

>
	>:	=; /=; <; >; <=; >=
	>=:	=; /=; <; >; <=; >=

A
	abort:	abort (Restart)
	abort:	abort; continue; muffle-warning; store-value; use-value
	abs:	abs
	acons:	acons
	acos:	asin; acos; atan
	acosh:	sinh; cosh; tanh; asinh; acosh; atanh
	add-method:	add-method
	adjoin:	adjoin
	adjust-array:	adjust-array
	adjustable-array-p:	adjustable-array-p
	allocate-instance:	allocate-instance
	alpha-char-p:	alpha-char-p
	alphanumericp:	alphanumericp
	and:	and (Type Specifier)
	and:	and (Macro)
	append:	append
	apply:	apply
	apropos:	apropos; apropos-list
	apropos-list:	apropos; apropos-list
	aref:	aref
	arithmetic-error:	arithmetic-error
	arithmetic-error-operands:	arithmetic-error-operands; arithmetic-error-operation
	arithmetic-error-operation:	arithmetic-error-operands; arithmetic-error-operation
	array:	array
	array-dimension:	array-dimension
	array-dimension-limit:	array-dimension-limit
	array-dimensions:	array-dimensions
	array-displacement:	array-displacement
	array-element-type:	array-element-type
	array-has-fill-pointer-p:	array-has-fill-pointer-p
	array-in-bounds-p:	array-in-bounds-p
	array-rank:	array-rank
	array-rank-limit:	array-rank-limit
	array-row-major-index:	array-row-major-index
	array-total-size:	array-total-size
	array-total-size-limit:	array-total-size-limit
	arrayp:	arrayp
	ash:	ash
	asin:	asin; acos; atan
	asinh:	sinh; cosh; tanh; asinh; acosh; atanh
	assert:	assert
	assoc:	assoc; assoc-if; assoc-if-not
	assoc-if:	assoc; assoc-if; assoc-if-not
	assoc-if-not:	assoc; assoc-if; assoc-if-not
	atan:	asin; acos; atan
	atanh:	sinh; cosh; tanh; asinh; acosh; atanh
	atom:	atom (Type)
	atom:	atom (Function)

B
	base-char:	base-char
	base-string:	base-string
	bignum:	bignum
	bit:	bit (Type)
	bit:	bit; sbit
	bit-and:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-andc1:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-andc2:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-eqv:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-ior:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-nand:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-nor:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-not:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-orc1:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-orc2:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	bit-vector:	bit-vector
	bit-vector-p:	bit-vector-p
	bit-xor:	bit-and; bit-andc1; bit-andc2; bit-eqv; bit-ior; bit-nand; bit-nor; bit+
	block:	block
	boole:	boole
	boole-1:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-2:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-and:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-andc1:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-andc2:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-c1:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-c2:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-clr:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-eqv:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-ior:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-nand:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-nor:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-orc1:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-orc2:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-set:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boole-xor:	boole-1; boole-2; boole-and; boole-andc1; boole-andc2; boole-c1; boole-+
	boolean:	boolean
	both-case-p:	upper-case-p; lower-case-p; both-case-p
	boundp:	boundp
	break:	break
	broadcast-stream:	broadcast-stream
	broadcast-stream-streams:	broadcast-stream-streams
	built-in-class:	built-in-class
	butlast:	butlast; nbutlast
	byte:	byte; byte-size; byte-position
	byte-position:	byte; byte-size; byte-position
	byte-size:	byte; byte-size; byte-position

C
	caaaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caaadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caadar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caaddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cadaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cadadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cadar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caddar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cadddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	caddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	call-arguments-limit:	call-arguments-limit
	call-method:	call-method; make-method
	call-next-method:	call-next-method
	car:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	case:	case; ccase; ecase
	catch:	catch
	ccase:	case; ccase; ecase
	cdaaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdaadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdadar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdaddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cddaar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cddadr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cddar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdddar:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cddddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cddr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	cdr:	car; cdr; caar; cadr; cdar; cddr; caaar; caadr; cadar; caddr; cdaar; cd+
	ceiling:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	cell-error:	cell-error
	cell-error-name:	cell-error-name
	cerror:	cerror
	change-class:	change-class
	char:	char; schar
	char-code:	char-code
	char-code-limit:	char-code-limit
	char-downcase:	char-upcase; char-downcase
	char-equal:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-greaterp:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-int:	char-int
	char-lessp:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-name:	char-name
	char-not-equal:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-not-greaterp:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-not-lessp:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char-upcase:	char-upcase; char-downcase
	char/=:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char<:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char<=:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char=:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char>:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	char>=:	char=; char/=; char<; char>; char<=; char>=; char-equal; char-not-equal+
	character:	character (System Class)
	character:	character (Function)
	characterp:	characterp
	check-type:	check-type
	cis:	cis
	class:	class
	class-name:	class-name
	class-of:	class-of
	clear-input:	clear-input
	clear-output:	finish-output; force-output; clear-output
	close:	close
	clrhash:	clrhash
	code-char:	code-char
	coerce:	coerce
	compile:	compile
	compile-file:	compile-file
	compile-file-pathname:	compile-file-pathname
	compiled-function:	compiled-function
	compiled-function-p:	compiled-function-p
	compiler-macro-function:	compiler-macro-function
	complement:	complement
	complex:	complex (System Class)
	complex:	complex (Function)
	complexp:	complexp
	compute-applicable-methods:	compute-applicable-methods
	compute-restarts:	compute-restarts
	concatenate:	concatenate
	concatenated-stream:	concatenated-stream
	concatenated-stream-streams:	concatenated-stream-streams
	cond:	cond
	condition:	condition
	conjugate:	conjugate
	cons:	cons (System Class)
	cons:	cons (Function)
	consp:	consp
	constantly:	constantly
	constantp:	constantp
	continue:	continue (Restart)
	continue:	abort; continue; muffle-warning; store-value; use-value
	control-error:	control-error
	copy-alist:	copy-alist
	copy-list:	copy-list
	copy-pprint-dispatch:	copy-pprint-dispatch
	copy-readtable:	copy-readtable
	copy-seq:	copy-seq
	copy-structure:	copy-structure
	copy-symbol:	copy-symbol
	copy-tree:	copy-tree
	cos:	sin; cos; tan
	cosh:	sinh; cosh; tanh; asinh; acosh; atanh
	count:	count; count-if; count-if-not
	count-if:	count; count-if; count-if-not
	count-if-not:	count; count-if; count-if-not
	ctypecase:	typecase; ctypecase; etypecase

D
	decf:	incf; decf
	declaim:	declaim
	declaration:	declaration
	declare:	declare
	decode-float:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	decode-universal-time:	decode-universal-time
	defclass:	defclass
	defconstant:	defconstant
	defgeneric:	defgeneric
	define-compiler-macro:	define-compiler-macro
	define-condition:	define-condition
	define-method-combination:	define-method-combination
	define-modify-macro:	define-modify-macro
	define-setf-expander:	define-setf-expander
	define-symbol-macro:	define-symbol-macro
	defmacro:	defmacro
	defmethod:	defmethod
	defpackage:	defpackage
	defparameter:	defparameter; defvar
	defsetf:	defsetf
	defstruct:	defstruct
	deftype:	deftype
	defun:	defun
	defvar:	defparameter; defvar
	delete:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	delete-duplicates:	remove-duplicates; delete-duplicates
	delete-file:	delete-file
	delete-if:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	delete-if-not:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	delete-package:	delete-package
	denominator:	numerator; denominator
	deposit-field:	deposit-field
	describe:	describe
	describe-object:	describe-object
	destructuring-bind:	destructuring-bind
	digit-char:	digit-char
	digit-char-p:	digit-char-p
	directory:	directory
	directory-namestring:	namestring; file-namestring; directory-namestring; host-namestring; eno+
	disassemble:	disassemble
	division-by-zero:	division-by-zero
	do:	do; do*
	do*:	do; do*
	do-all-symbols:	do-symbols; do-external-symbols; do-all-symbols
	do-external-symbols:	do-symbols; do-external-symbols; do-all-symbols
	do-symbols:	do-symbols; do-external-symbols; do-all-symbols
	documentation:	documentation; setf documentation
	dolist:	dolist
	dotimes:	dotimes
	double-float:	short-float; single-float; double-float; long-float
	double-float-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	double-float-negative-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	dpb:	dpb
	dribble:	dribble
	dynamic-extent:	dynamic-extent

E
	ecase:	case; ccase; ecase
	echo-stream:	echo-stream
	echo-stream-input-stream:	echo-stream-input-stream; echo-stream-output-stream
	echo-stream-output-stream:	echo-stream-input-stream; echo-stream-output-stream
	ed:	ed
	eighth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	elt:	elt
	encode-universal-time:	encode-universal-time
	end-of-file:	end-of-file
	endp:	endp
	enough-namestring:	namestring; file-namestring; directory-namestring; host-namestring; eno+
	ensure-directories-exist:	ensure-directories-exist
	ensure-generic-function:	ensure-generic-function
	eq:	eq
	eql:	eql (Type Specifier)
	eql:	eql (Function)
	equal:	equal
	equalp:	equalp
	error:	error (Condition Type)
	error:	error (Function)
	etypecase:	typecase; ctypecase; etypecase
	eval:	eval
	eval-when:	eval-when
	evenp:	evenp; oddp
	every:	every; some; notevery; notany
	exp:	exp; expt
	export:	export
	expt:	exp; expt
	extended-char:	extended-char

F
	fboundp:	fboundp
	fceiling:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	fdefinition:	fdefinition
	ffloor:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	fifth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	file-author:	file-author
	file-error:	file-error
	file-error-pathname:	file-error-pathname
	file-length:	file-length
	file-namestring:	namestring; file-namestring; directory-namestring; host-namestring; eno+
	file-position:	file-position
	file-stream:	file-stream
	file-string-length:	file-string-length
	file-write-date:	file-write-date
	fill:	fill
	fill-pointer:	fill-pointer
	find:	find; find-if; find-if-not
	find-all-symbols:	find-all-symbols
	find-class:	find-class
	find-if:	find; find-if; find-if-not
	find-if-not:	find; find-if; find-if-not
	find-method:	find-method
	find-package:	find-package
	find-restart:	find-restart
	find-symbol:	find-symbol
	finish-output:	finish-output; force-output; clear-output
	first:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	fixnum:	fixnum
	flet:	flet; labels; macrolet
	float:	float (System Class)
	float:	float (Function)
	float-digits:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	float-precision:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	float-radix:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	float-sign:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	floating-point-inexact:	floating-point-inexact
	floating-point-invalid-operation:	floating-point-invalid-operation
	floating-point-overflow:	floating-point-overflow
	floating-point-underflow:	floating-point-underflow
	floatp:	floatp
	floor:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	fmakunbound:	fmakunbound
	force-output:	finish-output; force-output; clear-output
	format:	format
	formatter:	formatter
	fourth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	fresh-line:	terpri; fresh-line
	fround:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	ftruncate:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	ftype:	ftype
	funcall:	funcall
	function:	function (System Class)
	function:	function (Special Operator)
	function-keywords:	function-keywords
	function-lambda-expression:	function-lambda-expression
	functionp:	functionp

G
	gcd:	gcd
	generic-function:	generic-function
	gensym:	gensym
	gentemp:	gentemp
	get:	get
	get-decoded-time:	get-universal-time; get-decoded-time
	get-dispatch-macro-character:	set-dispatch-macro-character; get-dispatch-macro-character
	get-internal-real-time:	get-internal-real-time
	get-internal-run-time:	get-internal-run-time
	get-macro-character:	set-macro-character; get-macro-character
	get-output-stream-string:	get-output-stream-string
	get-properties:	get-properties
	get-setf-expansion:	get-setf-expansion
	get-universal-time:	get-universal-time; get-decoded-time
	getf:	getf
	gethash:	gethash
	go:	go
	graphic-char-p:	graphic-char-p

H
	handler-bind:	handler-bind
	handler-case:	handler-case
	hash-table:	hash-table
	hash-table-count:	hash-table-count
	hash-table-p:	hash-table-p
	hash-table-rehash-size:	hash-table-rehash-size
	hash-table-rehash-threshold:	hash-table-rehash-threshold
	hash-table-size:	hash-table-size
	hash-table-test:	hash-table-test
	host-namestring:	namestring; file-namestring; directory-namestring; host-namestring; eno+

I
	identity:	identity
	if:	if
	ignorable:	ignore; ignorable
	ignore:	ignore; ignorable
	ignore-errors:	ignore-errors
	imagpart:	realpart; imagpart
	import:	import
	in-package:	in-package
	incf:	incf; decf
	initialize-instance:	initialize-instance (Standard Generic Function)
	inline:	inline; notinline
	input-stream-p:	input-stream-p; output-stream-p
	inspect:	inspect
	integer:	integer
	integer-decode-float:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	integer-length:	integer-length
	integerp:	integerp
	interactive-stream-p:	interactive-stream-p
	intern:	intern
	internal-time-units-per-second:	internal-time-units-per-second
	intersection:	intersection; nintersection
	invalid-method-error:	invalid-method-error
	invoke-debugger:	invoke-debugger
	invoke-restart:	invoke-restart
	invoke-restart-interactively:	invoke-restart-interactively
	isqrt:	sqrt; isqrt

K
	keyword:	keyword
	keywordp:	keywordp

L
	labels:	flet; labels; macrolet
	lambda:	lambda (Symbol)
	lambda:	lambda (Macro)
	lambda-list-keywords:	lambda-list-keywords
	lambda-parameters-limit:	lambda-parameters-limit
	last:	last
	lcm:	lcm
	ldb:	ldb
	ldb-test:	ldb-test
	ldiff:	ldiff; tailp
	least-negative-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-normalized-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-normalized-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-normalized-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-normalized-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-negative-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-normalized-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-normalized-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-normalized-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-normalized-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	least-positive-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	length:	length
	let:	let; let*
	let*:	let; let*
	lisp-implementation-type:	lisp-implementation-type; lisp-implementation-version
	lisp-implementation-version:	lisp-implementation-type; lisp-implementation-version
	list:	list (System Class)
	list:	list; list*
	list*:	list; list*
	list-all-packages:	list-all-packages
	list-length:	list-length
	listen:	listen
	listp:	listp
	load:	load
	load-logical-pathname-translations:	load-logical-pathname-translations
	load-time-value:	load-time-value
	locally:	locally
	log:	log
	logand:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logandc1:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logandc2:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logbitp:	logbitp
	logcount:	logcount
	logeqv:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logical-pathname:	logical-pathname (System Class)
	logical-pathname:	logical-pathname (Function)
	logical-pathname-translations:	logical-pathname-translations
	logior:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	lognand:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	lognor:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	lognot:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logorc1:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logorc2:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	logtest:	logtest
	logxor:	logand; logandc1; logandc2; logeqv; logior; lognand; lognor; lognot; lo+
	long-float:	short-float; single-float; double-float; long-float
	long-float-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	long-float-negative-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	long-site-name:	short-site-name; long-site-name
	loop:	loop
	loop-finish:	loop-finish
	lower-case-p:	upper-case-p; lower-case-p; both-case-p

M
	machine-instance:	machine-instance
	machine-type:	machine-type
	machine-version:	machine-version
	macro-function:	macro-function
	macroexpand:	macroexpand; macroexpand-1
	macroexpand-1:	macroexpand; macroexpand-1
	macrolet:	flet; labels; macrolet
	make-array:	make-array
	make-broadcast-stream:	make-broadcast-stream
	make-concatenated-stream:	make-concatenated-stream
	make-condition:	make-condition
	make-dispatch-macro-character:	make-dispatch-macro-character
	make-echo-stream:	make-echo-stream
	make-hash-table:	make-hash-table
	make-instance:	make-instance
	make-instances-obsolete:	make-instances-obsolete
	make-list:	make-list
	make-load-form:	make-load-form
	make-load-form-saving-slots:	make-load-form-saving-slots
	make-method:	call-method; make-method
	make-package:	make-package
	make-pathname:	make-pathname
	make-random-state:	make-random-state
	make-sequence:	make-sequence
	make-string:	make-string
	make-string-input-stream:	make-string-input-stream
	make-string-output-stream:	make-string-output-stream
	make-symbol:	make-symbol
	make-synonym-stream:	make-synonym-stream
	make-two-way-stream:	make-two-way-stream
	makunbound:	makunbound
	map:	map
	map-into:	map-into
	mapc:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	mapcan:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	mapcar:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	mapcon:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	maphash:	maphash
	mapl:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	maplist:	mapc; mapcar; mapcan; mapl; maplist; mapcon
	mask-field:	mask-field
	max:	max; min
	member:	member (Type Specifier)
	member:	member; member-if; member-if-not
	member-if:	member; member-if; member-if-not
	member-if-not:	member; member-if; member-if-not
	merge:	merge
	merge-pathnames:	merge-pathnames
	method:	method
	method-combination:	method-combination
	method-combination-error:	method-combination-error
	method-qualifiers:	method-qualifiers
	min:	max; min
	minusp:	minusp; plusp
	mismatch:	mismatch
	mod:	mod (Type Specifier)
	mod:	mod; rem
	most-negative-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-negative-fixnum:	most-positive-fixnum; most-negative-fixnum
	most-negative-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-negative-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-negative-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-positive-double-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-positive-fixnum:	most-positive-fixnum; most-negative-fixnum
	most-positive-long-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-positive-short-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	most-positive-single-float:	most-positive-short-float; least-positive-short-float; least-positive-n+
	muffle-warning:	muffle-warning (Restart)
	muffle-warning:	abort; continue; muffle-warning; store-value; use-value
	multiple-value-bind:	multiple-value-bind
	multiple-value-call:	multiple-value-call
	multiple-value-list:	multiple-value-list
	multiple-value-prog1:	multiple-value-prog1
	multiple-value-setq:	multiple-value-setq
	multiple-values-limit:	multiple-values-limit

N
	name-char:	name-char
	namestring:	namestring; file-namestring; directory-namestring; host-namestring; eno+
	nbutlast:	butlast; nbutlast
	nconc:	nconc
	next-method-p:	next-method-p
	nil:	nil (Type)
	nil:	nil (Constant Variable)
	nintersection:	intersection; nintersection
	ninth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	no-applicable-method:	no-applicable-method
	no-next-method:	no-next-method
	not:	not (Type Specifier)
	not:	not (Function)
	notany:	every; some; notevery; notany
	notevery:	every; some; notevery; notany
	notinline:	inline; notinline
	nreconc:	revappend; nreconc
	nreverse:	reverse; nreverse
	nset-difference:	set-difference; nset-difference
	nset-exclusive-or:	set-exclusive-or; nset-exclusive-or
	nstring-capitalize:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	nstring-downcase:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	nstring-upcase:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	nsublis:	sublis; nsublis
	nsubst:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	nsubst-if:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	nsubst-if-not:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	nsubstitute:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	nsubstitute-if:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	nsubstitute-if-not:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	nth:	nth
	nth-value:	nth-value
	nthcdr:	nthcdr
	null:	null (System Class)
	null:	null (Function)
	number:	number
	numberp:	numberp
	numerator:	numerator; denominator
	nunion:	union; nunion

O
	oddp:	evenp; oddp
	open:	open
	open-stream-p:	open-stream-p
	optimize:	optimize
	or:	or (Type Specifier)
	or:	or (Macro)
	output-stream-p:	input-stream-p; output-stream-p

P
	package:	package
	package-error:	package-error
	package-error-package:	package-error-package
	package-name:	package-name
	package-nicknames:	package-nicknames
	package-shadowing-symbols:	package-shadowing-symbols
	package-use-list:	package-use-list
	package-used-by-list:	package-used-by-list
	packagep:	packagep
	pairlis:	pairlis
	parse-error:	parse-error
	parse-integer:	parse-integer
	parse-namestring:	parse-namestring
	pathname:	pathname (System Class)
	pathname:	pathname (Function)
	pathname-device:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathname-directory:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathname-host:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathname-match-p:	pathname-match-p
	pathname-name:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathname-type:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathname-version:	pathname-host; pathname-device; pathname-directory; pathname-name; path+
	pathnamep:	pathnamep
	peek-char:	peek-char
	phase:	phase
	pi:	pi
	plusp:	minusp; plusp
	pop:	pop
	position:	position; position-if; position-if-not
	position-if:	position; position-if; position-if-not
	position-if-not:	position; position-if; position-if-not
	pprint:	write; prin1; print; pprint; princ
	pprint-dispatch:	pprint-dispatch
	pprint-exit-if-list-exhausted:	pprint-exit-if-list-exhausted
	pprint-fill:	pprint-fill; pprint-linear; pprint-tabular
	pprint-indent:	pprint-indent
	pprint-linear:	pprint-fill; pprint-linear; pprint-tabular
	pprint-logical-block:	pprint-logical-block
	pprint-newline:	pprint-newline
	pprint-pop:	pprint-pop
	pprint-tab:	pprint-tab
	pprint-tabular:	pprint-fill; pprint-linear; pprint-tabular
	prin1:	write; prin1; print; pprint; princ
	prin1-to-string:	write-to-string; prin1-to-string; princ-to-string
	princ:	write; prin1; print; pprint; princ
	princ-to-string:	write-to-string; prin1-to-string; princ-to-string
	print:	write; prin1; print; pprint; princ
	print-not-readable:	print-not-readable
	print-not-readable-object:	print-not-readable-object
	print-object:	print-object
	print-unreadable-object:	print-unreadable-object
	probe-file:	probe-file
	proclaim:	proclaim
	prog:	prog; prog*
	prog*:	prog; prog*
	prog1:	prog1; prog2
	prog2:	prog1; prog2
	progn:	progn
	program-error:	program-error
	progv:	progv
	provide:	provide; require
	psetf:	setf; psetf
	psetq:	psetq
	push:	push
	pushnew:	pushnew

Q
	quote:	quote

R
	random:	random
	random-state:	random-state
	random-state-p:	random-state-p
	rassoc:	rassoc; rassoc-if; rassoc-if-not
	rassoc-if:	rassoc; rassoc-if; rassoc-if-not
	rassoc-if-not:	rassoc; rassoc-if; rassoc-if-not
	ratio:	ratio
	rational:	rational (System Class)
	rational:	rational; rationalize
	rationalize:	rational; rationalize
	rationalp:	rationalp
	read:	read; read-preserving-whitespace
	read-byte:	read-byte
	read-char:	read-char
	read-char-no-hang:	read-char-no-hang
	read-delimited-list:	read-delimited-list
	read-from-string:	read-from-string
	read-line:	read-line
	read-preserving-whitespace:	read; read-preserving-whitespace
	read-sequence:	read-sequence
	reader-error:	reader-error
	readtable:	readtable
	readtable-case:	readtable-case
	readtablep:	readtablep
	real:	real
	realp:	realp
	realpart:	realpart; imagpart
	reduce:	reduce
	reinitialize-instance:	reinitialize-instance
	rem:	mod; rem
	remf:	remf
	remhash:	remhash
	remove:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	remove-duplicates:	remove-duplicates; delete-duplicates
	remove-if:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	remove-if-not:	remove; remove-if; remove-if-not; delete; delete-if; delete-if-not
	remove-method:	remove-method
	remprop:	remprop
	rename-file:	rename-file
	rename-package:	rename-package
	replace:	replace
	require:	provide; require
	rest:	rest
	restart:	restart
	restart-bind:	restart-bind
	restart-case:	restart-case
	restart-name:	restart-name
	return:	return
	return-from:	return-from
	revappend:	revappend; nreconc
	reverse:	reverse; nreverse
	room:	room
	rotatef:	rotatef
	round:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	row-major-aref:	row-major-aref
	rplaca:	rplaca; rplacd
	rplacd:	rplaca; rplacd

S
	satisfies:	satisfies
	sbit:	bit; sbit
	scale-float:	decode-float; scale-float; float-radix; float-sign; float-digits; float+
	schar:	char; schar
	search:	search
	second:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	sequence:	sequence
	serious-condition:	serious-condition
	set:	set
	set-difference:	set-difference; nset-difference
	set-dispatch-macro-character:	set-dispatch-macro-character; get-dispatch-macro-character
	set-exclusive-or:	set-exclusive-or; nset-exclusive-or
	set-macro-character:	set-macro-character; get-macro-character
	set-pprint-dispatch:	set-pprint-dispatch
	set-syntax-from-char:	set-syntax-from-char
	setf:	setf; psetf
	setq:	setq
	seventh:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	shadow:	shadow
	shadowing-import:	shadowing-import
	shared-initialize:	shared-initialize (Standard Generic Function)
	shiftf:	shiftf
	short-float:	short-float; single-float; double-float; long-float
	short-float-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	short-float-negative-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	short-site-name:	short-site-name; long-site-name
	signal:	signal
	signed-byte:	signed-byte
	signum:	signum
	simple-array:	simple-array
	simple-base-string:	simple-base-string
	simple-bit-vector:	simple-bit-vector
	simple-bit-vector-p:	simple-bit-vector-p
	simple-condition:	simple-condition
	simple-condition-format-arguments:	simple-condition-format-control; simple-condition-format-arguments
	simple-condition-format-control:	simple-condition-format-control; simple-condition-format-arguments
	simple-error:	simple-error
	simple-string:	simple-string
	simple-string-p:	simple-string-p
	simple-type-error:	simple-type-error
	simple-vector:	simple-vector
	simple-vector-p:	simple-vector-p
	simple-warning:	simple-warning
	sin:	sin; cos; tan
	single-float:	short-float; single-float; double-float; long-float
	single-float-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	single-float-negative-epsilon:	short-float-epsilon; short-float-negative-epsilon; single-float-epsilon+
	sinh:	sinh; cosh; tanh; asinh; acosh; atanh
	sixth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	sleep:	sleep
	slot-boundp:	slot-boundp
	slot-exists-p:	slot-exists-p
	slot-makunbound:	slot-makunbound
	slot-missing:	slot-missing
	slot-unbound:	slot-unbound
	slot-value:	slot-value
	software-type:	software-type; software-version
	software-version:	software-type; software-version
	some:	every; some; notevery; notany
	sort:	sort; stable-sort
	special:	special
	special-operator-p:	special-operator-p
	sqrt:	sqrt; isqrt
	stable-sort:	sort; stable-sort
	standard-char:	standard-char
	standard-char-p:	standard-char-p
	standard-class:	standard-class
	standard-generic-function:	standard-generic-function
	standard-method:	standard-method
	standard-object:	standard-object
	step:	step
	storage-condition:	storage-condition
	store-value:	store-value (Restart)
	store-value:	abort; continue; muffle-warning; store-value; use-value
	stream:	stream
	stream-element-type:	stream-element-type
	stream-error:	stream-error
	stream-error-stream:	stream-error-stream
	stream-external-format:	stream-external-format
	streamp:	streamp
	string:	string (System Class)
	string:	string (Function)
	string-capitalize:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	string-downcase:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	string-equal:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-greaterp:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-left-trim:	string-trim; string-left-trim; string-right-trim
	string-lessp:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-not-equal:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-not-greaterp:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-not-lessp:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string-right-trim:	string-trim; string-left-trim; string-right-trim
	string-stream:	string-stream
	string-trim:	string-trim; string-left-trim; string-right-trim
	string-upcase:	string-upcase; string-downcase; string-capitalize; nstring-upcase; nstr+
	string/=:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string<:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string<=:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string=:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string>:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	string>=:	string=; string/=; string<; string>; string<=; string>=; string-equal; +
	stringp:	stringp
	structure-class:	structure-class
	structure-object:	structure-object
	style-warning:	style-warning
	sublis:	sublis; nsublis
	subseq:	subseq
	subsetp:	subsetp
	subst:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	subst-if:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	subst-if-not:	subst; subst-if; subst-if-not; nsubst; nsubst-if; nsubst-if-not
	substitute:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	substitute-if:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	substitute-if-not:	substitute; substitute-if; substitute-if-not; nsubstitute; nsubstitute-+
	subtypep:	subtypep
	svref:	svref
	sxhash:	sxhash
	symbol:	symbol
	symbol-function:	symbol-function
	symbol-macrolet:	symbol-macrolet
	symbol-name:	symbol-name
	symbol-package:	symbol-package
	symbol-plist:	symbol-plist
	symbol-value:	symbol-value
	symbolp:	symbolp
	synonym-stream:	synonym-stream
	synonym-stream-symbol:	synonym-stream-symbol

T
	t:	t (System Class)
	t:	t (Constant Variable)
	tagbody:	tagbody
	tailp:	ldiff; tailp
	tan:	sin; cos; tan
	tanh:	sinh; cosh; tanh; asinh; acosh; atanh
	tenth:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	terpri:	terpri; fresh-line
	the:	the
	third:	first; second; third; fourth; fifth; sixth; seventh; eighth; ninth; ten+
	throw:	throw
	time:	time (Macro)
	trace:	trace; untrace
	translate-logical-pathname:	translate-logical-pathname
	translate-pathname:	translate-pathname
	tree-equal:	tree-equal
	truename:	truename
	truncate:	floor; ffloor; ceiling; fceiling; truncate; ftruncate; round; fround
	two-way-stream:	two-way-stream
	two-way-stream-input-stream:	two-way-stream-input-stream; two-way-stream-output-stream
	two-way-stream-output-stream:	two-way-stream-input-stream; two-way-stream-output-stream
	type:	type
	type-error:	type-error
	type-error-datum:	type-error-datum; type-error-expected-type
	type-error-expected-type:	type-error-datum; type-error-expected-type
	type-of:	type-of
	typecase:	typecase; ctypecase; etypecase
	typep:	typep

U
	unbound-slot:	unbound-slot
	unbound-slot-instance:	unbound-slot-instance
	unbound-variable:	unbound-variable
	undefined-function:	undefined-function
	unexport:	unexport
	unintern:	unintern
	union:	union; nunion
	unless:	when; unless
	unread-char:	unread-char
	unsigned-byte:	unsigned-byte
	untrace:	trace; untrace
	unuse-package:	unuse-package
	unwind-protect:	unwind-protect
	update-instance-for-different-class:	update-instance-for-different-class
	update-instance-for-redefined-class:	update-instance-for-redefined-class
	upgraded-array-element-type:	upgraded-array-element-type
	upgraded-complex-part-type:	upgraded-complex-part-type
	upper-case-p:	upper-case-p; lower-case-p; both-case-p
	use-package:	use-package
	use-value:	use-value (Restart)
	use-value:	abort; continue; muffle-warning; store-value; use-value
	user-homedir-pathname:	user-homedir-pathname

V
	values:	values (Type Specifier)
	values:	values (Accessor)
	values-list:	values-list
	vector:	vector (System Class)
	vector:	vector (Function)
	vector-pop:	vector-pop
	vector-push:	vector-push; vector-push-extend
	vector-push-extend:	vector-push; vector-push-extend
	vectorp:	vectorp

W
	warn:	warn
	warning:	warning
	when:	when; unless
	wild-pathname-p:	wild-pathname-p
	with-accessors:	with-accessors
	with-compilation-unit:	with-compilation-unit
	with-condition-restarts:	with-condition-restarts
	with-hash-table-iterator:	with-hash-table-iterator
	with-input-from-string:	with-input-from-string
	with-open-file:	with-open-file
	with-open-stream:	with-open-stream
	with-output-to-string:	with-output-to-string
	with-package-iterator:	with-package-iterator
	with-simple-restart:	with-simple-restart
	with-slots:	with-slots
	with-standard-io-syntax:	with-standard-io-syntax
	write:	write; prin1; print; pprint; princ
	write-byte:	write-byte
	write-char:	write-char
	write-line:	write-string; write-line
	write-sequence:	write-sequence
	write-string:	write-string; write-line
	write-to-string:	write-to-string; prin1-to-string; princ-to-string

Y
	y-or-n-p:	y-or-n-p; yes-or-no-p
	yes-or-no-p:	y-or-n-p; yes-or-no-p

Z
	zerop:	zerop

Jump to:	( * + - / 1 < = > A B C D E F G H I K L M N O P Q R S T U V W Y Z