OKI ISLisp ֐ꗗ (234)*g܂

֐: BASIC-ARRAY-P
dl: (BASIC-ARRAY-P OBJ) ---> BOOLEAN
: obj z܂͕, xN^ ǂ`FbN

֐: BASIC-ARRAY*-P
dl: (BASIC-ARRAY*-P OBJ) ---> BOOLEAN
: obj zł邩`FbN

֐: GENERAL-ARRAY*-P
dl: (GENERAL-ARRAY*-P OBJ) ---> BOOLEAN
: obj zł邩`FbN

֐: CREATE-ARRAY
dl: (CREATE-ARRAY DIMENSIONS INITIAL-ELEMENT +) ---> <BASIC-ARRAY>
: z𐶐

֐: AREF
dl: (AREF BASIC-ARRAY Z *) ---> <OBJECT>
: z basic-array  z Ԗڂ̗vfo

֐: GAREF
dl: (GAREF GENERAL-ARRAY Z *) ---> <OBJECT>
: z general-array  z Ԗڂ̗vfo

֐: SET-AREF
dl: (SET-AREF OBJ BASIC-ARRAY Z *) ---> <OBJECT>
: z basic-array  z Ԗڂɗvf obj Zbg

֐: SET-GAREF
dl: (SET-GAREF OBJ GENERAL-ARRAY Z *) ---> <OBJECT>
: z general-array  z Ԗڂɗvf obj Zbg

֐: ARRAY-DIMENSIONS
dl: (ARRAY-DIMENSIONS BASIC-ARRAY) ---> <LIST>
: z basic-array ̎XgŕԂ

֐: CHARACTERP
dl: (CHARACTERP OBJ) ---> BOOLEAN
: obj ł邩`FbN

֐: CHAR=
dl: (CHAR= CHAR1 CHAR2) ---> BOOLEAN
: char1  char2 ̕`FbN

֐: CHAR/=
dl: (CHAR/= CHAR1 CHAR2) ---> BOOLEAN
: char1  char2 ̕Ȃ`FbN

