#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of shell archive."
# Contents:  adt.fund.tex all3.ps all4.ps bottom3.ps bottom4.ps
#   some3.ps sub41.ps sub42.ps sub43.ps sub44.ps
# Wrapped by pepe@cain on Sat Jun 24 10:42:39 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f adt.fund.tex -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"adt.fund.tex\"
else
echo shar: Extracting \"adt.fund.tex\" \(39062 characters\)
sed "s/^X//" >adt.fund.tex <<'END_OF_adt.fund.tex'
X%> do TEX -latex -x %F
X
X%  ADT fundamentals
X%  Jose A. Manas
X%  dpt. ingenieria telematica
X%  etsi telecomunicacion
X
X%  jmanas@dit.upm.es
X
X\documentstyle[12pt]{article}
X
X\textwidth=16cm
X\oddsidemargin=1cm
X\evensidemargin=1cm
X\textheight=22cm
X\topmargin=0cm
X
X\parindent=0cm
X\parskip=3mm
X
X\unitlength=1mm
X
X\title  {
X        A Tutorial on ADT semantics for LOTOS users     \\
X        Part I: Fundamental Concepts
X        }
X
X\author {
X        Jos\'e A. Ma\~nas       \\
X                                \\
X        Dept. Ingenier\'{\i}a Telem\'atica      \\
X        E.T.S.I. Telecomunicaci\'on             \\
X        Ciudad Universitaria                    \\
X        E-28040  MADRID                         \\
X        SPAIN                                   \\
X                                                \\
X        {\tt jmanas@dit.upm.es}
X        }
X
X\date {14 November, 1988}
X
X\begin{document}
X
X\maketitle
X
X\begin{flushright}
X\em
XThe limits of my language mean the limits of my world   \\
XLudwig Wittgenstein
X\end{flushright}
X
X\begin{abstract}
XAn informal presentation of the semantics of Abstract Data Types 
Xas they are used in the specification language LOTOS.
XThis paper covers the fundamentals,
Xwhile a separate {\em Part II} covers the available operations.
X\end{abstract}
X
X\section{Introduction}
XThis tutorial intends to cover the usually big gap
Xbetween normal specifiers and algebricians.
XThe question to answer is
X
X\begin{center}
Xwhat are the abstract data types of LOTOS?
X\end{center}
X
XLOTOS syntax is used,
Xbut not introduced in detail.
XReaders are referred to the standard definition
X\cite{kn:is8807-88}.
XThis tutorial is mostly dealing with semantics.
X
XThe author is not a mathematician,
Xnor an algebrician,
Xbut a plain computer scientist,
Xwith a very pragmatic interest on abstract data types.
XThat helps making this paper introductory,
Xbut be sure it will not be very useful for mathematicians.
X
XThe magic word in this world is {\em ABSTRACT}.
XThere are several reasons to say
X{\bf abstract}.
XSome people say ADTs are implementation independent,
Xand put as a counter example concrete data types
Xas those in the language Ada.
XIt is true that
Xyou can describe data without giving algorithms,
Xthus providing an implementation-free specification,
Xbut it is also true
Xthat you can specify algorithms as ADTs too.
XIn fact,
Xmost people specify ADTs by giving and evaluation algorithm
Xin the style that is usualy referred to as
X{\em a rewrite system}.
X
XOther people say ADTs are representation independent,
Xas opposed to cluttering representation issues as in old FORTRAN.
XOk, that's true as for any language where types may be defined
Xby means of symbolic names,
Xthat is, for most modern programming languages.
XBut be aware you can also describe bytes and bits as ADTs.
X
XWe prefer to say ADTs are a {\em methodology} to describe objects by
Xitemizing the properties your data must have.
XIt's up to specifiers which properties are described.
XYou may wish to specify algorithms or even bit representations.
XThose are perfectly legal items to be specified.
XYou may wish to specify the axioms of group theory,
Xand that is perfectly legal too.
X
XWith respect to the contents of this paper,
Xthe presentation will be straightforward,
Xintroducing only those theoretical concepts that are strictly
Xrequired.
XMany examples will be presented,
Xnot big ones,
Xbut meaningful ones.
X
XA note of warning about the universality of what is exposed in the
Xfollowing pages.
XThe theory of abstract data types is not a single theory,
Xbut there are as many as ADT languages.
XWe shall concentrate on ACT ONE,
Xthe language used in LOTOS.
XWhen there are several choices,
Xthey will be briefly presented,
Xbut only the one followed by ACT ONE is carried on.
XWhen there are differences between ACT ONE and LOTOS,
Xthe last one is preferred.
X
X\section{ADTs in LOTOS}
XIn order to make clear what do LOTOS specifiers need from ADTs,
Xlet's start by revising LOTOS constructions.
X
X\subsection{Synchronization}
XBasic LOTOS activity is to synchronize on action denotations.
XThere are three basic kinds of synchronization:
X
X\begin{enumerate}
X  \item
X    synchronization:
X    
X    \verb/g !E1  |[ g ]|  g !E2/
X
X    where expressions $E1$ and $E2$ must belong to the same
X    sort.\footnote{
X        Precise definitions are given below.
X        For the time being,
X        think of sorts as Pascal types.
X        }
X    It will succeed iff we can prove
X    $E1 = E2$
X    from the specification of the common type.
X
X  \item
X    value passing:
X    
X    \verb/g !E  |[ g ]|  g ?x:S/
X
X    where expression $E$ must belong to the sort $S$.
X    It will succeed,
X    becoming 
X    $x= E$.
X
X  \item
X    negotiation:
X    
X    \verb/g ?x:S  |[ g ]|  g ?y:S/
X
X    It will succeed, becoming
X    $x = y$
X    for some value in sort $S$.
X\end{enumerate}
X
XCases 2 and 3 can be regarded as trivial
Xwith respect to the use of data type specifications.
XCase 1 introduces the notion of
X{\bf proving}.
XIt must be proved if two expressions are equal or not,
Xin order to know whether the synchronization may succeed.
X
X\subsection{Guarded Behaviours}
XThe behaviour 
X
X\[[ E1 = E2 ]\rightarrow B\]
X
Xis equivalent to
X$stop$
Xor
X$B$,
Xdepending on $E1$ being equal to $E2$ or not.
XAgain,
Xit must be proved.
XThere is a shorthand for boolean expressions:
X$[ E1 ]$    stands for    $[ E1 = true ]$.
X
X\subsubsection{Predicates}
XThe action denotation
X
X\[a [ E1 = E2 ]; B\]
X
Xwill allow $a$ to synchronize or not
Xdepending on the result of proving if $E1$ is equal to $E2$ or not.
XThere is a shorthand for boolean expressions:
X$[ E1 ]$    stands for    $[ E1 = true ]$.
X
X\subsection{Conclusion}
XThe use of an ADT specification in LOTOS
Xis basically finding out if two expressions are equal or not.
XOf course,
Xvalid expressions are only those constructed using the operations of
Xspecified types,
Xwith the standard rules.
XThis is typical of every programming language,
Xand we shall not say much more.
X
X\section{Very Basic Remind}
XSince readers are not expected to be working algebricians,
Xwe shall copy here some very very basic notions.
XTo simplify the notation,
Xwhere no confusion arise,
Xwe shall use the Pascal typing mechanism,
Xwriting $x: S$    for    $x \in S$.
X
X\subsection{Functions}
XA function is a deterministic criterion to relate {\em EVERY} combination of
Xelements of a domain of sets,
Xinto just one element of a range set.
XThe standard notation is used:
X
X\[f: s_{1} \ldots s_{n} \rightarrow s_{r}\]
X
Xwhere the domain is \((s_{1} \ldots s_{n})\),
Xand the range is $s_{r}$.
XNotice we say "\ldots every \ldots",
Xthat is,
Xwe are dealing with
X{\bf total}
Xfunctions,
Xthose defined over the whole domain.
X\subsection{Surjective}
XA function is surjective if and only if for every element of $s_{r}$
Xthere exists a combination of elements in the domain
Xwhose image is that element in the range.
XThe whole range set is covered.
XFormally,
X
X\begin{center}
X  $\forall x_{r}: s_{r}$,
X  $\exists x_{1}: s_{1} \ldots x_{n}: s_{n}$
X  such that $f (x_{1} \ldots x_{n}) = x_{r}$
X\end{center}
X
X\subsection{Injective}
XA function is injective iff different combinations of elements in the
Xdomain are mapped into different elements of the range.
XInformally,
Xit means that
Xfrom the result we can infer the arguments.
X
X\[f(a) = f(b)  \Rightarrow  a = b\]
X
XFor injective  and total functions $f$
Xthere exists an inverse function $f'$ such that
X
X\[f \circ f' = I\]
X\[f' \circ f = I\]
X
Xwhere $\circ$ is the composition of functions
X
X\[(f1 \circ f2) (x) = f1 (f2 (x))\]
X
Xand $I$ is the identity function
X
X\[I (x) = x\]
X
X\subsection{Bijective}
XA total function that is both surjective and injective is then bijective.
X
X\section{Fundamental Concepts}
XAlthough we shall try to keep to a minimum,
Xwe need some formalism to proceed.
XACT ONE is a language for specifying by means of algebras.
X\begin{itemize}
X  \item
X    {\em ALGEBRA:}
X  
X    An {\bf algebra}
X    is a set of elements
X    with operations
X    and properties between them.
X\end{itemize}
X
XThis is very informal.
XLet's refine the concept.
X
X\subsection{Sort}
X\begin{itemize}
X  \item
X    {\em SORT:}
X  
X    A {\bf sort} is a set of elements with a name.
X\end{itemize}
X
XThere are algebras with just one
Xsort\footnote{
X        one-sorted algebras,
X        homogeneous.
X        }.
XFor instance,
Xthat of {\em Bool}.
XAnd there are algebras with more than one
Xsort\footnote{
X        many-sorted algebras,
X        heterogeneous.
X        }.
XFor instance,
Xthe algebra of the {\em stacks of integers},
Xwhere at least we have the sort of {\em integers}
Xand the sort of {\em stacks}.
X
XWhat we here call sorts,
Xcorresponds to the concept of 
X{\bf type}
Xin most programming languages
X(e.g. in Pascal).
XBut readers must be careful because later on
Xwe shall call types to algebras.
XBut let's go step by step.
X
X\subsection{Operation}
X\begin{itemize}
X  \item
X    {\em OPERATION:}
X  
X    An {\bf operation}
X    is a function with a domain and a range
X\end{itemize}
X
X\[op : s_{1}, s_{2}, \ldots s_{n} \rightarrow s_{r}\]
X
Xwhere $<s_{1} \ldots s_{n}>$ is the
Xdomain\footnote{
X        Cartesian product of sorts.
X        },
Xover which the operation is defined;
Xand $s_{r}$ is the range,
Xthe sort of the result.
XWe shall restrict ourselves to 
X{\em total functions}.
XThat is, operations must be defined for {\em EVERY} possible combination of
Xinput arguments.
XThey must be defined over the whole domain.
X
XFormally,
Xlet $op : Sx \rightarrow Sy$
X
X\begin{center}
X  $\forall x \in Sx$,
X  $\exists y \in Sy$
X  such that $op(x) = y$
X\end{center}
X
XThere are ADT languages able to specify partial operations,
Xbut that is not the case for ACT ONE in LOTOS.
XThere are languages with nondeterministic operations,
Xbut their algebraic support is extremely complicated.
XIt is not the case for LOTOS too.
X
X\subsection{Ground Terms}
X\begin{itemize}
X  \item
X    {\em GROUND TERMS:}
X  
X    The elements in the sorts are called
X    {\bf ground terms}\footnote{
X      Some authors call them {\em carriers},
X      but the terminology is not common to everybody.
X      }
X\end{itemize}
X
XIn an algebra $A$,
Xincluding a sort $s$,
Xwe shall denote by
X$|A|s$
Xthe set of ground terms in sort $s$.
XSometimes we shall abuse of the notation and write
X$|A|$
Xto denote all the sets of ground terms of sorts belonging to $|A|$.
X
XThere is a simple procedure to construct all the terms in a sort:
X
X\begin{enumerate}
X  \item
X    seed: nullary operations
X
X    $\forall op: \rightarrow s,  op \in |A|s$
X
X  \item
X    rest: operations on ground terms generate new ground terms
X
X        Let $x_{1} \in |A|s_{1}, \ldots, x_{n} \in |A|s_{n}$
X
X        and  $op: S_{1} \ldots S_{n} \rightarrow S$
X
X        then $op (x_{1} \ldots x_{n}) \in |A|s$
X\end{enumerate}
X
XExample.
XLet's consider the Booleans,
Xwith one sort
X{\em bool}
Xand three operations
X
X\[\begin{array}{lll}
X  T   & :      & \rightarrow bool       \\
X  F   & :      & \rightarrow bool       \\
X  not & : bool & \rightarrow bool
X\end{array}\]
X
Xthe following are ground terms
X
X$T$, $F$, $not(T)$, $not(F)$, $not(not(T))$, $not(not(F))$, $\ldots$
X
XNotice the set of ground terms $|Booleans|_{bool}$ is infinite.
XThis is a very typical situation.
X
XWe shall be mainly concerned with ground terms,
Xbut the definition may be slightly extended to cover 
X{\bf variables}.
XLet $X$
Xbe a set of variables of sort $s$.
XWe call
X{\bf terms}
Xof the sort $s$
Xto the set formed by ground terms,
Xas previously defined,
Xand the elements of $X$.
XNotice that previous rule (2.)
Xgenerates {\em more} new terms than before.
X
XFor Pascal educated readers,
Xnullary operations are CONSTANTS,
Xand ground terms are valid expressions
Xformed according to the Pascal type compatibility.
XTerms are similar,
Xincluding variables of the appropriate sorts.
X
X\subsection{Signature}
X\begin{itemize}
X  \item
X    {\em SIGNATURE:}
X
X    We shall call
X    {\bf signature}
X    of an algebra
X    to the pair formed by the set of sorts and the set of operations.
X\end{itemize}
X
X\[\begin{array}{lll}
X  SIG  & = & < S, F >           \\
X  S    & = & \{ sorts \}        \\
X  F    & = & \{ operations \} = \{ op: S^{*} \rightarrow S \}
X\end{array}\]
X
XFor those who know Modula-2,
Xa signature is quite similar to a DEFINITION module.
XIt says how functions are called,
Xand which are their parameters and result.
XThe whole syntax is known,
Xbut nobody knows what those functions do when called.
XThere is no {\em semantics} in a signature,
Xbut its value should not be disminished.
XAll the elements of the game are in the signature.
XThe rules of the game come later,
Xbut there is no further opportunity to introduce more elements.
XEven more,
Xthe names of the elements of the game are extremely interesting for
Xthe reader:
Xthe intuition works fine.
XTo put an example,
Xwhile every body will have a quick idea of an operation named $plus$
Xmay do,
Xthe intuition will not help at all if the operation is named $opn27$,
Xand it will work against normal understanding if named $minus$.
XIntuition works despite any correct semantics that are provided later on.
XWhile machines are very good with statements,
Xdespite concrete names;
Xhumans are much better with names.
X
X\subsection{Morphisms}
X\begin{itemize}
X  \item
X    {\em MORPHISM:}
X  
X    We shall relate signatures by means of morphisms.
X    {\bf Morphisms}
X    are mappings between signatures.
X\end{itemize}
X
XGiven $SIG_{1}$ and $SIG_{2}$,
Xwe may define a mapping
X
X\[g: SIG_{1} \rightarrow SIG_{2}\]
X
Xthat maps every sort in $S_{1}$ into some sort of $S_{2}$,
Xand every operation in $F_{1}$, into some operation of $F_{2}$.
XWe shall put a minimal requirement on morphisms:
Xthey must preserve functionality,
Xthat is, the mapping of operations must be such that
X
X\[\begin{array}{lll}
X  if    & op:    & s_{1}  \ldots   s_{n}  \rightarrow   s_{r}   \\
X  then  & g(op): & g(s_{1}) \ldots g(s_{n}) \rightarrow g(s_{r})
X\end{array}\]
X
X\subsection{Algebra}
XThe
X{\bf signature}
Xgives all the syntactic knowledge.
XWe just need to add
X{\bf semantics}
Xto have an algebra.
X
X\begin{itemize}
X  \item
X    {\em ALGEBRA:}
X  
X    $algebra = < signature, semantics > = < S, F, semantics>$
X\end{itemize}
X
X\begin{center}
XAn {\em ABSTRACT DATA TYPE} is an algebra.
X\end{center}
X
XThe semantics is needed for proving if two expressions
X(ground terms)
Xare equal or not.
XThat is the reason for many languages to describe the semantics in
Xterms of $=$   and   $\not =$.
X
XWe shall use the following notation to denote reasoning with algebras:
X$A \vdash  t_{1} = t_{2}$
Xthat is read as: from (the semantics of) algebra $A$
Xwe can prove that terms $t_{1}$ and $t_{2}$\footnote{
X   Obviously, 
X   (ground) terms,
X   i.e. generated from $A$'s signature.
X   }
Xare equal.
X
XSemantics breaks sorts into equivalence classes
X
X$\forall x \in CE_{i}$ and $\forall y \in CE_{j}$
X
X\[\begin{array}{lll}
X  i = j     & \Rightarrow & x = y       \\
X  i \not= j & \Rightarrow & x \not= y
X\end{array}\]
X
XIf two (ground) terms belong to the same equivalence class,
Xthen they are equal.
XIf two (ground) terms belong to different equivalence classes,
Xthen they are unequal.
XThere is no exception.
XEach equivalence class groups equal terms,
Xby definition.
X
XLet us present a simple example.
XWe shall start using LOTOS notation,
Xbut readers are referred to the LOTOS definition for a precise and
Xconcise syntax definition.
XIt is not our concern.
X
X\subsubsection{Naturals modulo 2}
X\begin{verbatim}
X        type Mod2 is
X          sorts
X            bit
X          opns
X            0, 1  :          -> bit
X            _ + _ : bit, bit -> bit
X
X          semantics
X            + | 0 1
X           ---+-----
X            0 | 0 1
X            1 | 1 0
X          endtype
X\end{verbatim}
X
XThere is just one sort, $bit$,
Xand three operations, $0$, $1$ and $+$.
XThe ground terms are
X$0$, $1$, $0+0$, $0+1$, $1+0$, $1+1$, $(0+0)+0$, $(0+0)+1$, $(0+1)+0$, $\ldots$
Xand there are just two equivalence classes,
Xas may be easily proved
X
X\begin{center}
X  \begin{tabular}{ll}
X    class 0 & class 1           \\
X    \hline
X    $0$       & $1$             \\
X    $0+0$     & $0+1$           \\
X    $1+1$     & $1+0$           \\
X    $(0+0)+0$ & $(0+0)+1$       \\
X    $(0+1)+1$ & $(0+1)+0$       \\
X    $\ldots$  & $\ldots$        \\
X    \hline
X  \end{tabular}
X\end{center}
X
X\subsection{Models}
XThere may be many algebras with the same signature.
XThat implies that given a signature,
Xwe may think of many algebras.
XWe shall indistincticly speak of
X{\bf models}
Xas a synonym for algebras.
XWe shall denote by
X$Alg(SIG, semantics)$
Xthe collection of models of a signature $SIG$
Xthat comply with a certain {\em semantics}.
XThe whole collection of models for a signature,
Xno semantics,
Xare denoted as $Alg(SIG, \emptyset)$,
Xor just $Alg(SIG)$ for short.
X
XThere are some very simple models.
XSo simple that they exist for every signature.
X
X\begin{itemize}
X  \item
X    WORD algebra.
X
X    Every (ground) term is different from any other.
X    Equivalence classes are one-element sets.
X
X  \item
X    BOTTOM.
X
X    All the terms are equal.
X    There is just ONE equivalence class encompassing ALL the (ground)
X    terms.
X\end{itemize}
X
XWe do not argue if these algebras are useful or not.
XWe just state their existence.
XWe can even find a third trivial model when variables are considered
X
X\begin{itemize}
X  \item
X    FREE algebra.
X
X    Every term is different from any other.
X    It is a generalization of the word algebra.
X\end{itemize}
X
X\subsubsection{Example: bottom algebra}
XThe bottom algebra is a nice model for some stupid programs as
X
X\begin{verbatim}
X        program nut (input, output);
X          begin
X          while true do
X            begin
X            readln;
X            writeln ("Ha!");
X            end
X          end.
X\end{verbatim}
X
X\subsubsection{Example: word algebra}
XThe word algebra is the normal model for simple specifications of
Xnatural numbers:
X
X\begin{verbatim}
X        type Naturals
X          sorts
X            nat
X          opns
X            0 :     -> nat       (* zero *)
X            s : nat -> nat       (* successor *)
X          endtype
X\end{verbatim}
X
XWhere the ground terms are
X$0$, $s(0)$, $s(s(0))$, $s(s(s(0)))$, $\ldots$
Xand every ground term is different from each other.
X
X\subsection{Homomorphisms}
XInformally speaking,
Xthe semantics of an algebra allows us to {\em evaluate} terms,
Xmeaning that given a complex term
Xwe are able to find a simpler one
Xthat is equal {\em in some sense}.
XFor instance, in type Mod2,
X
X\[Mod2 \vdash  (0+1)+1  =  0\]
X
XThere may exist different algebras,
Xwith different signatures and different semantics,
Xbut such that similar {\em evaluations} may be performed on any of them.
X
XSuppose there is a morphism
X$f : A_{1} \rightarrow A_{2}$
Xwith the property that if we {\em evaluate} a term $t$ in $A_{1}$
Xand get $\alpha$,
Xthen moving into $A_{2}$ and evaluating there,
Xwill yield $f(\alpha)$.
X
X\[\begin{array}{lll}
X        A_{1}  \vdash & t    & = \alpha \\
X        A_{2}  \vdash & f(t) & = f(\alpha)
X\end{array}\]
X
XWe are looking for relations between algebras.
XAnd obviously we are thinking of morphisms.
XBut not any morphism.
XWe need, we wish, to preserve some properties.
XWe introduce the
Xhomomorphisms.
X
X\begin{itemize}
X  \item
X    {\em HOMORPHISM:}
X  
X    An {\bf homomorphism}
X    is a morphism between (signatures of) algebras
X    such that two terms of the same equivalence class in the original
X    algebra
X    are mapped into terms of the same equivalence class in the image
X    algebra.
X\end{itemize}
X
XSince operations are proper functions
X(i.e. deterministic),
Xit is enough to require for every operation
Xthat the result of applying it here and then mapping there
Xis the same as first mapping arguments
Xand then applying it there.
XFormally,
X
X\medskip
X
XLet $ A_{1} = < SIG_{1}, SEM_{1} >, A_{2} = < SIG_{2}, SEM_{2} >,$
X
X$h: SIG_{1} \rightarrow SIG_{2}$  is an homomorphism iff
X$\forall t_{1}, t_{2} \in |A_{1}|$,
X
X\[A_{1} \vdash t_{1} = t_{2} \Rightarrow A_{2} \vdash h(t_{1}) = h(t_{2})\]
X
Xand
X$\forall (op: s_{1} \ldots s_{n} \rightarrow s_{r}) \in F_{1},
X           t_{1}: s_{1}, \ldots, t_{n}: s_{n},$
X
X\[h (op(t_{1}\ldots t_{n})) = h(op) (h(t_{1})\ldots h(t_{n}))\]
X
XWe shall usually write
X$h: A_{1} \rightarrow A_{2}$.
XIn the previous (long) definition,
Xplease notice that the implication goes from left to right.
XThat is,
XNOBODY requires an homomorphism to guarantee that
X
X\[A_{1} \vdash t_{1} = t_{2} \Leftarrow A_{2} \vdash h(t_{1}) = h(t_{2})\]
X
XLet's put a familiar example.
XThe most widely used homomorphism I know of is the KERMIT\footnote{
X    Kermit is a widely used program to transfer data from one computer to
X    another.
X    }.
XAt my institution I have a VAX and a SUN.
XLet $mine.p$ be a pascal program.
XLet us have two evaluation functions\footnote{
X    Compile + link + execute.
X    }
X
X\begin{center}
X  \begin{tabular}{lll}
X    VAX: pascal-program  & $\rightarrow$ &  result in algebra VAX       \\
X    SUN: pascal-program  & $\rightarrow$ &  result in algebra SUN
X  \end{tabular}
X\end{center}
X
XThe KERMIT is a morphism,
X$kermit: VAX \rightarrow SUN$,
Xthat allows me to evaluate in the VAX and
Xbring the result to the SUN,
X$kermit (VAX (mine.p))$
Xor bring it to the SUN and evaluate in this last system
X$SUN (kermit (mine.p))$.
X$kermit$ is an homomorphism because
X
X\[kermit (VAX (mine.p)) = SUN (kermit (mine.p))\]
X
XThe property of kermit is that any program that runs in the VAX,
Xwill run in the SUN too,
Xand we obtain the same result everywhere.
X
XAt my institution,
Xthe Pascal version in the SUN is a superset of the version in the VAX.
XSo,
Xit is guaranteed that any program that runs in the VAX will run in the
XSUN,
Xbut not the other way round.
XIf it were too in both directions,
Xwe would have a nice {\em isomorphism}.
X
X\subsubsection{Properties}
X\begin{itemize}
X  \item
X    Identity.
X
X    $\forall A = <SIG, sem>$, $\exists$ homomorphism $I$,
X    
X    $I: SIG \rightarrow SIG$
X
X    that maps every (ground) term on itself.
X
X    \[\forall t \in |A|,  I (t) = t\]
X
X  \item
X    Transitivity.
X
X    Let $h_{1}: A_{1} \rightarrow A_{2}$
X    and $h_{2}: A_{2} \rightarrow A_{3}$
X    be homomorphisms.
X    
X    Then $h_{1} \circ h_{2}: A_{1} \rightarrow A_{3}$
X    is an homomorphism too.
X
X  \item
X    Associativity.
X
X    \[h_{1} \circ (h_{2} \circ h_{3}) = (h_{1} \circ h_{2}) \circ h_{3}\]
X
X  \item
X    Bottom.
X
X    $\forall A$, $\exists$ homomorphism $h$,
X    
X    $h: A \rightarrow$ bottom algebra.
X
X    It is the trivial homomorphism that collapses everything.
X
X  \item
X    Partial ordering.
X
X    The previous properties permits to define a partial ordering between
X    models for a given signature.
X
X    \[A_{1} \geq A_{2} \Leftrightarrow \exists h: A_{1} \rightarrow A_{2}\]
X\end{itemize}
X
X\subsection{Isomorphisms}
XSome homomorphisms are bijective.
XThat means there is an inverse homomorphism such that
Xthe composition of both gives the identity
X
X\[h \circ h'  =  h' \circ h  =  I\]
X
XSuch homomorphisms with an inverse are called
X{\bf isomorphisms}.
XAn isomorphism  \(i: A_{1} \rightarrow A_{2}\) guarantees
X
X\[A_{1} \vdash t_{1} = t_{2} \Leftrightarrow A_{2} \vdash i(t_{1}) = i(t_{2})\]
X
XGoing back to the example of the {\em kermit},
Xif the two systems support the same Pascal standard,
Xthe {\em kermit} becomes an isomorphism.
X
X\subsection{Examples}
XLet's put again our type $Mod2$.
X
X\begin{verbatim}
X        type Mod2 is
X          sorts   bit
X          opns    0, 1  :          -> bit
X                  _ + _ : bit, bit -> bit
X          semantics
X                  + | 0 1
X                 ---+-----
X                  0 | 0 1
X                  1 | 1 0
X          endtype Mod2
X\end{verbatim}
X
XAnd let's consider naturals modulo 4.
X
X\begin{verbatim}
X        type Mod4 is
X          sorts   n.4
X          opns    0, 1, 2, 3  :          -> n.4
X                  _ ++ _      : n.4, n.4 -> n.4
X          semantics
X                 ++ | 0 1 2 3
X                 ---+---------
X                  0 | 0 1 2 3
X                  1 | 1 2 3 0
X                  2 | 2 3 0 1
X                  3 | 3 0 1 2
X          endtype Mod4
X\end{verbatim}
X
XWe can easily find an homomorphism
X
X\[h: Mod4 \rightarrow Mod2\]
X
XThere are many of them.
XOne of the easiest would be
X
X\[\begin{array}{lll}
Xh (n.4) & = & bit       \\
X                        \\
Xh  (0) & = & 0          \\
Xh  (1) & = & 1          \\
Xh  (2) & = & 0          \\
Xh  (3) & = & 1          \\
Xh (++) & = & +
X\end{array}\]
X
XNotice the equivalence of {\em evaluating} in both algebras
X
X\begin{center}
X  \begin{tabular}{lll}
X    Mod4 & $h(Mod2)$ & Mod2 \\
X    \hline
X    $1 ++ 2$ & $h(1) h(++) h(2)$ & $1 + 0$      \\
X    $3$      & $h(3)$            & $1$  \\
X    \hline
X  \end{tabular}
X\end{center}
X
XNotice there is no inverse homomorphism,
Xso $h$ is not an isomorphism.
X
XNow,
Xlet's consider the algebra of parities.
X
X\begin{verbatim}
X        type Parity is
X          sorts   parity
X          opns    even, odd  :                -> parity
X                  _ * _      : parity, parity -> parity
X          semantics
X                    *  | even odd
X                 ------+----------
X                  even | even odd
X                  odd  | odd  even
X          endtype Parity
X\end{verbatim}
X
XHere we can easily find an homomorphism
Xthat is an isomorphism,
X
X\[\begin{array}{rclrcl}
Xi: Parity  & \rightarrow & Mod2 & i': Mod2 & \rightarrow & Parity       \\
X                                                                        \\
Xi (parity) & =           & bit  & i' (bit) & =           & parity       \\
X                                                                        \\
Xi (even)   & =           & 0    & i' (0)   & =           & even         \\
Xi (odd)    & =           & 1    & i' (1)   & =           & odd          \\
Xi (*)      & =           & +    & i' (+)   & =           & *
X\end{array}\]
X
X\subsection{Representation Independence}
XLast example shows that the existence of an isomorphism between two
Xalgebras means both algebras are very similar.
XIn fact, the difference between them is just a matter of names.
XThe isomorphism is not much more than a translation cipher
Xthat preserves semantics.
X
XThus,
Xit is usual to say that two algebras related by an isomorphism are
Xjust two representations of the same idea.
XAbstract data types are algebras defined up to isomorphism.
XSo,
Xwe say they are representation independent.
XThat's the reason they are tagged as
X{\bf abstract}.
X
XThere are many examples of isomorphic algebras:
X
X\begin{center}
X  \begin{tabular}{ll}
X    \hline
X    binary              & decimal               \\
X    arabic numerals     & roman numerals        \\
X    ascii               & ebcdic                \\
X    prefix notation     & postfix notation      \\
X    \hline
X  \end{tabular}
X\end{center}
X
X\subsection{Categories}
XAs already stated,
Xgiven an signature {\em SIG},
Xthere may be many models or algebras
X
X\[A = < SIG, semantics > = < S, F, semantics >\]
X
Xthat share the same signature.
XThese many models are related by homomorphisms
Xthat establish a partial ordering.
XThe collection of models and homomorphisms is known as a
X{\bf category}.
X
XA model differs from others in the partition into equivalence classes.
X
X\subsubsection{Categories as DAGs}
XFor the very simple type
X
X\begin{verbatim}
X        type ST is
X          sorts
X            s
X          opns
X            A, B, C:  -> s
X          endtype
X\end{verbatim}
X
XThe set of ground terms may be drawn as
X
X\begin{center}
X  \begin{picture}(0, 20)
X    \special{psfile=bottom3.ps}
X  \end{picture}
X\end{center}
X
Xthat may be partitioned in different ways
X
X\begin{center}
X  \begin{picture}(0, 80)
X    \special{psfile=all3.ps}
X  \end{picture}
X\end{center}
X
XEach model having different properties\footnote{
X     We shall speak in terms of $=$ and $\not=$
X     because that is what is needed in LOTOS.
X     }:
X
X\begin{center}
X  \begin{picture}(0, 80)
X    \special{psfile=some3.ps}
X  \end{picture}
X\end{center}
X
XSince equality is transitive,
Xwe can just write $A=B=C$.
X
XThe point is that every single model can be uniquely determined by means of
Xequalities and unequalities.
X
XModels are ordered by homomorphisms
X(the arrows in the previous picture)
X
X\[\begin{array}{lrl}
Xh_{1}: & h_{1} (A) & = A        \\
X       & h_{1} (B) & = A        \\
X       & h_{1} (C) & = C        \\
X                                \\
Xh_{2}: & h_{2} (A) & = A        \\
X       & h_{2} (B) & = A        \\
X       & h_{2} (C) & = A
X\end{array}\]
X
XSo,
Xthe category of models for a signature
Xis a
X{\bf dag}
X{\em (directed acyclic graph)}
Xwhere the first node is the word algebra
Xand the last,
Xthe bottom algebra.
X
XSchematically, categories can be drawn as
X
X\begin{center}
X  \begin{picture}(0, 40)
X    \put(0, 32){\makebox(0, 0)[b]{word algebra}}
X    \put(0, 30){\line(-1, -1){10}}
X    \put(0, 30){\line( 1, -1){10}}
X    \put(-10, 20){\vector( 1, -1){10}}
X    \put( 10, 20){\vector(-1, -1){10}}
X    \put(0, 8){\makebox(0, 0)[t]{bottom algebra}}
X  \end{picture}
X\end{center}
X
X\subsubsection{Initial Algebra}
XFor the slightly more complex type
X
X\begin{verbatim}
X        type T is
X          sorts
X            s
X          opns
X            A, B, C, D:  -> s
X          endtype
X\end{verbatim}
X
XThe set of ground terms is
X
X\begin{center}
X  \begin{picture}(0, 20)
X    \special{psfile=bottom4.ps hscale=0.6 vscale=0.6}
X  \end{picture}
X\end{center}
X
Xthat may be partitioned in 15 different ways.
XThe total set of models,
Xwithout caring for semantics,
X$Alg (SIG)  or  Alg (SIG, \emptyset)$ is as follows,
X
X\begin{center}
X  \begin{picture}(0, 120)
X    \special{psfile=all4.ps hscale=0.5 vscale=0.5}
X  \end{picture}
X\end{center}
X
XThis category can be reduced by means of semantics.
XIn the previous example we showed how to choose just one model by
Xmeans of equalities and unequalities.
XMore general situations may be devised.
X
XIf we impose just one equality,
Xwe restrict the category to
X
X\[Alg (SIG, \{C = D\})\]
X
X\begin{center}
X  \begin{picture}(0, 85)
X    \special{psfile=sub41.ps hscale=0.6 vscale=0.6}
X  \end{picture}
X\end{center}
X
XWe can further reduce it by adding more equalities
X
X\[Alg (SIG, \{C=D, A=C\})\]
X
X\begin{center}
X  \begin{picture}(0, 55)
X    \special{psfile=sub42.ps hscale=0.6 vscale=0.6}
X  \end{picture}
X\end{center}
X
XNotice there is a very closed relationship between imposing equalities
Xand moving down along the graph of partially ordered models.
XThe reason is obvious:
Xan homomorphism cannot make distinct was was equal,
Xbut may make equal what was not specified.
X
XThus,
Xthere is always a sub-dag of partially ordered models.
XThat dag has always a unique first node,
Xby construction.
XThat first node is called the
X{\bf initial}
X{\bf model}
Xof the sub-category.
X
XThe initial model is the one that makes
Xas many equivalence classes as possible.
XAny other model in the dag goes further identifying terms.
XIn other words,
Xin the initial model everything is different unless explicitly
Xstated.
X
XBecause of homomorphism transitivity,
Xwe can formally define the initial model.
XGiven a category Alg(SIG,\ sem),
Xwe say 
X$A$
Xis the initial model in the category
Xiff for every model
X$B$
Xin it there exists an homomorphism
X$h: A \rightarrow B$.
X
XWe can identify as well a last node in the dag.
XIt is called the
X{\bf final model}.
XFor $=$ specified sub-categories,
Xit is ALWAYS the bottom algebra.
X
X\begin{center}
X  \begin{picture}(0, 60)
X    \put(0, 52){\makebox(0, 0)[b]{word algebra}}
X    \put(0, 50){\line(-1, -1){20}}
X    \put(0, 50){\line( 1, -1){20}}
X    \put(0, 32){\makebox(0, 0)[b]{{\bf initial}}}
X    \put(0, 30){\vector(-1, -1){10}}
X    \put(0, 30){\vector( 1, -1){10}}
X    \put(-20, 30){\vector( 1, -1){20}}
X    \put( 20, 30){\vector(-1, -1){20}}
X    \put(0, 8){\makebox(0, 0)[t]{bottom algebra = final algebra}}
X  \end{picture}
X\end{center}
X
X\subsubsection{Unequalities}
XSemantics can be specified by means of unequalities.
XThe effect on the category of models is to reduce it.
XFor example,
X
X\[Alg (SIG, \{B \not= C, B \not= D,  C \not= D\})\]
X
X\begin{center}
X  \begin{picture}(0, 55)
X    \special{psfile=sub43.ps hscale=0.6 vscale=0.6}
X  \end{picture}
X\end{center}
X
XThe initial model of sub-categories selected by unequalities
Xis ALWAYS the word algebra.
X
XNotice there is no unique last node.
XIn this case, there are three.
XSo, we say there is no final model.
X
X\begin{center}
X  \begin{picture}(0, 60)
X    \put(0, 52){\makebox(0, 0)[b]{word algebra = initial algebra}}
X    \put(0, 50){\line(-1, -1){20}}
X    \put(0, 50){\line( 1, -1){20}}
X    \put(-10, 40){\vector( 1, -1){8}}
X    \put( 10, 40){\vector(-1, -1){8}}
X    \put(0, 28){\makebox(0, 0)[t]{\ldots}}
X    \put(-20, 30){\vector( 1, -1){20}}
X    \put( 20, 30){\vector(-1, -1){20}}
X    \put(0, 8){\makebox(0, 0)[t]{bottom algebra}}
X  \end{picture}
X\end{center}
X
XIf we use both equals and unequals to specify semantics,
Xwe reduce our dag from the top
X(by $=$)
Xand from the bottom
X(by $\not=$).
XNevertheless,
Xby construction,
Xwe always have a first node,
Xthat is the initial model.
X
X\begin{center}
X  \begin{picture}(0, 60)
X    \put(0, 52){\makebox(0, 0)[b]{word algebra}}
X    \put(0, 50){\line(-1, -1){20}}
X    \put(0, 50){\line( 1, -1){20}}
X    \put(0, 42){\makebox(0, 0)[b]{initial}}
X    \put(0, 40){\line(-1, -1){10}}
X    \put(0, 40){\line( 1, -1){10}}
X    \put(-10, 30){\vector( 1, -1){8}}
X    \put( 10, 30){\vector(-1, -1){8}}
X    \put(0, 18){\makebox(0, 0)[t]{\ldots}}
X    \put(-20, 30){\vector( 1, -1){20}}
X    \put( 20, 30){\vector(-1, -1){20}}
X    \put(0, 8){\makebox(0, 0)[t]{bottom algebra}}
X  \end{picture}
X\end{center}
X
X\subsubsection{Positive Conditionals}
XIt is usually of practical interest to use conditional axioms as
X
X\[A = B  \Rightarrow  C = D\]
X
XIt must be read as follows:
Xa model $M$ agrees with this semantics if
Xeither $A \not= B$,
Xor both $A = B$ and $C = D$.
XNotice that when $A \not= B$,
X$C$ and $D$ may be equal or not.
X
XLet's suppose we just have equalities
Xand positive conditionals as the one shown above.
XThat is, there is no $\not=$ in the semantics.
X
XThe procedure to construct the sub-category is as follows.
XWe have two kinds of rules
X
X\begin{enumerate}
X  \item
X    $A = B$
X  \item
X    $C = D \Rightarrow E = F$
X\end{enumerate}
X
Xprocedure build ();                             \\
X\hspace*{15mm}begin                                     \\
X\hspace*{15mm}take the word algebra;                    \\
X\hspace*{15mm}for each rule (1. $A=B$)                  \\
X\hspace*{25mm}go {\em down} into the sub-dag $A=B$;     \\
X\hspace*{15mm}while $\exists$ (2. $C = D \Rightarrow E = F$)      \\
X\hspace*{18mm}if $C=D$ is in the current initial model  \\
X\hspace*{25mm}go {\em down} into the sub-dag $E = F$;   \\
X\hspace*{25mm}clear out this equation;                  \\
X\hspace*{15mm}end;
X
XConditional axioms must be reconsidered every time we go into a
Xsub-dag,
Xbecause there is a new initial model to test.
XAt the end,
Xthere may be some equations
X$C = D \Rightarrow E = F$
Xfor none of which $C = D$
Xaccording to the current initial model.
XThese ones are just dropped.
XThis construction procedure guarantees there is always an initial
Xmodel.
X
X\subsubsection{Negative conditionals}
XNegative conditionals may yield dags without an initial model.
XJust let's put an example.
X
X\[Alg (SIG, \{B \not= C  \Rightarrow  A = B\})\]
X
XThe semantics may be expanded into
X
X\[\begin{array}{ccc}
XB = C     &     &       \\
XB \not= C & and & A = B
X\end{array}\]
X
XThe sub-category is
X
X\begin{center}
X  \begin{picture}(0, 85)
X    \special{psfile=sub44.ps hscale=0.6 vscale=0.6}
X  \end{picture}
X\end{center}
X
XWhere there is no unique initial model.
X\subsection{The Model in LOTOS}
XIn LOTOS only equalities and positive conditionals are allowed.
XThus,
Xthere is always an initial model.
XThere is always a final model too:
Xthe bottom algebra.
X
XIn LOTOS we just choose one model for each type,
Xthe
X{\em INITIAL MODEL}.
X
XNotice we have to select one single model to make precise whether two
Xterms are equal or not.
X
XSometimes we say LOTOS specifies types equationally
Xwith initial semantics.
XThis expression is rather strange,
Xbut readers must be able to understand it so far.
X
X\section{Further Readings}
X\cite{kn:is8807-88} is the standard reference for LOTOS,
Xboth syntax and semantics.
XIt's hard to read,
Xbut it's definitely the last word about the language.
XA tutorial introduction may be found in appendix C of this document.
XA much better tutorial may be found in
X\cite{kn:bolognesi-87}.
X
XNearly every paper on ADTs starts with a very brief presentation of
Xsignatures, sorts, etc.
XBut every author has its own peculiarities and definitions,
Xwhat creates lots of confusion to beginners.
X
XPedagogic presentations can be found in \cite{kn:wagner-81}
Xand \cite{kn:burstall-82}.
XThey are intended for beginners.
X
XAn introduction to lattices (categories) of models can be found in
X\cite{kn:broy-81}.
XAfter introducing the objects, the authors go into demonstrating
Xtheorems.
XThe standard reference for category theory is \cite{kn:maclane-72},
Xbut normal readers should not need it.
X
XThe last word on ADTs in
XACT ONE\footnote{
X    The {\em mother} of LOTOS data types.
X    }
Xis \cite{kn:ehrig-85},
Xbut it is not really intended for beginners.
X
XIt has been shown in many papers,
Xafter \cite{kn:majster-77},
Xthat extra operations are usually needed to specify an ADT
Xwith a finite number of equations.
XThese are called
X{\bf hidden operations}.
XIn LOTOS nothing is hidden,
Xso if an extra operation is needed,
Xit will be visible outside the ADT.
XHidden operations arise the much more general question of
X{\bf overspecification}:
X{\em are these the minimal requirements on the ADT?}
Xor, {\em are we imposing more equivalences than required?}
XThe answer to these questions is far from clear,
Xis usually undecidable,
Xand is definitely out of the scope of this tutorial.
X
X\begin{thebibliography}{Bolognesi, 87}
X
X\bibitem[Bolognesi, 87]{kn:bolognesi-87}
XT. Bolognesi and
XE. Brinksma.
XIntroduction to the ISO Specification Language LOTOS.
XComputer Networks and ISDN Systems,
X14(1), pp. 25-59,
XNorth Holland, Jan. 1987.
X
X\bibitem[Broy, 81]{kn:broy-81}
XM. Broy,
XA C. Pair and
XM. Wirsing.
XA Systematic Study of Models of Abstract Data Types.
X1981.
X
X\bibitem[Burstall, 82]{kn:burstall-82}
XR.M. Burstall and
XJ.A. Goguen.
XAlgebras, Theories and Freeness:
XAn Introduction for Computer Scientists.
XProc. 1981 Marktoberdorf NATO Summer School,
XReidel,
X1982.
Xpp. 329-348.
X
X\bibitem[Ehrig, 85]{kn:ehrig-85}
XH. Ehrig and
XB. Mahr.
XFundamentals of Algebraic Specification. Part 1.
XSpringer Verlag,
XBerlin,
X1985.
X
X\bibitem[ISO, 88]{kn:is8807-88}
XISO - Information Processing Systems -
XOpen Systems Interconnection -
XLOTOS, A Formal Description Technique Based
Xon the Temporal Ordering of Observational Behaviour.
XIS 8807, 1988.
X
X\bibitem[MacLane, 72]{kn:maclane-72}
XS. MacLane.
XCategories for the Working Mathematician.
XSpringer,
XNew York- Heidelberg- Berlin,
X1972.
X
X\bibitem[Majster, 77]{kn:majster-77}
XM.E. Majster.
XLimits of the "Algebraic" Specification of Abstract Data Types.
XSIGPLAN Notices, 12-10,
Xpp. 37-42,
XOctober, 1977.
X
X\bibitem[Wagner, 81]{kn:wagner-81}
XE. Wagner.
XLecture Notes on the Algebraic Specification of Data Types.
XRC 9203,
XIBM, Thomas J. Watson Research Center,
XYorktown Heights, New York,
X1981.
X\end{thebibliography}
X\end{document}
X
X%% Local Variables:
X%% mode:indented-text
X%% comment-column:60
X%% comment-start:"%"
X%% comment-end:""
X%% End:
END_OF_adt.fund.tex
if test 39062 -ne `wc -c <adt.fund.tex`; then
    echo shar: \"adt.fund.tex\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f all3.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"all3.ps\"
else
echo shar: Extracting \"all3.ps\" \(3381 characters\)
sed "s/^X//" >all3.ps <<'END_OF_all3.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 70 translate
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X150 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X270 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgrestore
Xgsave
X20 70 moveto
X(word algebra) show
Xgrestore
Xgsave -30 40 translate
Xgsave
X30 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X270 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave 0 40 translate
Xgsave
X150 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X270 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave 30 40 translate
Xgsave
X150 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave 0 10 translate
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave
X20 10 moveto
X(bottom algebra) show
Xgrestore
X0.200000 setlinewidth
Xgsave
X0 70 translate
X-30 -30 atan rotate
Xnewpath
X10 0 moveto
X1800 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-17 57 moveto
X(h1)
Xdup stringwidth pop neg
X0 rmoveto show
Xgrestore
Xgsave
X0 70 translate
X-30 0 atan rotate
Xnewpath
X10 0 moveto
X900 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 70 translate
X-30 30 atan rotate
Xnewpath
X10 0 moveto
X1800 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-30 40 translate
X-30 30 atan rotate
Xnewpath
X10 0 moveto
X1800 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-17 20 moveto
X(h2)
Xdup stringwidth pop neg
X0 rmoveto show
Xgrestore
Xgsave
X0 40 translate
X-30 0 atan rotate
Xnewpath
X10 0 moveto
X900 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X30 40 translate
X-30 -30 atan rotate
Xnewpath
X10 0 moveto
X1800 sqrt 10 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_all3.ps
if test 3381 -ne `wc -c <all3.ps`; then
    echo shar: \"all3.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f all4.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"all4.ps\"
else
echo shar: Extracting \"all4.ps\" \(14045 characters\)
sed "s/^X//" >all4.ps <<'END_OF_all4.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 205 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 15 translate
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave -100 155 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 -100 atan rotate
Xnewpath
X15 0 moveto
X12500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave -60 155 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 -60 atan rotate
Xnewpath
X15 0 moveto
X6100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave -20 155 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 -20 atan rotate
Xnewpath
X15 0 moveto
X2900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 20 155 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 20 atan rotate
Xnewpath
X15 0 moveto
X2900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 60 155 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 60 atan rotate
Xnewpath
X15 0 moveto
X6100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 100 155 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 205 translate
X-50 100 atan rotate
Xnewpath
X15 0 moveto
X12500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave -120 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X-120 65 translate
X-50 120 atan rotate
Xnewpath
X15 0 moveto
X16900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave -80 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X-80 65 translate
X-50 80 atan rotate
Xnewpath
X15 0 moveto
X8900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave -40 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X-40 65 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 0 65 translate
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 65 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 40 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X40 65 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 80 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X80 65 translate
X-50 -80 atan rotate
Xnewpath
X15 0 moveto
X8900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave 120 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X120 65 translate
X-50 -120 atan rotate
Xnewpath
X15 0 moveto
X16900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-100 155 translate
X-90 -20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-100 155 translate
X-90 20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-100 155 translate
X-90 100 atan rotate
Xnewpath
X15 0 moveto
X18100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-60 155 translate
X-90 60 atan rotate
Xnewpath
X15 0 moveto
X11700 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-60 155 translate
X-90 140 atan rotate
Xnewpath
X15 0 moveto
X27700 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-60 155 translate
X-90 180 atan rotate
Xnewpath
X15 0 moveto
X40500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-20 155 translate
X-90 -20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-20 155 translate
X-90 20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-20 155 translate
X-90 60 atan rotate
Xnewpath
X15 0 moveto
X11700 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X20 155 translate
X-90 -140 atan rotate
Xnewpath
X15 0 moveto
X27700 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X20 155 translate
X-90 20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X20 155 translate
X-90 100 atan rotate
Xnewpath
X15 0 moveto
X18100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X60 155 translate
X-90 -180 atan rotate
Xnewpath
X15 0 moveto
X40500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X60 155 translate
X-90 -100 atan rotate
Xnewpath
X15 0 moveto
X18100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X60 155 translate
X-90 20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X100 155 translate
X-90 -180 atan rotate
Xnewpath
X15 0 moveto
X40500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X100 155 translate
X-90 -140 atan rotate
Xnewpath
X15 0 moveto
X27700 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X100 155 translate
X-90 20 atan rotate
Xnewpath
X15 0 moveto
X8500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_all4.ps
if test 14045 -ne `wc -c <all4.ps`; then
    echo shar: \"all4.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f bottom3.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"bottom3.ps\"
else
echo shar: Extracting \"bottom3.ps\" \(394 characters\)
sed "s/^X//" >bottom3.ps <<'END_OF_bottom3.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 10 translate
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
END_OF_bottom3.ps
if test 394 -ne `wc -c <bottom3.ps`; then
    echo shar: \"bottom3.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f bottom4.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"bottom4.ps\"
else
echo shar: Extracting \"bottom4.ps\" \(470 characters\)
sed "s/^X//" >bottom4.ps <<'END_OF_bottom4.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 10 translate
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
END_OF_bottom4.ps
if test 470 -ne `wc -c <bottom4.ps`; then
    echo shar: \"bottom4.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f some3.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"some3.ps\"
else
echo shar: Extracting \"some3.ps\" \(1495 characters\)
sed "s/^X//" >some3.ps <<'END_OF_some3.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave -20 70 translate
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X150 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X270 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 70 moveto
X(A <> B, A <> C, B <> C) show
Xgrestore
Xgsave -20 40 translate
Xgsave
X30 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
X270 rotate
Xnewpath
X0 0 moveto
X10 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave
X0 40 moveto
X(A = B, A <> C, B <> C) show
Xgrestore
Xgsave -20 10 translate
Xgsave
Xnewpath
X0 0 10 0 360 arc
Xstroke
Xgrestore
Xgsave
X0 3 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-4 -5 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X4 -5 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgrestore
Xgsave
X0 10 moveto
X(A = B, A = C, B = C) show
Xgrestore
END_OF_some3.ps
if test 1495 -ne `wc -c <some3.ps`; then
    echo shar: \"some3.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f sub41.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"sub41.ps\"
else
echo shar: Extracting \"sub41.ps\" \(3735 characters\)
sed "s/^X//" >sub41.ps <<'END_OF_sub41.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 115 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave -40 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 65 translate
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 40 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 15 translate
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 115 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 115 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 115 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-40 65 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 65 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X40 65 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_sub41.ps
if test 3735 -ne `wc -c <sub41.ps`; then
    echo shar: \"sub41.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f sub42.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"sub42.ps\"
else
echo shar: Extracting \"sub42.ps\" \(1178 characters\)
sed "s/^X//" >sub42.ps <<'END_OF_sub42.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 15 translate
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 65 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_sub42.ps
if test 1178 -ne `wc -c <sub42.ps`; then
    echo shar: \"sub42.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f sub43.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"sub43.ps\"
else
echo shar: Extracting \"sub43.ps\" \(3268 characters\)
sed "s/^X//" >sub43.ps <<'END_OF_sub43.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave 0 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave -40 15 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 15 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 40 15 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X0 65 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 65 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 65 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_sub43.ps
if test 3268 -ne `wc -c <sub43.ps`; then
    echo shar: \"sub43.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f sub44.ps -a "${1}" != "-c" ; then 
  echo shar: Will not over-write existing file \"sub44.ps\"
else
echo shar: Extracting \"sub44.ps\" \(6356 characters\)
sed "s/^X//" >sub44.ps <<'END_OF_sub44.ps'
X%!
X2.835000 2.835000 scale
X0.400000 setlinewidth
X/Helvetica findfont 5 scalefont setfont
Xgsave -40 115 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 40 115 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave -80 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave -40 65 translate
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 30 150 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 40 65 translate
Xgsave
X150 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 150 270 arc
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 80 65 translate
Xgsave
X270 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
X30 rotate
Xnewpath
X5 0 moveto
X15 0 lineto
Xstroke
Xgrestore
Xgsave
Xnewpath
X0 0 5 270 30 arc
Xstroke
Xgrestore
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave 0 15 translate
Xgsave
X0 -2 moveto
X(A)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X0 8 moveto
X(B)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X8 -8 moveto
X(C)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
X-8 -8 moveto
X(D)
Xdup stringwidth pop 2 div neg
X0 rmoveto show
Xgrestore
Xgsave
Xnewpath
X0 0 15 0 360 arc
Xstroke
Xgrestore
Xgrestore
Xgsave
X-40 115 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-40 115 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-40 115 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X40 115 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X40 115 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X40 115 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-80 65 translate
X-50 80 atan rotate
Xnewpath
X15 0 moveto
X8900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X-40 65 translate
X-50 40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X0 65 translate
X-50 0 atan rotate
Xnewpath
X15 0 moveto
X2500 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X40 65 translate
X-50 -40 atan rotate
Xnewpath
X15 0 moveto
X4100 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
Xgsave
X80 65 translate
X-50 -80 atan rotate
Xnewpath
X15 0 moveto
X8900 sqrt 15 sub 0 lineto
X-4 2 rmoveto
X4 -2 rlineto
X-4 -2 rmoveto
X4 2 rlineto
Xstroke
Xgrestore
END_OF_sub44.ps
if test 6356 -ne `wc -c <sub44.ps`; then
    echo shar: \"sub44.ps\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of shell archive.
exit 0
