Interlisp-10 Specifics (found and deleted throughout the Interlisp Reference Manual)
========

{FnDef {FnName APROPOS} {FnArgs STRING ALLFLG QUIETFLG}
{Text
(Currently only in Interlisp-D)  ...

=====

{FnDef {Name DISMISS} {Args MSECSWAIT TIMER}
{Text
Dismisses the program for {arg MSECSWAIT} milliseconds. Can be aborted by interrupts such as control-D, control-E, or control-B.

In Interlisp-10 and -VAX, the program uses no CPU time while waiting.

In Interlisp-D, {fn DISMISS} allows other Lisp processes to run, i.e., the current process is suspended for {arg MSECSWAIT} milliseconds.  In addition {fn DISMISS} can be given a timer {arg TIMER}, in which case it will ignore {arg MSECSWAIT} and await the expiration of {arg TIMER} (see {PageRef Tag Timers}).
}}

====

{Label {lisp OPENBYTESIZE}{index OPENBYTESIZE (File Attribute)}}
{Text  (Interlisp-10)  It is possible that the byte size for the "opening" of a file might differ from the "permanent" bytesize.  For example, a 7-bit text file can be opened in 36-bit mode.  To obtain the "open" bytesize, use attribute {lisp OPENBYTESIZE}.}

{Label {lisp PROTECTION}{index PROTECTION (File Attribute)}}
{Text  (Interlisp-10)  The "protection code" of {arg FILE}, as an integer.}

{Label {lisp DELETED}{index DELETED (File Attribute)}}
{Text  (Interlisp-10)  {lisp T} if {arg FILE} is the name of a deleted file, {lisp NIL} otherwise.}

Additional attributes which are available for Interlisp-10 on TOPS-20 systems (DEC release 4 or later) are:

{Begin LabeledList values for ATTRIB on TOPS-20 systems}

{Label {lisp INVISIBLE}{index INVISIBLE (File Attribute)}}
{Text  {lisp T} if {arg FILE} has the invisible attribute, {lisp NIL} otherwise.}

{Label {lisp ARCHIVED}{index ARCHIVED (File Attribute)}}
{Text  {lisp T} if {arg FILE} has been archived, {lisp NIL} otherwise.}

{Label {lisp OFF-LINE}{index OFF-LINE (File Attribute)}}
{Text  {lisp T} if the contents of {arg FILE} are off-line (i.e. {arg FILE} has been archived and its contents flushed), {lisp NIL} otherwise.}

{End LabeledList values for ATTRIB on TOPS-20 systems}

=====

(Interlisp-10)  {fn LISTFILES} uses the function {fn TENEX} ({PageRef Fn TENEX}) to tell the operating system to print the file.  {fn LISTFILES} calls {index LISTFILES1 FN}{fn LISTFILES1} which calls {fn TENEX} with {lisp (CONCAT 'LIST$ {arg FILENAME} LISTFILESTR)}, where {var LISTFILESTR} is initially "{CRsymbol}".{index LISTFILESTR Var} The user can reset {var LISTFILESTR} to specify subcommands for the list command, or advise or redefine {fn LISTFILES1}.

=====

{FnDef {FnName GETFILEINFO} {FnArgs FILE ATTRIB}
{Text
Returns the current setting of the {arg ATTRIB} attribute of {arg FILE}.  In Interlisp-10, {arg FILE} may also be a {lisp JFN} as returned by {fn GTJFN} ({PageRef Fn GTJFN}).

In Interlisp-10, {fn GETFILEINFO} takes an optional third argument, {arg SCRATCH}, which is analogous to the third argument of {fn GDATE} ({PageRef fn GDATE}): a string pointer to reuse for those {arg ATTRIB}'s which return string values.
}}

=====

{FnDef {FnName SETLINELENGTH} {FnArgs N}
{Text
In Interlisp-10,if {arg N} is {lisp NIL}, interrogates the operating system for the line length of the terminal device, and sets the variable {index TTYLINELENGTH Var}{var TTYLINELENGTH} to this value.  If {arg N} is not {lisp NIL}, instructs the operating system to set the terminal line length to {arg N}, and also sets {var TTYLINELENGTH} to {arg N}.  Then, {fn SETLINELENGTH} performs (and returns as its value) {lisp (LINELENGTH N T)}.

In Interlisp-D, {fn SETLINELENGTH} merely does {lisp (LINELENGTH N T)}.
}}

Both {index AFTERSYSOUTFORMS Var}{var AFTERSYSOUTFORMS} and {index RESETFORMS Var}{var RESETFORMS} ({PageRef Var RESETFORMS}) contain a {lisp (SETLINELENGTH)} so that when the user first runs a {fn SYSOUT}, or types control-D{index control-D}, the system obtains the latest information about the terminal.


=====

{FnDef {Name CASEARRAY} {Args OLDARRAY}
{Text
Creates and returns a new casearray, with all elements set to themselves, to indicate the identity mapping.

(Interlisp-D) If {arg OLDARRAY} is given, it is reused.
}}

=====

{FnDef {FnName WAITFORINPUT} {FnArgs FILE}
{Text
Waits until input is available from {arg FILE} or from the terminal, i.e. from {lisp T}.  {fn WAITFORINPUT} is functionally equivalent to {lisp (until (OR (READP T) (READP FILE)) do NIL)}, except that it does not use up machine cycles while waiting.  Returns the device for which input is now available, i.e. {arg FILE} or {lisp T}.

{arg FILE} can also be an integer, in which case {fn WAITFORINPUT} waits until there is input available from the terminal, or until {arg FILE} milliseconds have elapsed. Value is {lisp T} if input is now available, {lisp NIL} in the case that {fn WAITFORINPUT} timed out.

In Interlisp-10, {fn WAITFORINPUT} operates by dismissing, checking for available input, and then, if there is none, dismissing again, each time for an increasingly larger interval.  The initial interval is {var DISMISSINIT}{index DISMISSINIT Var} milliseconds (initially 500), and the interval grows by 1/16 for each dismissal, up to a maximum of {var DISMISSMAX}{index DISMISSMAX Var} milliseconds (initially 10,000).
}}

=====

{FnDef {FnName READ} {FnArgs FILE RDTBL FLG}
{Text

In Interlisp-10, the character control-W is defined as an {lisp IMMEDIATE} read macro that erases the last expression read, echoing a {lisp \\} and the erased expression, e.g., {lisp (NOW IS THE TIME^W \\ TIME)} returns {lisp (NOW IS THE)}.{index *PRIMARY* control-W}{index *PRIMARY* \\ (Printed by System)}  Control-W can be used repeatedly, and can also back up and erase expressions on previous lines.  However, since control-W is implemented as an {lisp IMMEDIATE} read-macro character, ({PageRef Tag ReadMacros}), once it is typed, then individual {it characters} typed before it cannot be deleted by control-A or control-Q, since they will already have passed through the line buffer.

In Interlisp-D, control-W is instead defined as an editing character that deletes the last "word" of input, i.e., back to the first non-{lisp OTHER} character preceding the first non-{lisp SEPR} character, essentially a repeated BackSpace.  The character performing this function is assignable using the {lisp WORDDELETE} syntax ({PageRef fn SETSYNTAX}).

}}

=====

Note: in all Interlisp-10 symbolic files, {index end-of-line}end-of-line is indicated by the characters {index carriage-return}carriage-return and {index line-feed}line-feed in that order.  Accordingly, on input from files, Interlisp-10 skips all line-feeds that immediately follow carriage-returns.  On input from the terminal, Interlisp echos a line-feed whenever a carriage-return is input.

When reading from the {index terminal}terminal, the input is buffered a line at a time (unless buffering has been inhibited by {lisp (CONTROL T)}, or the input is being read by {fn READC} or {fn PEEKC}) and can be backed up over using specified editing characters.  The user can erase a character at a time, the whole line, or, in Interlisp-D, a word at a time.  The keys that perform these editing functions are assignable via the {fn SETSYNTAX} function ({PageRef Fn SETSYNTAX}), with the intial settings chosen to be those most natural for the given operating system: characters are deleted one at a time by {index control-A}control-A under Tenex, Delete under Tops20, and {index BackSpace}BackSpace in Interlisp-D; the whole line is erased by {index control-Q}control-Q under Tenex and in Interlisp-D, and {index control-U}control-U under Tops20; words are erased by {index control-W}control-W in Interlisp-D.

The character-deleting action on normal terminals is to echo a {lisp \}{index \ (Printed by System)} followed by the erased character; on the Interlisp-D display the character is physically erased from the screen (this action can also be specified for display terminals in other Interlisps; see {PageRef Fn DELETECONTROL}).  The line-deleting action is normally to print {lisp ##}{index ## (Printed by System)} and start over on a new line.  Neither will back up beyond the previous carriage-return.

=====

{FnDef {FnName DATE} {FnArgs FORMATBITS}
{Text
Obtains date and time, returning it as a single string with format {lisp "{arg DD}-{arg MM}-{arg YY} {arg HH}:{arg MMM}:{arg SS}"}, where {arg DD} is day, {arg MM} is month, {arg YY} year, {arg HH} hours, {arg MMM} minutes, {arg SS} seconds, e.g., {lisp "14-MAY-71 14:26:08"}.

In Interlisp-10, {fn DATE} will accept {arg FORMATBITS} as an argument, which can be used to specify other formats, e.g., day of week, time zone, etc., as described in the TENEX/TOPS-20 JSYS manual. {arg FORMATBITS} is ignored in Interlisp-D.
}}

=====

{FnDef {FnName CLOCK} {FnArgs N {anonarg}}
{Text
...
{Label For {arg N}=3,}
{Item
returns the number of milliseconds of compute time spent in garbage collections (all types).{foot
In Interlisp-10, this  number is directly accessible via the 
{lisp COREVAL} {lisp GCTIM}.
}{comment endfootnote}
}

=====

Each data type in Interlisp has an associated "type name," a litatom.{foot
In Interlisp-10, each data type also has an associated "type number."  See {PageRef Fn NTYP}.
}{comment endfootnote}

=====

{foot
In particular, the Interlisp-10 implementation recognizes file names in both Tenex and TOPS-20 format, and builds new names as appropriate.
}{comment endfootnote}

Every file name is composed of a collection of {it fields} which have different semantic interpretations.  A {it field name} is a literal atom which is the name of a file-name field.  Interlisp assumes that {lisp NAME} and {lisp EXTENSION} are valid field names; the implementor is free to allow other fields.  In Interlisp-10, allowable field names are:
{lisp DEVICE}, {lisp DIRECTORY}, {lisp NAME}, {lisp EXTENSION}, {lisp VERSION}, {lisp PROTECTION}, {lisp ACCOUNT}, and {lisp TEMPORARY}.  Interlisp-D allows {lisp HOST}, {lisp DIRECTORY}, {lisp NAME}, {lisp EXTENSION}, and {lisp VERSION}.

=====

fn OPENFILE:

{arg BYTESIZE}, if supplied, is the byte size in which to open the file.  If {arg BYTESIZE}={lisp NIL}, the bytesize used is the default for the implementation (8 for Interlisp-D, 7 for Interlisp-10).

{arg PARAMETERS} is a list specifying additional opening parameters.  In Interlisp-10, this list may contain the following litatoms:


{Begin Labeledlist opening parameters}

{Indent 15percent}

{Label {lisp WAIT}}
{Text Wait if file is busy.}

{Label {lisp DON'T.CHANGE.DATE}}
{Text Don't change the access dates.}

{Label {lisp THAWED}}
{Text Open file in "thawed" mode.}

{End Labeledlist opening parameters}

In Interlisp-D, {arg PARAMETERS} must be a list of pairs {lisp ({arg ATTRIB} {arg VALUE})}, where {arg ATTRIB} is any file attribute that the file system is willing to allow the user to set (see {fn SETFILEINFO}, {PageRef Fn SETFILEINFO}).  A non-list {arg ATTRIB} in {arg PARAMETERS} is treated as the pair {lisp ({arg ATTRIB} {lisp T})}.

=====


{FnDef {FnName DOBE} {FnArgs}
{Text
(Interlisp-10)  {lisp D}ismiss until {lisp O}utput {lisp B}uffer is {lisp E}mpty, i.e., until all of the characters that have been printed by Interlisp functions have actually been printed on the user's terminal.  For example, it is important to perform a {fn DOBE} after printing an error message before clearing the input buffers to make sure that the user has actually seen the error message.

In systems that do not handle output to the display asynchronously with user computation, such as Interlisp-D, {fn DOBE} is a no-op.
}}

=====


{FnDef {FnName RANDACCESSP} {FnArgs FILE}
{Text
Returns {arg FILE} if {arg FILE} is randomly accessible, {lisp NIL} otherwise.  The file {lisp T} is not randomly accessible, nor are the files {lisp LPT:}, {lisp NIL:} in Interlisp-10, or certain network file connections in Interlisp-D.  {arg FILE} must be open or an error is generated, {lisp FILE NOT OPEN}{index FILE NOT OPEN Error}.
}}


=====

from UNPACKFILENAME


Examples from Interlisp-10 on Tenex:

{lispcode
_ (UNPACKFILENAME '<LISP>MAC.COM;3)
(DIRECTORY LISP NAME MAC EXTENSION COM VERSION 3)
_ (UNPACKFILENAME 'WORK.;T)
(NAME WORK EXTENSION NIL TEMPORARY T)}

Note:  In Interlisp-10, {lisp (UNPACKFILENAME 'DSK:FOO)} returns {lisp (DEVICE DSK: NAME FOO)}, i.e. the {lisp :} is left in.  This is so {lisp (DEVICE NIL:)} may be distinguished from {lisp (DEVICE NIL)}.

=====

In Interlisp-10, filenames follow the conventions of the operating system (either TENEX or TOPS-20), i.e., {arg FILE} can be prefixed by a directory name enclosed in angle brackets, can contain <esc>s{index $ (<esc>)} or control-F's,{index control-F (in file name) Term} and can include suffixes and/or version numbers.{index version numbers}    The full filename in Interlisp-10 consists of directory, name, extension, and version.

=====

Note that recognition is performed on the user's entire directory, not just the open files, which can result in certain anomalies.  Thus, even if only one file is open, say {lisp FOO.;1}, the name {lisp F$} ({lisp F}<esc>) will not be recognized if the user's directory also contains the file {lisp FIE.;1}.

=====

{FnDef {Name LOGOUT} {Args FAST}
{Text
Stops Interlisp, and returns control to the operating system.  From there, it is possible to continue Interlisp as of the {fn LOGOUT}.  {fn LOGOUT} will not affect the state of open files.

In Interlisp-D, {fn LOGOUT} writes out all altered pages from real memory to the file {lisp Lisp.virtualmem}.  This usually takes about 30 seconds on the Xerox 1100.  If {arg FAST} is non-{lisp NIL}, Interlisp is stopped without updating {lisp Lisp.virtualmem}.  Note that it will not be possible to restart Interlisp from the point of the {fn LOGOUT}, and it may not be possible to restart it at all.  Typing {lisp (LOGOUT T)} is preferable to just booting the machine, because it also does other cleanup operations (closing network connections, etc.).

In Interlisp-10, if Interlisp was started as a subsidiary fork (see {fn SUBSYS}, {PageRef Fn SUBSYS}), control is returned to the higher fork.
}}
{note BEFORELOGOUTFORMS and AFTERLOGOUTFORMS evaluated before/after logout in Interlisp-D only!  foo!}


=====

{FnDef {Name SYSOUT} {Args FILE}
{Text
Saves the current state of the Interlisp virtual memory on the file {arg FILE}, in a form that can be subsequently restarted.  The current state of program execution is saved in the sysout file, so {lisp (PROGN (SYSOUT 'FOO) (PRINT 'HELLO))} will cause {lisp HELLO} to be printed after the sysout file is restarted.

If {arg FILE} is non-{lisp NIL}, the variable {var SYSOUTFILE}{index SYSOUTFILE Var} is set to the body of {arg FILE}.  If {arg FILE} is {lisp NIL}, then the value of {var SYSOUTFILE} instead.  Therefore, {lisp (SYSOUT)} will save the current state on the next higher version of a file with the same name as the previous {fn SYSOUT}.  Also, if the extension for {arg FILE} is not specified, the value of {var SYSOUT.EXT}{index SYSOUT.EXT Var} is used.  This is initially {lisp SYSOUT} in Interlisp-D, {lisp SAV} in Tenex Interlisp-10, and {lisp EXE} in Tops-20 Interlisp-10.



...

=====

In Interlisp-10, a sysout file only contains the parts of the virtual memory that the user has changed.  When the sysout file is restarted, the other pages are taken from the makesys file of the Interlisp system within which the sysout file was made (see {fn MAKESYS}, below).  Therefore, whenever the Interlisp system is reassembled and/or reloaded, old sysout files are {it not} compatible with the new system.


=====

After a sysout file is restarted (but {it not} when it is initially created), {fn SYSOUT} evaluates the expressions on {index AFTERSYSOUTFORMS Var}{var AFTERSYSOUTFORMS}.  This initially includes expressions to:  (1)  Perform any necessary operations on previously-opened files as specified by calls to {fn WHENCLOSE} ({PageRef Fn WHENCLOSE});  (2)  [Interlisp-10 only]  Reset the terminal line length with {fn SETLINELENGTH} ({PageRef Fn SETLINELENGTH});  (3)  [Interlisp-10 only]  Reset the terminal control characters using {index SETTERMCHARS Fn}{fn SETTERMCHARS} ({PageRef Fn SETTERMCHARS}) if the operating system has changed from Tenex to Tops-20 or vice versa;  (4)  Possibly print a message, as determined by the value of {var SYSOUTGAG} (see below); and (5)  Call {fn SETINITIALS} to reset the initials used for time-stamping ({PageRef Tag TimeStamps}).


{FnDef {Name SYSIN} {Args FILE}
{Text
[Interlisp-10 only]  Restores the state of Interlisp from a sysout file.  This is essentially the same as exiting Interlisp, and restarting a sysout file from the operating system executive.  If {fn SYSIN} returns {lisp NIL}, there was a problem in reading the file.  If {arg FILE} was not found, generates a {lisp FILE NOT FOUND} error.
}}


{FnDef {Name SYSOUTP} {Args FILE}
{Text
[Interlisp-10 only]  Returns the name of the original Interlisp makesys file (see {fn MAKESYS}, below) if {arg FILE} is a sysout file, otherwise {lisp NIL}.

{arg FILE} may also be a JFN.
}}

In Interlisp-D, {fn MAKESYS} is almost the same as {fn SYSOUT}, except that it does some cleaning-up operations (such as clearing the screen).  In Interlisp-10, however, {fn MAKESYS} is considerably different from {fn SYSOUT}, because it saves {it all} of the pages in the Interlisp virtual memory, and allows the makesys file to be shared between multiple users.

{index shared pages}
{index private pages}

The Interlisp-10 system initially obtained by the user is shared; that is, all active users of Interlisp-10 are actually using the same pages of memory.  As a user adds to the system, private pages are added to his memory.  Similarly, if the user changes anything in the original shared Interlisp-10, for example, by advising a system function, a private copy of the changed page is created.

In addition to the swapping time saved by having several users accessing the same memory, the sharing mechanism permits a large saving in garbage collection time, since it is not necessary to garbage collect any data in the shared system, and thus Interlisp-10 does not need to chase from any pointers on shared pages during garbage collections.

This reduction in garbage collection time is possible because the shared system usually is not modified very much by the user.  If the shared system is changed extensively, the savings in time will vanish, because once a page that was initially shared is made private, every pointer on it must be assumed active, because it may be pointed {it to} by something in the shared system.  Since every pointer on an initially shared but now private page can also point to {it private} data, they must always be chased.

A user may create his own shared system with the function {fn MAKESYS}.  If several people are using the same system, making the system be shared will result in a savings in swapping time.  Similarly, if a system is large and seldom modified, making it be shared will result in a reduction of garbage collection time, and may therefore be worthwhile even if the system is only being used by one user.


One problem with using {fn MAKESYS} in Interlisp-10 is that it may protect large amounts of useless data from being garbage collected.  For example, suppose that during the course of building an Interlisp system, a large number of list cells are used and discarded.  If {fn MAKESYS} is now executed to store the system, all of that list cell space is stored, and protected from garbage collection (unless the user changes those pages, making a personal copy).  To solve this problem, it is necessary to make sure that as little storage as possible is allocated while creating a new system, perhaps by setting {fn MINFS} ({PageRef Fn MINFS}) to a very low value.  Of course, this will slow down Interlisp considerably, so making a new system will take a long time.

======

{FnDef {FnName BOXCOUNT} {FnArgs TYPE N}
{Text
Returns the number of boxing operations for the data type {arg TYPE} (see {PageRef Tag BOXING}) since Interlisp started up.  If {arg N} is not {lisp NIL}, the corresponding counter is reset to {arg N}.

In Interlisp-10, if {arg TYPE}={lisp NIL}, {fn BOXCOUNT} returns the number of large integer boxes; if {arg TYPE} is non-{lisp NIL}, it returns the number of floating boxes.  These counters are directly accessible via the {lisp COREVAL}s {lisp IBOXCN} and {lisp FBOXCN}.    

In Interlisp-D, {arg TYPE} can be any datatype name, in addition to {lisp FIXP} and {lisp FLOATP}.
}}

=====


Note:  Interlisp-10 employs a {index shallow binding}shallow binding scheme as described on {PageRef Tag Stack}.  There is no distinction between global variables and other types of variables: all variable references are to the variable's value cell.  Thus, the cost of {it accessing} a variable is small and independent of the depth of computation, whereas in a deep bound system, it can be expensive to search the stack for the most recent binding of a variable, hence the need for a mechanism like global variables.  Note however that in a shallow bound system, the cost of rebinding a variable is somewhat higher than in a deep bound system (except when the variable is a {lisp LOCALVAR}).  For the purposes of compilation, global variables are treated the same as {lisp SPECVARS}, i.e. their names are always visible on the stack when they are rebound.

-----


{Def {Type PACom}
{Name EXEC}
{Text
(Interlisp-10)  Calls {fn SUBSYS} ({PageRef Fn SUBSYS}) to descend to lower exec.

Rather than start up a new fork each time the user types {pacom EXEC}, the {pacom EXEC} command will save the old fork handle upon return from an {pacom EXEC} command, and, if the fork handle is still active, reuse it for the next {pacom EXEC} command, i.e. an {pacom EXEC} followed by another {pacom EXEC} is equivalent to an {pacom EXEC} followed by a {pacom CONTIN}.
}}


{Def {Type PACom}
{Name CONTIN}
{Text
(Interlisp-10)  Performs {lisp (SUBSYS T)} to continue the last call to {fn SUBSYS} ({PageRef Fn SUBSYS}).
}}

=====


{Begin SubSec Statistics}
{Title Statistics}
{Text

{index statistics}

The programmer's assistant keeps various statistics about system usage, e.g., number of user inputs, number of undo saves, number of calls to editor, number of edit commands, number of p.a. commands, cpu time, console time, etc.  These can be viewed via the function {fn LISPXSTATS}.  The user can define add new statistics to the p.a. statistics via the function {fn ADDSTATS}, and increment them with {fn LISPXWATCH}.


Note:  The collection of programmer's assistant statistics is not supported in Interlisp-D.  {fn ADDSTATS} and {fn LISPXWATCH} are defined with null definitions, so programs can be transferred.


{FnDef {FnName LISPXSTATS} {FnArgs RETURNVALUESFLG}
{Text
Prints programmer's assistant statistics.  If {arg RETURNVALUESFLG}={lisp T}, returns the statistics as a list of elements of the form {lisp ({arg VALUE} . {arg EXPLANATION})}.
}}


{FnDef {FnName ADDSTATS} {FnArgs STAT{sub 1} {ellipsis} STAT{sub N}}
{Type NOSPREAD NLAMBDA}
{Text
Each {arg STAT{sub i}} is a list of the form {lisp ({arg STAT-NAME} . {arg MESSAGE})}.  Each {arg STAT-NAME} is defined as the name of a new statistic.


For example, {lisp (ADDSTATS (EDITCALLS CALLS TO EDITOR) (UNDOSTATS CHANGES UNDONE)} will define two new statistics, named {lisp EDITCALLS} and {lisp UNDOSTATS}.
}}



{FnDef {FnName LISPXWATCH} {FnArgs STAT N}
{Text
Increments the statistic with name {arg STAT} by {arg N} (or 1 if {arg N}={lisp NIL}).

{fn LISPXWATCH} has a {index BLKLIBRARYDEF Prop}{prop BLKLIBRARYDEF} (see {PageRef Prop BLKLIBRARYDEF}).
}}


The user can save his statistics for loading into a new system by performing {lisp MAKEFILE(DUMPSTATS)}.  After the file {lisp DUMPSTATS} is loaded, the statistics printed by {fn LISPXSTATS} will be the same as those that would be printed following the {fn MAKEFILE}.

}{End SubSec Statistics}


&
&
&
&
&
&
&
&
&
&
&
&
&
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))
GACHA
?1(DEFAULTFONT 1 (GACHA 10) (GACHA 8) (TERMINAL 8))

U
	


8

%





-




F



7








A







=

L




7

d




l




9




;

R




9

H




9






7









Ī

1Æ
ļ

)
¹
H

2


(l
8


+




M











¤








-






³





c











Š




’





ō








	)				
		
		ó				
				
		+										b		>								
				
	K^

Œ

cļ



É
…

'


!&
#
%

T



Œ
…


*
R




%

$2'
Ī


±


4

!½
*
g


!
<
?








`

 
R

"


l


ˆ

Z


‘

ü

)Ź


c


Z


R

r

k




















¤







Ā







4



±









E





˜







¢












+



W




i




















]ŠĒzŗ