֐: CHAR<
dl: (CHAR< CHAR1 CHAR2) ---> BOOLEAN
: char1 ̕R[h char2 傫`FbN

֐: CHAR>
dl: (CHAR> CHAR1 CHAR2) ---> BOOLEAN
: char1 ̕R[h char2 `FbN

֐: CHAR<=
dl: (CHAR<= CHAR1 CHAR2) ---> BOOLEAN
: char1 ̕R[h char2 傫܂͓`FbN

֐: CHAR>=
dl: (CHAR>= CHAR1 CHAR2) ---> BOOLEAN
: char1 ̕R[h char2 ܂͓`FbN

֐: ERROR
dl: (ERROR ERROR-STRING OBJ *) ---> <OBJECT>
: G[VOi

֐: CERROR
dl: (CERROR CONTINUE-STRING ERROR-STRING OBJ *) ---> <OBJECT>
: p\ȃG[VOi

֐: SIGNAL-CONDITION
dl: (SIGNAL-CONDITION CONDITION CONTINUABLE) ---> <OBJECT>
: RfBV𑀍삷邽߂ɃVOi

֐: IGNORE-ERRORS
dl: (IGNORE-ERRORS FORM *) ---> <OBJECT>
: G[oĂ(`)

֐: REPORT-CONDITION
dl: (REPORT-CONDITION CONDITION STREAM) ---> <CONDITION>
: RfBV condition Xg[ stream Ƀ|[g

֐: CONDITION-CONTINUABLE
dl: (CONDITION-CONTINUABLE CONDITION) ---> <OBJECT>
: p\`FbN

֐: CONTINUE-CONDITION
dl: (CONTINUE-CONDITION CONDITION VALUE +) ---> <OBJECT>
: RfBVp

֐: WITH-HANDLER
dl: (WITH-HANDLER HANDLER FORM *) ---> <OBJECT>
: nh]ătH[s(`)

֐: ARITHMETIC-ERROR-OPERATION
dl: (ARITHMETIC-ERROR-OPERATION ARITHMETIC-ERROR) ---> <FUNCTION>
: ZpZG[̃Iy[^Ԃ

֐: ARITHMETIC-ERROR-OPERANDS
dl: (ARITHMETIC-ERROR-OPERANDS ARITHMETIC-ERROR) ---> <LIST>
: ZpZG[̃IyhԂ

֐: DOMAIN-ERROR-OBJECT
dl: (DOMAIN-ERROR-OBJECT DOMAIN-ERROR) ---> <OBJECT>
: hCG[ domain-error ŐꂽIuWFNgԂ

֐: DOMAIN-ERROR-EXPECTED-CLASS
dl: (DOMAIN-ERROR-EXPECTED-CLASS DOMAIN-ERROR) ---> <CLASS>@
: hCG[ domain-error Őꂽ]܂hCԂ

֐: PARSE-ERROR-STRING
dl: (PARSE-ERROR-STRING PARSE-ERROR) ---> <STRING>
: ̓G[ parse-error ŐꂽԂ

֐: PARSE-ERROR-EXPECTED-CLASS
dl: (PARSE-ERROR-EXPECTED-CLASS PARSE-ERROR) ---> <CLASS>
: ̓G[ parse-error Őꂽ]܂NXԂ

֐: SIMPLE-ERROR-FORMAT-STRING
dl: (SIMPLE-ERROR-FORMAT-STRING SIMPLE-ERROR) ---> <STRING>
: simple-error ŐꂽԂ

֐: SIMPLE-ERROR-FORMAT-ARGUMENTS
dl: (SIMPLE-ERROR-FORMAT-ARGUMENTS SIMPLE-ERROR) ---> <LIST>
: simple-error ŐꂽXgԂ

֐: STREAM-ERROR-STREAM
dl: (STREAM-ERROR-STREAM STREAM-ERROR) ---> <STREAM>
: Xg[G[ stream-error ŐꂽXg[Ԃ

֐: UNDEFINED-ENTITY-NAME
dl: (UNDEFINED-ENTITY-NAME UNDEFINED-ENTITY) ---> <SYMBOL>
: `GeBeB undefined-entity ŐꂽV{Ԃ

֐: UNDEFINED-ENTITY-NAMESPACE
dl: (UNDEFINED-ENTITY-NAMESPACE UNDEFINED-ENTITY) ---> <SYMBOL>
: `GeBeB undefined-entity ŐꂽOԂԂ

֐: QUOTE
dl: (QUOTE OBJ) ---> <OBJECT>
: obj ̎QƂԂ(`)

֐: SETQ
dl: (SETQ VAR FORM) ---> <OBJECT>
: ϐ var ɃtH[ form ̕]ʂ(`)

֐: SETF
dl: (SETF PLACE FORM) ---> <OBJECT>
: ꏊ place ɃtH[ form ̕]ʂ(`)

֐: LET
dl: (LET ((VAR FORM) *) BODY-FORM *) ---> <OBJECT>
: Ǐϐ`ÅŎs(`)

֐: LET*
dl: (LET* ((VAR FORM) *) BODY-FORM *) ---> <OBJECT>
: letƓlł邪ǏϐƂ낪قȂ(`)

֐: DYNAMIC
dl: (DYNAMIC VAR) ---> <OBJECT>
: Iϐ錾(`)

֐: SETF
dl: (SETF (DYNAMIC VAR) FORM) ---> <OBJECT>
: Iϐɒl(`)

֐: DYNAMIC-LET
dl: (DYNAMIC-LET ((VAR FORM) *) BODY-FORM *) ---> <OBJECT>
: Iϐ̈ꎞI(`)

֐: IF
dl: (IF TEST-FORM THEN-FORM ELSE-FORM+) ---> <OBJECT>
: ̌ʂŕ򂷂(`)

֐: COND
dl: (COND (TEST FORM *) *) ---> <OBJECT>
: ̌ʂŕ򂷂(`)

֐: CASE
dl: (CASE KEYFORM ((KEY *) FORM *) * (T FORM *) +) ---> <OBJECT>
: keyform ̒lɂđɕ򂷂(`)

֐: CASE-USING
dl: (CASE-USING PREDFORM KEYFORM ((KEY *) FORM *) * (T FORM *) +) ---> <OBJECT>
: case Ƃقړlł邪,q֐ predform rɎg(`)

֐: PROGN
dl: (PROGN FORM*) ---> <OBJECT>
: ssȂ(`)

֐: WHILE
dl: (WHILE TEST-FORM BODY-FORM *) ---> <NULL>
: test-form  nil łȂ body-form s(`)

֐: FOR
dl: (FOR (ITERATION-SPEC *) (END-TEST RESULT *) FORM *) ---> <OBJECT>
: iteration-spec ŎꂽlƃXebpp end-test  nil łȂԌJԂs(`)

֐: BLOCK
dl: (BLOCK NAME FORM *) ---> <OBJECT>
: ubN^Otďs(`)

֐: RETURN-FROM
dl: (RETURN-FROM NAME RESULT-FORM) ---> TRANSFERS-CONTROL-AND-DATA
: name ubN𔲂(`)

֐: CATCH
dl: (CATCH TAG-FORM FORM *) ---> <OBJECT>
: tag-form Lb`Aform s(`)

֐: THROW
dl: (THROW TAG-FORM RESULT-FORM) ---> TRANSFERS-CONTROL-AND-DATA
: tag-form X[(`)

֐: TAGBODY
dl: (TAGBODY TAGBODY-TAG * FORM *) ---> <OBJECT>
: tagbody-tagtďs(`)

֐: GO
dl: (GO TAGBODY-TAG) ---> TRANSFERS-CONTROL
: tag-bodyubNɐڂ(`)

֐: UNWIND-PROTECT
dl: (UNWIND-PROTECT FORM CLEANUP-FORM *) ---> <OBJECT>
: form̕]IƂ͕K cleanup-form s(`)

֐: THE
dl: (THE CLASS-NAME FORM) ---> <OBJECT>
: form ̎sʂ̃NX class-name Ɛ錾(`)

֐: ASSURE
dl: (ASSURE CLASS-NAME FORM) ---> <OBJECT>
: form ̎sʂ̃NX class-name Ǝ咣AقȂꍇ̓G[ƂȂ(`)

֐: CONVERT
dl: (CONVERT OBJ CLASS-NAME) ---> <OBJECT>
: obj NX class-name ɕϊ(`)

֐: PROBE-FILE
dl: (PROBE-FILE FILENAME) ---> BOOLEAN@
: filename ̃t@C݂邩`FbN

֐: FILE-POSITION
dl: (FILE-POSITION STREAM) ---> <INTEGER>
: stream ݂̌̃t@CʒuԂ

֐: SET-FILE-POSITION
dl: (SET-FILE-POSITION STREAM Z) ---> <INTEGER>
:  stream ̃t@Cʒu z ɐݒ肷

֐: FILE-LENGTH
dl: (FILE-LENGTH FILENAME ELEMENT-CLASS) ---> <INTEGER>
: filename ̃t@C element-class ̃t@CƂẴTCYԂ

֐: FUNCTIONP
dl: (FUNCTIONP OBJ) ---> BOOLEAN
: obj ֐ł邩`FbN

֐: FUNCTION
dl: (FUNCTION FUNCTION-NAME) ---> <FUNCTION>
: function-name 𖼑OƂ֐Ԃ(`)

֐: LAMBDA
dl: (LAMBDA LAMBDA-LIST FORM *) ---> <FUNCTION>
: _𐶐(`)

֐: LABELS
dl: (LABELS ((FUNCTION-NAME LAMBDA-LIST FORM *) *) BODY-FORMS *) ---> <OBJECT>
: Ǐ֐̑AiċAI`\jł_ flet ƈقȂ(`)

֐: FLET
dl: (FLET ((FUNCTION-NAME LAMBDA-LIST FORM *) *) BODY-FORMS *) ---> <OBJECT>
: Ǐ֐̑(`)

֐: APPLY
dl: (APPLY FUNCTION OBJ * LIST) ---> <OBJECT>
: ֐Kp

֐: FUNCALL
dl: (FUNCALL FUNCTION OBJ *) ---> <OBJECT>
: ֐Ăяo

֐: DEFCONSTANT
dl: (DEFCONSTANT NAME FORM) ---> <SYMBOL>
: 萔錾(`)

֐: DEFGLOBAL
dl: (DEFGLOBAL NAME FORM) ---> <SYMBOL>
: Lϐ錾(`)

֐: DEFDYNAMIC
dl: (DEFDYNAMIC NAME FORM) ---> <SYMBOL>
: Iϐ錾(`)

֐: DEFUN
dl: (DEFUN FUNCTION-NAME LAMBDA-LIST FORM *) ---> <SYMBOL>
: ֐`(`)

֐: READ
dl: (READ INPUT-STREAM + EOS-ERROR-P + EOS-VALUE +) ---> <OBJECT>
: input-stream SƂēǂ

֐: READ-CHAR
dl: (READ-CHAR INPUT-STREAM + EOS-ERROR-P + EOS-VALUE +) ---> <OBJECT>
: input-stream 1ǂ

֐: PREVIEW-CHAR
dl: (PREVIEW-CHAR INPUT-STREAM + EOS-ERROR-P + EOS-VALUE +) ---> <OBJECT>
: ɓǂݍޕԂi1ǂ݁Bt@C|WV͕ωȂj

֐: READ-LINE
dl: (READ-LINE INPUT-STREAM + EOS-ERROR-P + EOS-VALUE +) ---> <OBJECT>
: 1s𕶎Ƃēǂ

֐: STREAM-READY-P
dl: (STREAM-READY-P INPUT-STREAM) ---> BOOLEAN
: Xg[ǂݍ݉\ɂȂĂ邩

֐: FORMAT
dl: (FORMAT OUTPUT-STREAM FORMAT-STRING OBJ *) ---> <NULL>
: format-string ɏ] obj o͂

֐: FORMAT-CHAR
dl: (FORMAT-CHAR OUTPUT-STREAM CHAR) ---> <NULL>
: 1o͂

֐: FORMAT-FLOAT
dl: (FORMAT-FLOAT OUTPUT-STREAM FLOAT) ---> <NULL>
: _Ƃďo͂

֐: FORMAT-FRESH-LINE
dl: (FORMAT-FRESH-LINE OUTPUT-STREAM) ---> <NULL>
: s

֐: FORMAT-INTEGER
dl: (FORMAT-INTEGER OUTPUT-STREAM INTEGER RADIX) ---> <NULL>
: Ƃďo͂

֐: FORMAT-OBJECT
dl: (FORMAT-OBJECT OUTPUT-STREAM OBJ ESCAPE-P) ---> <NULL>
: IuWFNgƂďo͂

֐: FORMAT-TAB
dl: (FORMAT-TAB OUTPUT-STREAM COLUMN) ---> <NULL>
: ^uo͂

֐: READ-BYTE
dl: (READ-BYTE INPUT-STREAM EOS-ERROR-P + EOS-VALUE +) ---> <INTEGER>
: oCgƂēǂ

֐: WRITE-BYTE
dl: (WRITE-BYTE Z OUTPUT-STREAM) ---> <INTEGER>
: oCgƂď

֐: CONSP
dl: (CONSP OBJ) ---> BOOLEAN
: RX`FbN

֐: CONS
dl: (CONS OBJ1 OBJ2) ---> <CONS>
: RX𐶐

֐: CAR
dl: (CAR CONS) ---> <OBJECT>
: RX Car o

֐: CDR
dl: (CDR CONS) ---> <OBJECT>
: RX Cdr o

֐: SET-CAR
dl: (SET-CAR OBJ CONS) ---> <OBJECT>
: RX Car ɃZbg

֐: SET-CDR
dl: (SET-CDR OBJ CONS) ---> <OBJECT>
: RX Cdr ɃZbg

֐: NULL
dl: (NULL OBJ) ---> BOOLEAN
: NULL `FbN

֐: LISTP
dl: (LISTP OBJ) ---> BOOLEAN
: Xg`FbN

֐: CREATE-LIST
dl: (CREATE-LIST I INITIAL-ELEMENT +) ---> <LIST>
:  i l initial-element ̃Xg𐶐

֐: LIST
dl: (LIST OBJ *) ---> <LIST>
: obj vfƂ郊Xg𐶐

֐: REVERSE
dl: (REVERSE LIST) ---> <LIST>
: XgtɂĩXg͔j󂵂Ȃj

֐: NREVERSE
dl: (NREVERSE LIST) ---> <LIST>
: XgtɂĩXg͔j󂳂j

֐: APPEND
dl: (APPEND LIST *) ---> <LIST>
: XgA

֐: MEMBER
dl: (MEMBER OBJ LIST) ---> <LIST>
: Xg list  obj ܂܂Ă΁Aobj 擪Ƃ镔XgԂ

֐: MAPCAR
dl: (MAPCAR FUNCTION LIST +) ---> <LIST>
: Xg list ̗vfɊ֐ function sʂ̃XgԂ

֐: MAPC
dl: (MAPC FUNCTION LIST +) ---> <LIST>
: Xg list ̗vfɊ֐ function s̃Xg list Ԃ

֐: MAPCAN
dl: (MAPCAN FUNCTION LIST +) ---> <LIST>
: MAPCAR ̑ list j󂵂čsȂ

֐: MAPLIST
dl: (MAPLIST FUNCTION LIST +) ---> <LIST>
: Xg list ̕XgɊ֐ function sAʂ̃XgԂ

֐: MAPL
dl: (MAPL FUNCTION LIST +) ---> <LIST>
: Xg list ̕XgɊ֐ function sAXg list Ԃ

֐: MAPCON
dl: (MAPCON FUNCTION LIST +) ---> <LIST>
: MAPLIST ̑ list j󂵂čsȂ

֐: ASSOC
dl: (ASSOC OBJ ASSOCIATION-LIST) ---> <CONS>
: AzXg association-list ɑ΂ obj L[ƂlԂ

֐: DEFMACRO
dl: (DEFMACRO MACRO-NAME LAMBDA-LIST FORM *) ---> <SYMBOL>
: }N`(`)

֐: IDENTITY
dl: (IDENTITY OBJ) ---> <OBJECT>@
: obj ̂܂ܕԂ

֐: GET-UNIVERSAL-TIME
dl: (GET-UNIVERSAL-TIME) ---> <INTEGER>
: jo[T^CibjԂ

֐: GET-INTERNAL-RUN-TIME
dl: (GET-INTERNAL-RUN-TIME) ---> <INTEGER>
: sԂԂ

֐: GET-INTERNAL-REAL-TIME
dl: (GET-INTERNAL-REAL-TIME) ---> <INTEGER>
: oߎԂԂ

֐: INTERNAL-TIME-UNITS-PER-SECOND
dl: (INTERNAL-TIME-UNITS-PER-SECOND) ---> <INTEGER>
: 1b̃C^[i^CPʂԂ

֐: NUMBERP
dl: (NUMBERP OBJ) ---> BOOLEAN
: obj ^ł邩`FbN

֐: PARSE-NUMBER
dl: (PARSE-NUMBER STRING) ---> <NUMBER>
:  string ͂Đ^ɕϊ

֐: =
dl: (= X1 X2) ---> BOOLEAN
: l`FbN

֐: /=
dl: (/= X1 X2) ---> BOOLEAN
: lȂ`FbN

֐: >=
dl: (>= X1 X2) ---> BOOLEAN
: l x1  x2 ȏł邩`FbN

֐: <=
dl: (<= X1 X2) ---> BOOLEAN
: l x1  x2 ȉł邩`FbN

֐: >
dl: (> X1 X2) ---> BOOLEAN
: l x1  x2 傫`FbN

֐: <
dl: (< X1 X2) ---> BOOLEAN
: l x1  x2 菬`FbN

֐: +
dl: (+ X *) ---> <NUMBER>
: lZ

֐: *
dl: (* X *) ---> <NUMBER>
: lZ

֐: -
dl: (- X Y *) ---> <NUMBER>
: lZ

֐: QUOTIENT
dl: (QUOTIENT DIVIDEND DIVISOR +) ---> <NUMBER>
: lZ

֐: RECIPROCAL
dl: (RECIPROCAL X) ---> <NUMBER>
: ltɂ

֐: MAX
dl: (MAX X Y *) ---> <NUMBER>
: l̍őlԂ

֐: MIN
dl: (MIN X Y *) ---> <NUMBER>
: l̍ŏlԂ

֐: ABS
dl: (ABS X) ---> <NUMBER>
: l̐ΒlԂ

֐: EXP
dl: (EXP X) ---> <NUMBER>
: l̎w֐̒lԂ

֐: LOG
dl: (LOG X) ---> <NUMBER>
: l̎Rΐ̒lԂ

֐: EXPT
dl: (EXPT X1 X2) ---> <NUMBER>
: lׂ悷

֐: SQRT
dl: (SQRT X) ---> <NUMBER>
: l̕Ԃ

֐: SIN
dl: (SIN X) ---> <NUMBER>
: l sin ֐̒lԂ

֐: COS
dl: (COS X) ---> <NUMBER>
: l cos ֐̒lԂ

֐: TAN
dl: (TAN X) ---> <NUMBER>
: l tan ֐̒lԂ

֐: ATAN
dl: (ATAN X) ---> <NUMBER>
: l atan ֐̒lԂ

֐: ATAN2
dl: (ATAN2 X1 X2) ---> <NUMBER>
: l atan2 ֐̒lԂ

֐: SINH
dl: (SINH X) ---> <NUMBER>
: l sinh ֐̒lԂ

֐: COSH
dl: (COSH X) ---> <NUMBER>
: l cosh ֐̒lԂ

֐: TANH
dl: (TANH X) ---> <NUMBER>
: l tanh ֐̒lԂ

֐: ATANH
dl: (ATANH X) ---> <NUMBER>
: l atanh ֐̒lԂ

֐: FLOATP
dl: (FLOATP OBJ) ---> BOOLEAN
: obj _ł邩`FbN

֐: FLOAT
dl: (FLOAT X) ---> <FLOAT>
: ^ x 𕂓_ɕϊ

֐: FLOOR
dl: (FLOOR X) ---> <INTEGER>
: ؂艺sȂ

֐: CEILING
dl: (CEILING X) ---> <INTEGER>
: ؂グsȂ

֐: TRUNCATE
dl: (TRUNCATE X) ---> <INTEGER>
: 0Ɋۂ߂

֐: ROUND
dl: (ROUND X) ---> <INTEGER>
: ľܓsȂ

֐: INTEGERP
dl: (INTEGERP OBJ) ---> BOOLEAN
: obj ł邩`FbN

֐: DIV
dl: (DIV Z1 Z2) ---> <INTEGER>
: l𐮐Z

֐: MOD
dl: (MOD Z1 Z2) ---> <INTEGER>
: l]vZ

֐: GCD
dl: (GCD Z1 Z2) ---> <INTEGER>
: ő񐔂Ԃ

֐: LCM
dl: (LCM Z1 Z2) ---> <INTEGER>
: ŏ{Ԃ

֐: ISQRT
dl: (ISQRT Z) ---> <INTEGER>
: Ԃ

֐: DEFCLASS
dl: (DEFCLASS CLASS-NAME (SC-NAME *) (SLOT-SPEC *) CLASS-OPT *) ---> <SYMBOL>
: NX`sȂ(`)

֐: GENERIC-FUNCTION-P
dl: (GENERIC-FUNCTION-P OBJ) ---> BOOLEAN
: obj ֐ł邩`FbN

֐: DEFGENERIC
dl: (DEFGENERIC FUNC-SPEC LAMBDA-LIST OPTION * METHOD-DESC *) ---> <SYMBOL>
: ֐`(`)

֐: DEFMETHOD
dl: (DEFMETHOD FUNC-SPEC METHOD-QUALIFIER * PARAMETER-PROFILE FORM *) ---> <SYMBOL>
: \bh֐`(`)

֐: CALL-NEXT-METHOD
dl: (CALL-NEXT-METHOD) ---> <OBJECT>
: NXD揇ʂ̎̃NX̃\bhĂяo(`)

֐: NEXT-METHOD-P
dl: (NEXT-METHOD-P) ---> BOOLEAN
: ̃\bh݂邩`FbN(`)

֐: CREATE
dl: (CREATE CLASS INITARG * INITVAL *) ---> <OBJECT>
: CX^XIuWFNg𐶐(֐)

֐: INITIALIZE-OBJECT
dl: (INITIALIZE-OBJECT INSTANCE INITIALIZATION-LIST) ---> <OBJECT>
: IuWFNg̏sȂ

֐: CLASS-OF
dl: (CLASS-OF OBJ) ---> <CLASS>
: NXԂ

֐: INSTANCEP
dl: (INSTANCEP OBJ CLASS) ---> BOOLEAN
: CX^XIuWFNgł邩`FbN

֐: SUBCLASSP
dl: (SUBCLASSP CLASS1 CLASS2) ---> BOOLEAN
: TuNXł邩`FbN

֐: CLASS
dl: (CLASS CLASS-NAME) ---> <CLASS>
: O class-name ̃NXԂ(`)

֐: EQ
dl: (EQ OBJ1 OBJ2) ---> BOOLEAN
: obj1  obj2  eq ł邩`FbN

֐: EQL
dl: (EQL OBJ1 OBJ2) ---> BOOLEAN
: obj1  obj2  eql ł邩`FbN

֐: EQUAL
dl: (EQUAL OBJ1 OBJ2) ---> BOOLEAN
: obj1  obj2  equal ł邩`FbN

֐: NOT
dl: (NOT OBJ) ---> BOOLEAN
: obj ̔ےԂ

֐: AND
dl: (AND FORM *) ---> <OBJECT>
: form  AND (`)

֐: OR
dl: (OR FORM *) ---> <OBJECT>
: form  OR (`)

֐: LENGTH
dl: (LENGTH SEQUENCE) ---> <INTEGER>
:  sequence ̒Ԃ

֐: ELT
dl: (ELT SEQUENCE Z) ---> <OBJECT>
:  sequence  z Ԗڂ̗vfԂ

֐: SET-ELT
dl: (SET-ELT OBJ SEQUENCE Z) ---> <OBJECT>
:  sequence  z Ԗڂ obj Zbg

֐: SUBSEQ
dl: (SUBSEQ SEQUENCE Z1 Z2) ---> SEQUENCE
:  sequence  z1 Ԗڂ z2 Ԗڂ̕o

֐: MAP-INTO
dl: (MAP-INTO DESTINATION FUNCTION SEQ *) ---> SEQUENCE
:  sequence ̗vfɊ֐ function KpāǍʂ destination Ɋi[

֐: STREAMP
dl: (STREAMP OBJ) ---> BOOLEAN
: obj Xg[ł邩`FbN

֐: OPEN-STREAM-P
dl: (OPEN-STREAM-P OBJ) ---> BOOLEAN
: obj I[vꂽXg[ł邩`FbN

֐: INPUT-STREAM-P
dl: (INPUT-STREAM-P OBJ) ---> BOOLEAN
: obj ̓Xg[ł邩`FbN

֐: OUTPUT-STREAM-P
dl: (OUTPUT-STREAM-P OBJ) ---> BOOLEAN
: obj o̓Xg[ł邩`FbN

֐: STANDARD-INPUT
dl: (STANDARD-INPUT) ---> <STREAM>
: W͂Ԃ

֐: STANDARD-OUTPUT
dl: (STANDARD-OUTPUT) ---> <STREAM>
: Wo͂Ԃ

֐: ERROR-OUTPUT
dl: (ERROR-OUTPUT) ---> <STREAM>
: G[o͂Ԃ

֐: WITH-STANDARD-INPUT
dl: (WITH-STANDARD-INPUT STREAM-FORM FORM *) ---> <OBJECT>
: W͂ stream-form ̎sʂɂ form s(`)

֐: WITH-STANDARD-OUTPUT
dl: (WITH-STANDARD-OUTPUT STREAM-FORM FORM *) ---> <OBJECT>
: Wo͂ stream-form ̎sʂɂ form s(`)

֐: WITH-ERROR-OUTPUT
dl: (WITH-ERROR-OUTPUT STREAM-FORM FORM *) ---> <OBJECT>
: G[o͂ stream-form ̎sʂɂ form s(`)

֐: OPEN-INPUT-FILE
dl: (OPEN-INPUT-FILE FILENAME ELEMENT-CLASS +) ---> <STREAM>
: t@C filename ̃t@C̓Xg[ƂăI[v

֐: OPEN-OUTPUT-FILE
dl: (OPEN-OUTPUT-FILE FILENAME ELEMENT-CLASS +) ---> <STREAM>
: t@C filename ̃t@Co̓Xg[ƂăI[v

֐: OPEN-IO-FILE
dl: (OPEN-IO-FILE FILENAME ELEMENT-CLASS +) ---> <STREAM>
: t@C filename ̃t@Co̓Xg[ƂăI[v

֐: WITH-OPEN-INPUT-FILE
dl: (WITH-OPEN-INPUT-FILE (NAME FILE ELEMENT-CLASS +) FORM *) ---> <OBJECT>
: t@C file ̃t@C̓Xg[ƂăI[v form sAsN[Yi`j

֐: WITH-OPEN-OUTPUT-FILE
dl: (WITH-OPEN-OUTPUT-FILE (NAME FILE ELEMENT-CLASS +) FORM *) ---> <OBJECT>
: t@C file ̃t@Co̓Xg[ƂăI[v form sAsN[Yi`j

֐: WITH-OPEN-IO-FILE
dl: (WITH-OPEN-IO-FILE (NAME FILE ELEMENT-CLASS +) FORM *) ---> <OBJECT>
: t@C file ̃t@Co̓Xg[ƂăI[v form sAsN[Yi`j

֐: CLOSE
dl: (CLOSE STREAM) ---> IMPLEMENTATION-DEFINED
: Xg[N[Y

֐: CREATE-STRING-INPUT-STREAM
dl: (CREATE-STRING-INPUT-STREAM STRING) ---> <STREAM>
: ͂̕Xg[𐶐

֐: CREATE-STRING-OUTPUT-STREAM
dl: (CREATE-STRING-OUTPUT-STREAM) ---> <STREAM>
: o͂̕Xg[𐶐

֐: GET-OUTPUT-STREAM-STRING
dl: (GET-OUTPUT-STREAM-STRING STREAM) ---> <STRING>
: o̓Xg[ɏo͂ꂽԂ

֐: STRINGP
dl: (STRINGP OBJ) ---> BOOLEAN
: obj ł邩`FbN

֐: CREATE-STRING
dl: (CREATE-STRING I INITIAL-ELEMENT+) ---> <STRING>
:  i l initial-element ̕𐶐

֐: STRING=
dl: (STRING= STRING1 STRING2) ---> QUASI-BOOLEAN
: 񂪓`FbN

֐: STRING/=
dl: (STRING/= STRING1 STRING2) ---> QUASI-BOOLEAN
: 񂪓Ȃ`FbN

֐: STRING<
dl: (STRING< STRING1 STRING2) ---> QUASI-BOOLEAN
:  sting1  string2 `FbN

֐: STRING>
dl: (STRING> STRING1 STRING2) ---> QUASI-BOOLEAN
:  sting1  string2 傫`FbN

֐: STRING>=
dl: (STRING>= STRING1 STRING2) ---> QUASI-BOOLEAN
:  sting1  string2 ȉ`FbN

֐: STRING<=
dl: (STRING<= STRING1 STRING2) ---> QUASI-BOOLEAN
:  sting1  string2 ȏォ`FbN

֐: CHAR-INDEX
dl: (CHAR-INDEX CHARACTER STRING START-POSITION +) ---> <OBJECT>
:  string ɕ character ʒuԂ

֐: STRING-INDEX
dl: (STRING-INDEX SUBSTRING STRING START-POSITION +) ---> <OBJECT>
:  string ɕ substring ʒuԂ

֐: STRING-APPEND
dl: (STRING-APPEND STRING *) ---> <STRING>
: A

֐: SYMBOLP
dl: (SYMBOLP OBJ) ---> BOOLEAN
: V{`FbN

֐: PROPERTY
dl: (PROPERTY SYMBOL PROPERTY-NAME OBJ +) ---> <OBJECT>
: V{̃vpeBo

֐: SET-PROPERTY
dl: (SET-PROPERTY OBJ SYMBOL PROPERTY-NAME) ---> <OBJECT>
: V{ɃvpeBZbg

֐: REMOVE-PROPERTY
dl: (REMOVE-PROPERTY SYMBOL PROPERTY-NAME) ---> <OBJECT>
: V{vpeB폜

֐: GENSYM
dl: (GENSYM) ---> <SYMBOL>
: OȂV{𐶐

֐: BASIC-VECTOR-P
dl: (BASIC-VECTOR-P OBJ) ---> BOOLEAN
: BASIC xN^`FbN

֐: GENERAL-VECTOR-P
dl: (GENERAL-VECTOR-P OBJ) ---> BOOLEAN
: GENERIC VECTOR`FbN

֐: CREATE-VECTOR
dl: (CREATE-VECTOR I INITIAL-ELEMENT +) ---> <GENERAL-VECTOR>
: vf i l initial-element ̃xN^𐶐

֐: VECTOR
dl: (VECTOR OBJ *) ---> <GENERAL-VECTOR>
: obj ... vfƂxN^𐶐

֐: LOAD
dl: (LOAD FILE) ---> T
: t@C file [higj

֐: TIME
dl: (TIME FORM) ---> <OBJECT>
: tH[ form soߎԂ\i`jigj

֐: ROOM
dl: (ROOM) ---> <NULL>
: ݂̃gp󋵂\igj

֐: EVAL
dl: (EVAL FORM) ---> <OBJECT>
: tH[ form ]igj

֐: LIST*
dl: (LIST* OBJ *) ---> <LIST>
: ֐ list Ƃقړł邪Ō̈Ō̃RX CDR Ɋi[igj

֐: APPEND*
dl: (APPEND* OBJ *) ---> <LIST>
: ֐ append Ƃقړł邪Ō̈Ō̃RX CDR Ɋi[igj

֐: NTH
dl: (NTH N LIST) ---> <OBJECT>
: list  n Ԗڂ̗vfԂigj

֐: COMPILE
dl: (COMPILE FUN) ---> BOOLEAN
: ֐ fun RpC(g)

֐: COMPILE-FILE
dl: (COMPILE-FILE FILE) ---> BOOLEAN
: t@C file RpC(g)

֐: COMPILE-FILES
dl: (COMPILE-FILES DST-FNAME SRC-FNAME *) ---> BOOLEAN
: src-fname ̃̕t@C dst-fname ̃t@CɃRpC(g)

֐: DESCIBE
dl: (DESCIBE OBJ) ---> IDEF
: obj ̓e\igj

֐: GC
dl: (GC) ---> <NULL>
: gc IɎs (g)

֐: WRITE
dl: (WRITE OBJECT STREAM +) ---> <NULL>
: object  stream ɕ\(g)

֐: QUIT
dl: (QUIT) ---> TRANSFERS-CONTROL
: ISLispnI(g)

