Include [SaffronBaseDecls, SaffronAG];

SaffronCentral: Control Module;

SaffronCG1: Module = Begin
{
"TC"
"ABS" "ALL" "AND" "ANY" "APPLY" "ARRAY"
"BASE" "BEGIN" "BROADCAST"
"CEDAR" "CHECKED" "CODE" "COMPUTED" "CONS" "CONTINUE"
"DECREASING" "DEFINITIONS" "DEPENDENT" "DESCRIPTOR" "DIRECTORY" "DO"
"ELSE" "ENABLE" "END" "ENDCASE" "ENDLOOP" "ENTRY" "ERROR" "EXIT" "EXITS" "EXPORTS"
"FINISHED" "FIRST" "FOR" "FORK" "FRAME" "FREE" "FROM"
"GO" "GOTO"
"IF" "IMPORTS" "IN" "INLINE" "INTERNAL" "ISTYPE"
"JOIN"
"LAST" "LENGTH" "LIST" "LOCKS" "LONG" "LOOP" "LOOPHOLE"
"MACHINE" "MAX" "MIN" "MOD" "MONITOR" "MONITORED"
"NARROW" "NEW" "NIL" "NOT" "NOTIFY" "NULL"
"OF" "OPEN" "OR" "ORD" "ORDERED" "OVERLAID"
"PACKED" "PAINTED" "POINTER" "PORT" "PRED" "PRIVATE" "PROC" "PROCEDURE" "PROCESS" "PROGRAM" "PUBLIC"
"READONLY" "RECORD" "REF" "REJECT" "RELATIVE" "REPEAT" "RESTART" "RESUME" "RETRY" "RETURN" "RETURNS"
"SAFE" "SELECT" "SEQUENCE" "SHARES" "SIGNAL" "SIZE" "START" "STATE" "STOP" "SUCC"
"THEN" "THROUGH" "TO" "TRANSFER" "TRASH" "TRUSTED" "TYPE"
"UNCHECKED" "UNCOUNTED" "UNSAFE" "UNTIL" "USING"
"VAL" "VAR"
"WAIT" "WHILE" "WITH"
"ZONE"
"!" "#" "(" ")" "*" "+" "," "-" "." ".." "/" ":" ";" "<" "<=" "=" "=>" ">" ">=" "@"
"[" "]" "^" "_" "{" "|" "}" "~"
} : SimpleTokens;

maingoal:	NonTerminal Builds Top;
for maingoal	_ top
Build	top;

top:	NonTerminal Builds Top;
for top.modulep	_ goal
Build	Top.modulep[goal];
for top.scope	_ "BEGIN" scope "END"
Build	Top.scope[scope];
for top.tc	_ "TC" typeexp 
Build	Top.tc[typeexp];

goal:	NonTerminal Builds ModuleP;
for goal.a	_ module "."
Build	module;
for goal.b	_ module ".."
Build	module;

module:	NonTerminal Builds ModuleP;
for module.impl	_ directory identlist cedar proghead trusted checked block
Build	ModuleP.impl[directory, identlist, cedar, proghead, checked, block];
for module.def	_ directory identlist cedar defhead defbody
Build	ModuleP.def[directory, identlist, cedar, defhead, defbody];

directory:	NonTerminal Builds Directory;
for directory.a	_ "DIRECTORY" ";"
Build	Directory.empty[];
for directory.b	_ "DIRECTORY" includelist ";"
Build	includelist;
for directory.c	_ -- << empty >>
Build	Directory.empty[]; 

includelist:	NonTerminal Builds Directory;
for includelist.a	_ includeitem
Build	Directory.more[Directory.empty[[includeitem, includeitem)], includeitem];
for includelist.b	_ includelist "," includeitem
Build	Directory.more[includelist, includeitem];

includeitem:	NonTerminal Builds IncludeItem;
for includeitem.a	_ Id ":" "FROM" String using
Build	IncludeItem.fromp[Id, String, using];
for includeitem.b	_ Id ":" "TYPE" using
Build	IncludeItem.type[Id, using];
for includeitem.c	_ Id using
Build	IncludeItem.plain[Id, using];
for includeitem.d	_ Id.local ":" "TYPE" Id.global using
Build	IncludeItem.typeandid[Id.local, Id.global, using];

using:	NonTerminal Builds Using;
for using.nothing	_ "USING" "[" "]"
Build	Using.nothing[];
for using.restricted	_ "USING" "[" idlist "]"
Build	Using.restricted[idlist];
for using.unrestricted	_ -- << empty >>
Build	Using.unrestricted[]; 

defbody:	NonTerminal Builds DefBody;
for defbody.a	_ "BEGIN" open declist "END"
Build	DefBody[open, declist];
for defbody.b	_ "BEGIN" open declist ";" "END"
Build	DefBody[open, declist];
for defbody.c	_ "{" open declist "}"
Build	DefBody[open, declist];
for defbody.d	_ "{" open declist ";" "}"
Build	DefBody[open, declist];

defhead:	NonTerminal Builds DefHead;
for defhead	_ definitions locks imports shares tilde public
Build	DefHead[locks, imports, shares, public];

definitions:	NonTerminal Builds Junk;
for definitions	_ "DEFINITIONS"
Build	Junk[];

cedar:	NonTerminal Builds Cedar;
for cedar.yes	_ "CEDAR"
Build	Cedar.yes[];
for cedar.no	_ -- << empty >>
Build	Cedar.no[]; 

proghead:	NonTerminal Builds ProgHead;
for proghead	_ resident safe class arguments locks interface tilde public
Build	ProgHead[safe, class, arguments, locks, interface, public];

resident:	NonTerminal Builds Junk;
for resident	_ -- << empty >>
Build	Junk[];

class:	NonTerminal Builds Class;
for class.program	_ "PROGRAM"
Build	Class.program[];
for class.monitor	_ "MONITOR"
Build	Class.monitor[];

interface:	NonTerminal Builds Interface;
for interface	_ imports exports shares
Build	Interface[imports, exports, shares];

exports:	NonTerminal Builds ModuleList;
for exports.a	_ "EXPORTS"
Build	ModuleList.empty[];
for exports.b	_ "EXPORTS" modulelist
Build	modulelist;
for exports.c	_ -- << empty >>
Build	ModuleList.empty[]; 

binditem:	NonTerminal Builds BindItem;
for binditem.a	_ exp
Build	BindItem.unnamed[exp];
for binditem.b	_ Id ":" exp
Build	BindItem.named[Id, exp];
for binditem.c	_ Id "~" "~" exp
Build	BindItem.named[Id, exp];

caselabel:	NonTerminal Builds SelectLabel;
for caselabel.type	_ ident typeexp
Build	SelectLabel.type[ident, typeexp];
for caselabel.test	_ caselabelP
Build	SelectLabel.test[caselabelP];

caselabelP:	NonTerminal Builds SelectTestList;
for caselabelP.one	_ casetest
Build	SelectTestList.one[casetest];
for caselabelP.more	_ caselabelP "," casetest
Build	SelectTestList.more[caselabelP, casetest];

casetest:	NonTerminal Builds Relation;
for casetest.a	_ optrelation
Build	optrelation;
for casetest.b	_ exp
Build	Relation.positive[RelationTail.relop[Relop.eq[[exp, exp)], exp]];
block:	NonTerminal Builds Block;
for block.a	_ "BEGIN" scope exits "END"
Build	Block[scope, exits];
for block.b	_ "{" scope exits "}"
Build	Block[scope, exits];

exits:	NonTerminal Builds ExitList;
for exits.list	_ "EXITS" exitlist
Build	exitlist;
for exits.empty	_ 
Build	ExitList.empty[];

public:	NonTerminal Builds Access;
for public.public	_ "PUBLIC"
Build	Access.public[];
for public.private	_ "PRIVATE"
Build	Access.private[];
for public.empty	_ -- << empty >>
Build	Access.empty[];

End;

SaffronCG2: Module = Begin

bounds:	NonTerminal Builds Bounds;
for bounds	_ exp.lower ".." exp.upper
Build	Bounds[Bound[exp.lower], Bound[exp.upper]];

checked:	NonTerminal Builds Checked;
for checked.empty	_ -- << empty >>
Build	Checked.empty[]; 
for checked.checked	_ "CHECKED"
Build	Checked.checked[];
for checked.trusted	_ "TRUSTED"
Build	Checked.trusted[];
for checked.unchecked	_ "UNCHECKED"
Build	Checked.unchecked[];

default:	NonTerminal Builds Default;
for default.a	_ "_" defaultopt
Build	defaultopt;
for default.empty	_ -- << empty >>
Build	Default.empty[];

positionP:	NonTerminal Builds Position;
for positionP	_ "(" exp optbits ")"
Build	Position[exp, optbits];

optbits:	NonTerminal Builds OptBits;
for optbits.present	_ ":" bounds
Build	OptBits.present[bounds];
for optbits.absent	_ -- << empty >>
Build	OptBits.absent[]; 

sum:	NonTerminal Builds Exp;
for sum.sum	_ sum addop product
Build	Exp.sum[sum, addop, product];
for sum.product	_ product
Build	product;

product:	NonTerminal Builds Exp;
for product.product	_ product multop factor
Build	Exp.product[product, multop, factor];
for product.factor	_ factor
Build	factor;

multop:	NonTerminal Builds MultOp;
for multop.times	_ "*"
Build	MultOp.times[];
for multop.divide	_ "/"
Build	MultOp.divide[];
for multop.mod	_ "MOD"
Build	MultOp.mod[];

factor:	NonTerminal Builds Exp;
for factor.unarysum	_ addop primary
Build	Exp.unarysum[addop, primary]; 
for factor.primary	_ primary
Build	primary;

addop:	NonTerminal Builds AddOp;
for addop.plus	_ "+"
Build	AddOp.plus[];
for addop.minus	_ "-"
Build	AddOp.minus[];

readonly:	NonTerminal Builds ReadOnly;
for readonly.yes	_ "READONLY"
Build	ReadOnly.yes[];
for readonly.no	_ -- << empty >>
Build	ReadOnly.no[];

catchany:	NonTerminal Builds CatchAny;
for catchany	_ "ANY" "=>" statement
Build	CatchAny.present[statement];

interval:	NonTerminal Builds Interval;
for interval.cc	_ "[" bounds "]"
Build	Interval.cc[bounds];
for interval.oc	_ "(" bounds "]"
Build	Interval.oc[bounds];
for interval.co	_ "[" bounds ")"
Build	Interval.co[bounds];
for interval.oo	_ "(" bounds ")"
Build	Interval.oo[bounds];

exp:	NonTerminal Builds Exp;
for exp.ifthenelse	_ "IF" exp.cond "THEN" exp.thenpart "ELSE" exp.elsepart
Build	Exp.ifthenelse[exp.cond, exp.thenpart, exp.elsepart];
for exp.select	_ casehead caseexplist "ENDCASE" "=>" exp
Build	Exp.select[casehead, caseexplist, exp];
for exp.assign	_ lhs "_" exp
Build	Exp.assign[lhs, exp];
for exp.multiassign	_ "[" explist "]" "_" exp
Build	Exp.multiassign[explist, exp];
for exp.error	_ "ERROR"
Build	Exp.error[];
for exp.transfer	_ transferop lhs
Build	Exp.transfer[transferop, lhs];
for exp.disjunct	_ disjunct
Build	disjunct;

caseexplist:	NonTerminal Builds SelectExpList;
for caseexplist.empty	_ -- << empty >>
Build	SelectExpList.empty[];
for caseexplist.b	_ caseexplistP
Build	caseexplistP;
for caseexplist.c	_ caseexplistP ","
Build	caseexplistP;

caseexplistP:	NonTerminal Builds SelectExpList;
for caseexplistP.a	_ caseexpitem
Build	SelectExpList.more[
SelectExpList.empty[[caseexpitem, caseexpitem)],
caseexpitem
];
for caseexplistP.b	_ caseexplistP "," caseexpitem
Build	SelectExpList.more[caseexplistP, caseexpitem];

caseexpitem:	NonTerminal Builds SelectExpItem;
for caseexpitem	_ caselabel "=>" exp
Build	SelectExpItem[caselabel, exp]

End;

SaffronCG3: Module = Begin

transferop:	NonTerminal Builds TransferOp;
for transferop.signal	_ "SIGNAL"
Build	TransferOp.signal[];
for transferop.error	_ "ERROR"
Build	TransferOp.error[];
for transferop.start	_ "START"
Build	TransferOp.start[];
for transferop.join	_ "JOIN"
Build	TransferOp.join[];
for transferop.new	_ "NEW"
Build	TransferOp.new[];
for transferop.fork	_ "FORK"
Build	TransferOp.fork[];

disjunct:	NonTerminal Builds Exp; 
for disjunct.or	_ disjunct "OR" conjunct
Build	Exp.or[disjunct, conjunct];
for disjunct.conjunct	_ conjunct
Build	conjunct;

conjunct:	NonTerminal Builds Exp;
for conjunct.and	_ conjunct "AND" negation
Build	Exp.and[conjunct, negation];
for conjunct.negation	_ negation
Build	negation;

negation:	NonTerminal Builds Exp;
for negation.a	_ "~" relation
Build	Exp.not[relation];
for negation.b	_ "NOT" relation
Build	Exp.not[relation];
for negation.relation	_ relation
Build	relation;

relation:	NonTerminal Builds Exp;
for relation.relation	_ sum optrelation
Build	Exp.relation[sum, optrelation];
for relation.sum	_ sum
Build	sum;

catchlist:	NonTerminal Builds Catch;
for catchlist.a	_ catchhead catchcase
Build	Catch[
CatchCaseList.more[catchhead, catchcase],
CatchAny.absent[(catchcase, catchcase]]
];
for catchlist.b	_ catchhead
Build	Catch[catchhead,
CatchAny.absent[(catchhead, catchhead]]
];
for catchlist.c	_ catchhead catchany
Build	Catch[catchhead, catchany];
for catchlist.d	_ catchhead catchany ";"
Build	Catch[catchhead, catchany];

catchhead:	NonTerminal Builds CatchCaseList;
for catchhead.empty	_ -- << empty >>
Build	CatchCaseList.empty[];
for catchhead.more	_ catchhead catchcase ";"
Build	CatchCaseList.more[catchhead, catchcase];

ident:	NonTerminal Builds Ident;
for ident.idposition	_ Id positionP ":"
Build	Ident.idposition[Id, positionP];
for ident.id	_ Id ":"
Build	Ident.id[Id];

typeop:	NonTerminal Builds TypeOp;
for typeop.code	_ "CODE"
Build	TypeOp.code[];
for typeop.first	_ "FIRST"
Build	TypeOp.first[];
for typeop.last	_ "LAST"
Build	TypeOp.last[];
for typeop.nil	_ "NIL"
Build	TypeOp.nil[];

idlist:	NonTerminal Builds IdList;
for idlist	_ idlistP
Build	idlistP;

idlistP:	NonTerminal Builds IdList;
for idlistP.one	_ Id
Build	IdList.one[Id];
for idlistP.more	_ Id "," idlistP
Build	IdList.more[Id, idlistP];

arguments:	NonTerminal Builds Arguments;
for arguments	_ arglist returnlist
Build	Arguments[arglist, returnlist];

arglist:	NonTerminal Builds ParameterList;
for arglist.any	_ "ANY"
Build	ParameterList.any[];
for arglist.fieldlist	_ fieldlist
Build	fieldlist;
for arglist.empty	_ -- << empty >>
Build	ParameterList.empty[]; 

returnlist:	NonTerminal Builds ParameterList;
for returnlist.any	_ "RETURNS" "ANY"
Build	ParameterList.any[];
for returnlist.fieldlist	_ "RETURNS" fieldlist
Build	fieldlist;
for returnlist.empty	_ -- << empty >>
Build	ParameterList.empty[]; 

fieldlist:	NonTerminal Builds ParameterList;
for fieldlist.empty	_ "[" "]"
Build	ParameterList.empty[];
for fieldlist.pairlist	_ "[" pairlist "]"
Build	ParameterList.pairlist[pairlist];
for fieldlist.typelist	_ "[" typelist "]"
Build	ParameterList.typelist[typelist];

typeexp:	NonTerminal Builds TypeExp;
for typeexp.a	_ Id
Build	TypeExp.typeid[TypeId.id[Id]];
for typeexp.b	_ typeid
Build	TypeExp.typeid[typeid];
for typeexp.c	_ typecons
Build	typecons;

num:	NonTerminal Builds Num;
for num.decimal	_ Decimalnum
Build	Num.decimal[Decimalnum];
for num.octal	_ Octalnum
Build	Num.octal[Octalnum];
for num.hex	_ Hexnum
Build	Num.hex[Hexnum];

lhs:	NonTerminal Builds Exp;
for lhs.id	_ Id
Build	Exp.id[Id];
for lhs.num	_ num	-- several cases here
Build	Exp.num[num];
for lhs.string	_ String
Build	Exp.string[String];
for lhs.flnum	_ Flnum
Build	Exp.flnum[Flnum];
for lhs.char	_ Char
Build	Exp.char[Char];
for lhs.atom	_ Atom
Build	Exp.atom[Atom];
for lhs.narrow	_ "NARROW" "[" exp opttype optcatch "]"
Build	Exp.narrow[exp, opttype, optcatch];
for lhs.loophole	_ "LOOPHOLE" "[" exp opttype "]"
Build	Exp.loophole[exp, opttype];
for lhs.apply	_ "APPLY" "[" exp.rator "," exp.rand optcatch "]"
Build	Exp.apply[exp.rator, exp.rand, optcatch];
for lhs.exp	_ "(" exp ")"
Build	exp;
for lhs.qualifier	_ lhs qualifier
Build	Exp.qualifier[lhs, qualifier];

qualifier:	NonTerminal Builds Qualifier;
for qualifier.prefixop	_ "." prefixop
Build	Qualifier.prefixop[prefixop];
for qualifier.typeop	_ "." typeop
Build	Qualifier.typeop[typeop];
for qualifier.size	_ "." "SIZE"
Build	Qualifier.size[];
for qualifier.apply	_ "[" explist optcatch "]"
Build	Qualifier.apply[explist, optcatch];
for qualifier.select	_ "." Id
Build	Qualifier.select[Id];
for qualifier.indirect	_ "^"
Build	Qualifier.indirect[];

exitlist:	NonTerminal Builds ExitList;
for exitlist.empty	_ -- << empty >>
Build	ExitList.empty[]; 
for exitlist.b	_ exitlistP
Build	exitlistP;
for exitlist.c	_ exitlistP ";"
Build	exitlistP;

exitlistP:	NonTerminal Builds ExitList;
for exitlistP.a	_ exititem
Build	ExitList.more[ExitList.empty[[exititem, exititem)], exititem];
for exitlistP.b	_ exitlistP ";" exititem
Build	ExitList.more[exitlistP, exititem];

exititem:	NonTerminal Builds ExitItem;
for exititem	_ idlist "=>" statement
Build	ExitItem[idlist, statement];

optexp:	NonTerminal Builds OptExp;
for optexp.trash	_ trash
Build	OptExp.trash[];
for optexp.exp	_ exp
Build	OptExp.exp[exp];
for optexp.empty	_ -- << empty >>
Build	OptExp.empty[];

catchcase:	NonTerminal Builds CatchCase;
for catchcase	_ lhslist "=>" statement
Build	CatchCase[lhslist, statement];

lhslist:	NonTerminal Builds SignalList;
for lhslist.one	_ lhs
Build	SignalList.one[lhs];
for lhslist.more	_ lhslist "," lhs
Build	SignalList.more[lhslist, lhs];

initialization:	NonTerminal Builds Initialization;
for initialization.empty	_ -- << empty >>
Build	Initialization.empty[];
for initialization.assignment	_ "_" initvalue
Build	Initialization.assignment[initvalue];
for initialization.binding	_ tilde initvalue
Build	Initialization.binding[initvalue];

initvalue:	NonTerminal Builds InitialValue;
for initvalue.block	_ procaccess trusted checked inline block
Build	InitialValue.block[checked, inline, block];
for initvalue.code	_ "CODE"
Build	InitialValue.code[];
for initvalue.c	_ procaccess trusted checked
"MACHINE" "CODE" "BEGIN" codelist "END"
Build	InitialValue.machinecode[checked, codelist];
for initvalue.d	_ procaccess trusted checked
"MACHINE" "CODE" "{" codelist "}"
Build	InitialValue.machinecode[checked, codelist];
for initvalue.trash	_ trash
Build	InitialValue.trash[];
for initvalue.exp	_ exp
Build	InitialValue.exp[exp];

procaccess:	NonTerminal Builds Junk;
for procaccess	_ -- << empty >>
Build	Junk[]; 

inline:	NonTerminal Builds Inline;
for inline.yes	_ "INLINE"
Build	Inline.yes[];
for inline.no	_ -- << empty >>
Build	Inline.no[]; 

codelist:	NonTerminal Builds CodeList;
for codelist.one	_ orderlist
Build	CodeList.one[orderlist];
for codelist.more	_ codelist ";" orderlist
Build	CodeList.more[codelist, orderlist]

End;

SaffronCG4: Module = Begin

range:	NonTerminal Builds Range;
for range.a	_ Id
Build	Range.typeid[TypeId.id[Id]];
for range.b	_ Id interval
Build	Range.subrange[Subrange.named[TypeId.id[Id], interval]];
for range.c	_ typeid interval
Build	Range.subrange[Subrange.named[typeid, interval]];
for range.d	_ interval
Build	Range.subrange[Subrange.unnamed[interval]];
for range.e	_ typeid
Build	Range.typeid[typeid];

trash:	NonTerminal Builds Junk;
for trash.trash	_ "TRASH"
Build	Junk[];
for trash.null	_ "NULL"
Build	Junk[];

defaultopt:	NonTerminal Builds Default;
for defaultopt.getstrash	_ trash
Build	Default.getstrash[];
for defaultopt.getsexportrash	_ exp "|" trash
Build	Default.getsexportrash[exp];
for defaultopt.gets	_ -- << empty >>
Build	Default.gets[]; 
for defaultopt.getsexp	_ exp
Build	Default.getsexp[exp];

orderlist:	NonTerminal Builds OrderList;
for orderlist.one	_ optexp
Build	OrderList.one[optexp];
for orderlist.more	_ orderlist "," optexp
Build	OrderList.more[orderlist, optexp];

trusted:	NonTerminal Builds Junk;
for trusted	_ -- << empty >>
Build	Junk[]; 

optrelation:	NonTerminal Builds Relation;
for optrelation.negative	_ "NOT" relationtail
Build	Relation.negative[relationtail];
for optrelation.positive	_ relationtail
Build	Relation.positive[relationtail];

relationtail:	NonTerminal Builds RelationTail;
for relationtail.range	_ "IN" range
Build	RelationTail.range[range];
for relationtail.relop	_ relop sum
Build	RelationTail.relop[relop, sum];

relop:	NonTerminal Builds Relop;
for relop.eq	_ "=" 	Build	Relop.eq[];
for relop.ne	_ "#"	Build	Relop.ne[];
for relop.lt	_ "<"	Build	Relop.lt[];
for relop.le	_ "<="	Build	Relop.le[];
for relop.gt	_ ">"	Build	Relop.gt[];
for relop.ge	_ ">="	Build	Relop.ge[];

shares:	NonTerminal Builds Shares;
for shares.present	_ "SHARES" idlist
Build	Shares.present[idlist];
for shares.absent	_ -- << empty >>
Build	Shares.absent[];

statement:	NonTerminal Builds Statement;
for statement.ifthen	_ "IF" exp "THEN" statement
Build	Statement.ifthen[exp, statement];
for statement.ifthenelse	_ "IF" exp "THEN" balstmt "ELSE" statement
Build	Statement.ifthenelse[exp, balstmt, statement];
for statement.select	_ casehead casestmtlist "ENDCASE" "=>" statement
Build	Statement.select[casehead, casestmtlist, OptStatement.present[statement]];
for statement.basicstmt	_ basicstmt
Build	basicstmt;

balstmt:	NonTerminal Builds Statement;
for balstmt.ifthenelse	_ "IF" exp "THEN" balstmt.thenpart "ELSE" balstmt.elsepart
Build	Statement.ifthenelse[exp, balstmt.thenpart, balstmt.elsepart];
for balstmt.select	_ casehead casestmtlist "ENDCASE" "=>" balstmt
Build	Statement.select[casehead, casestmtlist, OptStatement.present[balstmt]];
for balstmt.basicstmt	_ basicstmt
Build	basicstmt;

basicstmt:	NonTerminal Builds Statement;
for basicstmt.exp	_ lhs
Build	Statement.exp[lhs];
for basicstmt.assign	_ lhs "_" exp
Build	Statement.assign[lhs, exp];
for basicstmt.multiassign	_ "[" explist "]" "_" exp
Build	Statement.multiassign[explist, exp];
for basicstmt.block	_ trusted checked block
Build	Statement.block[checked, block];
for basicstmt.select	_ casehead casestmtlist "ENDCASE"
Build	Statement.select[casehead, casestmtlist,
OptStatement.absent[(casestmtlist, casestmtlist]]];
for basicstmt.loopcontrol	_ forclause dotest "DO" scope doexit "ENDLOOP"
Build	Statement.loopcontrol[forclause, dotest, scope, doexit];
for basicstmt.exit	_ "EXIT"
Build	Statement.exit[];
for basicstmt.loop	_ "LOOP"
Build	Statement.loop[];
for basicstmt.i	_ "GOTO" Id
Build	Statement.goto[Id];
for basicstmt.j	_ "GO" "TO" Id
Build	Statement.goto[Id];
for basicstmt.return	_ "RETURN" optargs
Build	Statement.return[optargs];
for basicstmt.transfer	_ transfer lhs
Build	Statement.transfer[transfer, lhs];
for basicstmt.free	_ free "[" exp optcatch "]"
Build	Statement.free[free, exp, optcatch];
for basicstmt.wait	_ "WAIT" lhs
Build	Statement.wait[lhs];
for basicstmt.error	_ "ERROR"
Build	Statement.error[];
for basicstmt.stop	_ "STOP"
Build	Statement.stop[];
for basicstmt.null	_ "NULL"
Build	Statement.null[];
for basicstmt.resume	_ "RESUME" optargs
Build	Statement.resume[optargs];
for basicstmt.reject	_ "REJECT"
Build	Statement.reject[];
for basicstmt.continue	_ "CONTINUE"
Build	Statement.continue[];
for basicstmt.retry	_ "RETRY"
Build	Statement.retry[];
for basicstmt.getstate	_ lhs "_" "STATE"
Build	Statement.getstate[lhs];
for basicstmt.setstate	_ "STATE" "_" exp
Build	Statement.setstate[exp];

forclause:	NonTerminal Builds ForClause;
for forclause.assignation	_ "FOR" controlid "_" exp.initial "," exp.next
Build	ForClause.assignation[controlid, exp.initial, exp.next];
for forclause.iteration	_ "FOR" controlid direction "IN" range
Build	ForClause.iteration[controlid, direction, range];
for forclause.repetition	_ "THROUGH" range
Build	ForClause.repetition[range];
for forclause.empty	_ -- << empty >>
Build	ForClause.empty[]; 

controlid:	NonTerminal Builds ControlId;
for controlid.new	_ ident typeexp
Build	ControlId.new[ident, typeexp];
for controlid.old	_ Id
Build	ControlId.old[Id];

direction:	NonTerminal Builds Decreasing;
for direction.yes	_ "DECREASING"
Build	Decreasing.yes[];
for direction.no	_ -- << empty >>
Build	Decreasing.no[];

doexit:	NonTerminal Builds DoExit;
for doexit.a	_ -- << empty >>
Build	DoExit[ExitList.empty[], OptStatement.absent[]];
for doexit.b	_ "REPEAT" exitlist
Build	DoExit[exitlist, OptStatement.absent[(exitlist, exitlist]]];
for doexit.c	_ "REPEAT" exitlist "FINISHED" "=>" statement
Build	DoExit[exitlist, OptStatement.present[statement]];
for doexit.d	_ "REPEAT" exitlist "FINISHED" "=>" statement ";"
Build	DoExit[exitlist, OptStatement.present[statement]];

transfer:	NonTerminal Builds Transfer;
for transfer.signal	_ "SIGNAL"
Build	Transfer.signal[];
for transfer.error	_ "ERROR"
Build	Transfer.error[];
for transfer.returnwitherror	_ "RETURN" "WITH" "ERROR"
Build	Transfer.returnwitherror[];
for transfer.start	_ "START"
Build	Transfer.start[];
for transfer.restart	_ "RESTART"
Build	Transfer.restart[];
for transfer.join	_ "JOIN"
Build	Transfer.join[];
for transfer.notify	_ "NOTIFY"
Build	Transfer.notify[];
for transfer.broadcast	_ "BROADCAST"
Build	Transfer.broadcast[];
for transfer.transferwith	_ "TRANSFER" "WITH"
Build	Transfer.transferwith[];
for transfer.returnwith	_ "RETURN" "WITH"
Build	Transfer.returnwith[]

End;

SaffronCG5: Module = Begin

dotest:	NonTerminal Builds DoTest;
for dotest.until	_ "UNTIL" exp
Build	DoTest.until[exp];
for dotest.while	_ "WHILE" exp
Build	DoTest.while[exp];
for dotest.empty	_ -- << empty >>
Build	DoTest.empty[]; 

optargs:	NonTerminal Builds OptArgs;
for optargs.explist	_ "[" explist "]"
Build	OptArgs.explist[explist];
for optargs.empty	_ -- << empty >>
Build	OptArgs.empty[]; 
for optargs.exp	_ lhs
Build	OptArgs.exp[lhs];

free:	NonTerminal Builds Free;
for free.plain	_ "FREE"
Build	Free.plain[];
for free.zoned	_ lhs "." "FREE"
Build	Free.zoned[lhs];

casestmtlist:	NonTerminal Builds SelectStmtList;
for casestmtlist.empty	_ -- << empty >>
Build	SelectStmtList.empty[]; 
for casestmtlist.b	_ casestmtlistP
Build	casestmtlistP;
for casestmtlist.c	_ casestmtlistP ";"
Build	casestmtlistP;

casestmtlistP:	NonTerminal Builds SelectStmtList;
for casestmtlistP.a	_ casestmtitem
Build	SelectStmtList.more[
SelectStmtList.empty[[casestmtitem, casestmtitem)],
casestmtitem];
for casestmtlistP.b	_ casestmtlistP ";" casestmtitem
Build	SelectStmtList.more[casestmtlistP, casestmtitem];

casestmtitem:	NonTerminal Builds SelectStmtItem;
for casestmtitem	_ caselabel "=>" statement
Build	SelectStmtItem[caselabel, statement];

declist:	NonTerminal Builds DecList;
for declist.one	_ declaration
Build	DecList.one[declaration];
for declist.many	_ declist ";" declaration
Build	DecList.many[declist, DecList.one[declaration]];

declaration:	NonTerminal Builds Declaration;
for declaration.value	_ identlist public entry readonly typeexp initialization
Build	Declaration.value[identlist, public, entry, readonly, typeexp, initialization];
for declaration.type	_ identlist public.id "TYPE" tilde public.type typeexp default
Build	Declaration.type[identlist, public.id, public.type, typeexp, default];
for declaration.opaquetype	_ identlist public "TYPE" optsize
Build	Declaration.opaquetype[identlist, public, optsize];

entry:	NonTerminal Builds Entry;
for entry.entry	_ "ENTRY"
Build	Entry.entry[];
for entry.internal	_ "INTERNAL"
Build	Entry.internal[];
for entry.empty	_ -- << empty >>
Build	Entry.empty[]; 

optsize:	NonTerminal Builds OptSize;
for optsize.present	_ "[" exp "]"
Build	OptSize.present[exp];
for optsize.absent	_ -- << empty >>
Build	OptSize.absent[]; 

primary:	NonTerminal Builds Exp;
for primary.explist	_ "[" explist "]"
Build	Exp.explist[explist];
for primary.prefixop	_ prefixop "[" orderlist "]"
Build	Exp.prefixop[prefixop, orderlist];
for primary.val	_ "VAL" "[" orderlist "]"
Build	Exp.val[orderlist];
for primary.all	_ "ALL" "[" orderlist "]"
Build	Exp.all[orderlist];
for primary.new	_ new "[" typeexp initialization optcatch "]"
Build	Exp.new[new, typeexp, initialization, optcatch];
for primary.cons	_ cons "[" explist optcatch "]"
Build	Exp.cons[cons, explist, optcatch];
for primary.listcons	_ listcons "[" explist "]"
Build	Exp.listcons[listcons, explist];
for primary.nil	_ "NIL"
Build	Exp.nil[];
for primary.typeop	_ typeop "[" typeexp "]"
Build	Exp.typeop[typeop, typeexp];
for primary.size	_ "SIZE" "[" typeexp "]"
Build	Exp.size[typeexp];
for primary.size2	_ "SIZE" "[" typeexp "," exp "]"
Build	Exp.size2[typeexp, exp];
for primary.istype	_ "ISTYPE" "[" exp "," typeexp "]"
Build	Exp.istype[exp, typeexp];
for primary.address	_ "@" lhs
Build	Exp.address[lhs];
for primary.descriptor	_ "DESCRIPTOR" "[" desclist "]"
Build	Exp.descriptor[desclist];
for primary.lhs	_ lhs
Build	lhs;

new:	NonTerminal Builds New;
for new.plain	_ "NEW"
Build	New.plain[];
for new.zoned	_ lhs "." "NEW"
Build	New.zoned[lhs];

cons:	NonTerminal Builds Cons;
for cons.plain	_ "CONS"
Build	Cons.plain[];
for cons.zoned	_ lhs "." "CONS"
Build	Cons.zoned[lhs];

listcons:	NonTerminal Builds ListCons;
for listcons.plain	_ "LIST"
Build	ListCons.plain[];
for listcons.zoned	_ lhs "." "LIST"
Build	ListCons.zoned[lhs];

desclist:	NonTerminal Builds DescList;
for desclist.explicit	_ exp.base "," exp.length opttype
Build	DescList.explicitlength[exp.base, exp.length, opttype];
for desclist.default	_ exp
Build	DescList.defaultlength[exp];

optcatch:	NonTerminal Builds Catch;
for optcatch.catchlist	_ "!" catchlist
Build	catchlist;
for optcatch.empty	_ -- << empty >>
Build	Catch[CatchCaseList.empty[], CatchAny.absent[]];

identlist:	NonTerminal Builds IdentList;
for identlist	_ identlistP
Build	identlistP;

identlistP:	NonTerminal Builds IdentList;
for identlistP.a	_ Id ":"
Build	IdentList.one[Ident.id[Id]];
for identlistP.b	_ Id positionP ":"
Build	IdentList.one[Ident.idposition[Id, positionP]];
for identlistP.c	_ Id "," identlistP
Build	IdentList.many[IdentList.one[Ident.id[Id]], identlistP];
for identlistP.d	_ Id positionP "," identlistP
Build	IdentList.many[IdentList.one[Ident.idposition[Id, positionP]], identlistP];

prefixop:	NonTerminal Builds PrefixOp;
for prefixop.long	_ "LONG"
Build	PrefixOp.long[];
for prefixop.abs	_ "ABS"
Build	PrefixOp.abs[];
for prefixop.pred	_ "PRED"
Build	PrefixOp.pred[];
for prefixop.succ	_ "SUCC"
Build	PrefixOp.succ[];
for prefixop.ord	_ "ORD"
Build	PrefixOp.ord[];
for prefixop.min	_ "MIN"
Build	PrefixOp.min[];
for prefixop.max	_ "MAX"
Build	PrefixOp.max[];
for prefixop.base	_ "BASE"
Build	PrefixOp.base[];
for prefixop.length	_ "LENGTH"
Build	PrefixOp.length[]

End;

SaffronCG6: Module = Begin

typecons:	NonTerminal Builds TypeExp;
for typecons.a	_ interval
Build	TypeExp.subrange[Subrange.unnamed[interval]];
for typecons.b	_ Id interval
Build	TypeExp.subrange[Subrange.named[TypeId.id[Id], interval]];
for typecons.c	_ typeid interval
Build	TypeExp.subrange[Subrange.named[typeid, interval]];
for typecons.enum	_ dependent "{" elementlist "}"
Build	TypeExp.enum[dependent, elementlist];
for typecons.record	_ dependent monitored "RECORD" reclist
Build	TypeExp.record[dependent, monitored, reclist];
for typecons.pointer	_ ordered base pointertype
Build	TypeExp.pointer[ordered, base, pointertype];
for typecons.var	_ "VAR" typeexp
Build	TypeExp.var[typeexp];
for typecons.ref	_ "REF" readonly typeexp
Build	TypeExp.ref[readonly, typeexp];
for typecons.refany	_ "REF" readonly "ANY"
Build	TypeExp.refany[readonly];
for typecons.refunspecified	_ "REF"
Build	TypeExp.refunspecified[];
for typecons.list	_ "LIST" "OF" readonly typeexp
Build	TypeExp.list[readonly, typeexp];
for typecons.array	_ packed "ARRAY" indextype "OF" typeexp
Build	TypeExp.array[packed, indextype, typeexp];
for typecons.descriptor	_ "DESCRIPTOR" "FOR" readonly typeexp
Build	TypeExp.descriptor[readonly, typeexp];
for typecons.transfer	_ safe transfermode arguments
Build	TypeExp.transfer[safe, transfermode, arguments];
for typecons.o	_ Id "RELATIVE" typeexp
Build	TypeExp.relative[TypeId.id[Id], typeexp];
for typecons.p	_ typeid "RELATIVE" typeexp
Build	TypeExp.relative[typeid, typeexp];
for typecons.zone	_ heap "ZONE"
Build	TypeExp.zone[heap];
for typecons.long	_ "LONG" typeexp
Build	TypeExp.long[typeexp];
for typecons.frame	_ "FRAME" "[" Id "]"
Build	TypeExp.frame[Id];
for typecons.t	_ Id "PAINTED" typeexp
Build	TypeExp.painted[TypeId.id[Id], typeexp];
for typecons.u	_ typeid "PAINTED" typeexp
Build	TypeExp.painted[typeid, typeexp];
for typecons.typeapply	_ typeappl
Build	TypeExp.typeapply[typeappl];

dependent:	NonTerminal Builds MachineDependent;
for dependent.yes	_ "MACHINE" "DEPENDENT"
Build	MachineDependent.yes[];
for dependent.no	_ -- << empty >>
Build	MachineDependent.no[];

monitored:	NonTerminal Builds Monitored;
for monitored.yes	_ "MONITORED"
Build	Monitored.yes[];
for monitored.no	_ -- << empty >>
Build	Monitored.no[];

ordered:	NonTerminal Builds Ordered;
for ordered.yes	_ "ORDERED"
Build	Ordered.yes[];
for ordered.no	_ -- << empty >>
Build	Ordered.no[]; 

base:	NonTerminal Builds Base;
for base.yes	_ "BASE"
Build	Base.yes[];
for base.no	_ -- << empty >>
Build	Base.no[]; 

pointertype:	NonTerminal Builds PointerType;
for pointertype.unspecified	_ pointerprefix
Build	PointerType.unspecified[pointerprefix];
for pointertype.specified	_ pointerprefix "TO" readonly typeexp
Build	PointerType.specified[pointerprefix, readonly, typeexp];

pointerprefix:	NonTerminal Builds OptInterval;
for pointerprefix.absent	_ "POINTER"
Build	OptInterval.absent[];
for pointerprefix.present	_ "POINTER" interval
Build	OptInterval.present[interval];

indextype:	NonTerminal Builds OptType;
for indextype.present	_ typeexp
Build	OptType.present[typeexp];
for indextype.absent	_ -- << empty >>
Build	OptType.absent[]; 


transfermode:	NonTerminal Builds TransferMode;
for transfermode.a	_ "PROCEDURE"
Build	TransferMode.proc[];
for transfermode.b	_ "PROC"
Build	TransferMode.proc[];
for transfermode.port	_ "PORT"
Build	TransferMode.port[];
for transfermode.signal	_ "SIGNAL"
Build	TransferMode.signal[];
for transfermode.error	_ "ERROR"
Build	TransferMode.error[];
for transfermode.process	_ "PROCESS"
Build	TransferMode.process[];
for transfermode.program	_ "PROGRAM"
Build	TransferMode.program[];



elementlist:	NonTerminal Builds ElementList;
for elementlist.empty	_ -- << empty >>
Build	ElementList.empty[];
for elementlist.b	_ elementlistP
Build	elementlistP;

elementlistP:	NonTerminal Builds ElementList;
for elementlistP.a	_ element
Build	ElementList.more[ElementList.empty[[element, element)], element];
for elementlistP.b	_ elementlistP "," element
Build	ElementList.more[elementlistP, element];

element:	NonTerminal Builds Element;
for element.idwithrep	_ Id "(" exp ")"
Build	Element.idwithrep[Id, exp];
for element.anon	_ "(" exp ")"
Build	Element.anonymousrep[exp];
for element.id	_ Id
Build	Element.id[Id];

heap:	NonTerminal Builds Uncounted;
for heap.yes	_ "UNCOUNTED"
Build	Uncounted.yes[];
for heap.no	_ -- << empty >>
Build	Uncounted.no[]; 

typeappl:	NonTerminal Builds TypeApply;
for typeappl.a	_ typeappl "." Id
Build	TypeApply.moreids[typeappl, Id];
for typeappl.b	_ Id lengthP
Build	TypeApply.one[TypeId.id[Id], lengthP];
for typeappl.c	_ typeid lengthP
Build	TypeApply.one[typeid, lengthP];
for typeappl.d	_ typeappl lengthP
Build	TypeApply.morelengths[typeappl, lengthP];

lengthP:	NonTerminal Builds Exp;
for lengthP	_ "[" exp "]"
Build	exp;

reclist:	NonTerminal Builds RecList;
for reclist.a	_ "[" "]"
Build	RecList.empty[];
for reclist.b	_ "NULL"
Build	RecList.empty[];
for reclist.c	_ "[" pairlist "]"
Build	RecList.pairlist[pairlist];
for reclist.d	_ "[" typelist "]"
Build	RecList.typelist[typelist];
for reclist.e	_ "[" pairlist "," variantpair "]"
Build	RecList.pairlist[PairList.many[pairlist, PairList.one[variantpair]]];
for reclist.f	_ "[" variantpart default "]"
Build	RecList.typelist[TypeList.one[TypeItem[variantpart, default]]];
for reclist.g	_ "[" variantpair "]"
Build	RecList.pairlist[PairList.one[variantpair]];

variantpair:	NonTerminal Builds PairItem;
for variantpair	_ identlist public variantpart default
Build	PairItem[identlist, public, variantpart, default];

variantpart:	NonTerminal Builds TypeExp;
for variantpart.a	_ "SELECT" vcasehead "FROM" variantlist "ENDCASE"
Build	TypeExp.union[vcasehead, variantlist];
for variantpart.b	_ "SELECT" vcasehead "FROM" variantlist "," "ENDCASE"
Build	TypeExp.union[vcasehead, variantlist];
for variantpart.c	_ packed "SEQUENCE" vcasehead "OF" typeexp
Build	TypeExp.sequence[packed, vcasehead, typeexp];

vcasehead:	NonTerminal Builds Tag;
for vcasehead.ident	_ ident public tagtype
Build	Tag.ident[ident, public, tagtype];
for vcasehead.computed	_ "COMPUTED" tagtype
Build	Tag.computed[tagtype];
for vcasehead.overlaid	_ "OVERLAID" tagtype
Build	Tag.overlaid[tagtype];

tagtype:	NonTerminal Builds TagType;
for tagtype.star	_ "*"
Build	TagType.star[];
for tagtype.typeexp	_ typeexp
Build	TagType.typeexp[typeexp];

variantlist:	NonTerminal Builds VariantList;
for variantlist.one	_ variantitem
Build	VariantList.one[variantitem];
for variantlist.more	_ variantlist "," variantitem
Build	VariantList.more[variantlist, variantitem];

variantitem:	NonTerminal Builds VariantItem;
for variantitem	_ idlist "=>" reclist
Build	VariantItem[idlist, reclist];


packed:	NonTerminal Builds Packed;
for packed.yes	_ "PACKED"
Build	Packed.yes[];
for packed.no	_ -- << empty >>
Build	Packed.no[];

imports:	NonTerminal Builds ModuleList;
for imports.a	_ "IMPORTS"
Build	ModuleList.empty[];
for imports.b	_ "IMPORTS" modulelist
Build	modulelist;
for imports.c	_ -- << empty >>
Build	ModuleList.empty[]; 

opttype:	NonTerminal Builds OptType;
for opttype.present	_ "," typeexp
Build	OptType.present[typeexp];
for opttype.absent	_ -- << empty >>
Build	OptType.absent[]

End;

SaffronCG7: Module = Begin

typelist:	NonTerminal Builds TypeList;
for typelist.a	_ typecons default
Build	TypeList.one[TypeItem[
typecons, default]];
for typelist.b	_ typeid default
Build	TypeList.one[TypeItem[
TypeExp.typeid[typeid], default]];
for typelist.c	_ Id
Build	TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[Id]], Default.empty[(Id,Id]]]];
for typelist.d	_ Id "_" defaultopt
Build	TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[Id]], defaultopt]];

for typelist.e	_ typecons default "," typelist
Build	TypeList.many[TypeList.one[TypeItem[
typecons, default]], typelist];
for typelist.f	_ typeid default "," typelist
Build	TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[typeid], default]], typelist];
for typelist.g	_ Id "," typelist
Build	TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[Id]], Default.empty[(Id,Id]]]], typelist];
for typelist.h	_ Id "_" defaultopt "," typelist
Build	TypeList.many[TypeList.one[TypeItem[
TypeExp.typeid[TypeId.id[Id]], defaultopt]], typelist];

modulelist:	NonTerminal Builds ModuleList;
for modulelist.a	_ moduleitem
Build	ModuleList.more[ModuleList.empty[[moduleitem, moduleitem)], moduleitem];
for modulelist.b	_ modulelist "," moduleitem
Build	ModuleList.more[modulelist, moduleitem];

moduleitem:	NonTerminal Builds ModuleItem;
for moduleitem.one	_ Id
Build	ModuleItem.one[Id];
for moduleitem.two	_ Id.record ":" Id.type
Build	ModuleItem.two[Id.record, Id.type];

tilde:	NonTerminal Builds Junk;
for tilde.a	_ "~"
Build	Junk[];
for tilde.b	_ "="
Build	Junk[];

pairlist:	NonTerminal Builds PairList;
for pairlist.one	_ pairitem
Build	PairList.one[pairitem];
for pairlist.many	_ pairlist "," pairitem
Build	PairList.many[pairlist, PairList.one[pairitem]];

pairitem:	NonTerminal Builds PairItem;
for pairitem	_ identlist public typeexp default
Build	PairItem[identlist, public, typeexp, default];

typeid:	NonTerminal Builds TypeId;
for typeid.a	_ Id.a Id.b
Build	TypeId.qualifier[TypeId.id[Id.b], Id.a];
for typeid.b	_ Id typeid
Build	TypeId.qualifier[typeid, Id];
for typeid.c	_ typeidP
Build	typeidP;

typeidP:	NonTerminal Builds TypeId;
for typeidP.a	_ Id.a "." Id.b
Build	TypeId.qualifier[TypeId.id[Id.a], Id.b];
for typeidP.b	_ typeidP "." Id
Build	TypeId.qualifier[typeidP, Id];

explist:	NonTerminal Builds ExpList;
for explist.orderlist	_ orderlist
Build	ExpList.orderlist[orderlist];
for explist.keylist	_ keylist
Build	ExpList.keylist[keylist];

keylist:	NonTerminal Builds KeyList;
for keylist.one	_ keyitem
Build	KeyList.one[keyitem];
for keylist.more	_ keylist "," keyitem
Build	KeyList.more[keylist, keyitem];

keyitem:	NonTerminal Builds KeyItem;
for keyitem.a	_ Id "~" optexp
Build	KeyItem[Id, optexp];
for keyitem.b	_ Id ":" optexp
Build	KeyItem[Id, optexp];

locks:	NonTerminal Builds Locks;
for locks.present	_ "LOCKS" primary lambda
Build	Locks.present[primary, lambda];
for locks.absent	_ -- << empty >>
Build	Locks.absent[]; 

lambda:	NonTerminal Builds Lambda;
for lambda.present	_ "USING" ident typeexp
Build	Lambda.present[ident, typeexp];
for lambda.absent	_ -- << empty >>
Build	Lambda.absent[]; 

open:	NonTerminal Builds BindList;
for open.bindlist	_ "OPEN" bindlist ";"
Build	bindlist;
for open.empty	_ -- << empty >>
Build	BindList.empty[];

bindlist:	NonTerminal Builds BindList;
for bindlist.item	_ binditem
Build	BindList.more[BindList.empty[[binditem, binditem)], binditem];
for bindlist.list	_ bindlist "," binditem
Build	BindList.more[bindlist, binditem];

casehead:	NonTerminal Builds SelectHead;
for casehead.plain	_ "SELECT" exp "FROM"
Build	SelectHead.plain[exp];
for casehead.discrim	_ "WITH" binditem "SELECT" optexp "FROM"
Build	SelectHead.discriminating[binditem, optexp];

scope:	NonTerminal Builds Scope;
for scope.a	_ open enables statementlist
Build	Scope[open, enables, OptDecList.absent[[statementlist, statementlist)], statementlist];
for scope.b	_ open enables declist ";" statementlist
Build	Scope[open, enables, OptDecList.present[declist], statementlist];

enables:	NonTerminal Builds Catch;
for enables.a	_ "ENABLE" catchcase ";"
Build	Catch[
CatchCaseList.more[CatchCaseList.empty[[catchcase, catchcase)], catchcase], CatchAny.absent[(catchcase, catchcase]
]];
for enables.b	_ "ENABLE" catchany ";"
Build	Catch[CatchCaseList.empty[[catchany, catchany)], catchany];
for enables.c	_ "ENABLE" "BEGIN" catchlist "END" ";"
Build	catchlist;
for enables.d	_ "ENABLE" "{" catchlist "}" ";"
Build	catchlist;
for enables.e	_ -- << empty >>
Build	Catch[CatchCaseList.empty[], CatchAny.absent[]];

statementlist:	NonTerminal Builds StatementList;
for statementlist.empty	_ -- << empty >>
Build	StatementList.empty[]; 
for statementlist.b	_ statementlistP
Build	statementlistP;
for statementlist.c	_ statementlistP ";"
Build	statementlistP;

statementlistP:	NonTerminal Builds StatementList;
for statementlistP.a	_ statement
Build	StatementList.more[StatementList.empty[[statement, statement)], statement];
for statementlistP.b	_ statementlistP ";" statement
Build	StatementList.more[statementlistP, statement];

safe:	NonTerminal Builds Safe;
for safe.empty	_ -- << empty >>
Build	Safe.empty[]; 
for safe.no	_ "UNSAFE"
Build	Safe.no[];
for safe.yes	_ "SAFE"
Build	Safe.yes[]

End.

ZSaffronCG.ThreeC4
Copyright � 1986, 1987 by Xerox Corporation.  All rights reserved.
Shoup, August 7, 1986 4:37:43 pm PDT
Bill Jackson (bj) April 27, 1987 5:21:12 pm PDT
Lucy Hederman July 17, 1987 3:30:10 pm PDT
Sturgis, July 20, 1987 6:02:22 pm PDT
new grammar production
insert position info ???

the following nonterminal was added to handle the several varieties of numbers recognized by IO.GetCedarToken

for lhs.lnum	_ lnum shouldn't be a lexical entity
Build	Exp.lnum[lnum];
for lhs.lstring	_ lstring can't recognize due to IO.GetCedarToken limitation
Build	Exp.lstring[lstring];
eof...

��T
�

"cedar" style�
code�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
�B�BK�%clearTabStops 20 sp flushLeft tabStop�
�$�$K�%clearTabStops 20 sp flushLeft tabStop�/K�%clearTabStops 20 sp flushLeft tabStop�*K�%clearTabStops 20 sp flushLeft tabStop�%�K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop�
�&�&K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop��n��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop��
���%clearTabStops 20 sp flushLeft tabStop�
K�%clearTabStops 20 sp flushLeft tabStop�
�s�K�%clearTabStops 20 sp flushLeft tabStop�
�'�'K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
�5�5K�%clearTabStops 20 sp flushLeft tabStop�
�D�DK�%clearTabStops 20 sp flushLeft tabStop�
�R�RK�%clearTabStops 20 sp flushLeft tabStop�
�5�5K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
�0�0K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
�7�7K�%clearTabStops 20 sp flushLeft tabStop�
�1�1K�%clearTabStops 20 sp flushLeft tabStop�
�*�*K�%clearTabStops 20 sp flushLeft tabStop�
�+�+K�%clearTabStops 20 sp flushLeft tabStop�
�d�dK�%clearTabStops 20 sp flushLeft tabStop�
�d�dK�%clearTabStops 20 sp flushLeft tabStop�
�Q�QK�%clearTabStops 20 sp flushLeft tabStop�
�9�9K�%clearTabStops 20 sp flushLeft tabStop�
�0�0K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�
��K�%clearTabStops 20 sp flushLeft tabStop�SK�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��b��iz�
���!�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���i
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	��
�#K�%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�!�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�#�%clearTabStops 20 sp flushLeft tabStop���G�JK�%clearTabStops 20 sp flushLeft tabStop���
�D�J��%clearTabStops 20 sp flushLeft tabStop���7�:K�%clearTabStops 20 sp flushLeft tabStop���
�;�AK�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����	��!K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����	��-K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����c�cz� K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���*�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�I�O��%clearTabStops 20 sp flushLeft tabStop���,�/K�%clearTabStops 20 sp flushLeft tabStop���
�)�/K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop������.K�%clearTabStops 20 sp flushLeft tabStop���
�%�+��%clearTabStops 20 sp flushLeft tabStop������'K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop������7K�%clearTabStops 20 sp flushLeft tabStop���
�2�8K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop�����	�#K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������-K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������'K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop�������
�*K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�������
�.K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���%�(K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop���8�;K�%clearTabStops 20 sp flushLeft tabStop���
�(�.K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���%�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���F�IK�%clearTabStops 20 sp flushLeft tabStop���
�;�AK�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
�$�*K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���'�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
��
�*�%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
�!�'��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��#K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���.�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop���*�-K�%clearTabStops 20 sp flushLeft tabStop���
�*�0K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����%clearTabStops 20 sp flushLeft tabStop���
�A�GK�%clearTabStops 20 sp flushLeft tabStop�
���K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop�������
�'K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�#�%clearTabStops 20 sp flushLeft tabStop�����
�!K�%clearTabStops 20 sp flushLeft tabStop���
�	���%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
�+�1K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����	�
�#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
��
�'�%clearTabStops 20 sp flushLeft tabStop��� �#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
�%�+��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop��� �#K�%clearTabStops 20 sp flushLeft tabStop���
��$��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������ K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���
���#K�%clearTabStops 20 sp flushLeft tabStop���
��"K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����������JK�%clearTabStops 20 sp flushLeft tabStop���
�5�;��%clearTabStops 20 sp flushLeft tabStop���$��
�8K�%clearTabStops 20 sp flushLeft tabStop���
�'�-��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���*�-K�%clearTabStops 20 sp flushLeft tabStop���
��$��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��$��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�	�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���.�%clearTabStops 20 sp flushLeft tabStop������&K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���/�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�S�Y��%clearTabStops 20 sp flushLeft tabStop���.�1K�%clearTabStops 20 sp flushLeft tabStop���
�.�4K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���.�%clearTabStops 20 sp flushLeft tabStop���!�$�%clearTabStops 20 sp flushLeft tabStop���
��#K�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop��
���
���*�%clearTabStops 20 sp flushLeft tabStop�����
� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop�����
�(K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�	�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���!�%clearTabStops 20 sp flushLeft tabStop�����
�*K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�	�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���!�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�	�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���!�%clearTabStops 20 sp flushLeft tabStop���$�'K�%clearTabStops 20 sp flushLeft tabStop���
��%��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���$�%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
�[�a��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�;�A��%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop���%�(K�%clearTabStops 20 sp flushLeft tabStop���
��!K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���,�%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop���
�)�/K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop���$�'K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���#�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
��%K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���*�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���-�%clearTabStops 20 sp flushLeft tabStop�������
�$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������.K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop������%K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���,�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���&�)K�%clearTabStops 20 sp flushLeft tabStop���
�!�'��%clearTabStops 20 sp flushLeft tabStop���&�)K�%clearTabStops 20 sp flushLeft tabStop���
�!�'K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��$��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����%clearTabStops 20 sp flushLeft tabStop���
�	�K�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop�
�m�mK�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����'K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���.�1K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���I�LK�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������6K�%clearTabStops 20 sp flushLeft tabStop���
�#�)��%clearTabStops 20 sp flushLeft tabStop������1K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop�����)�?K�%clearTabStops 20 sp flushLeft tabStop���
�)�/��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
��%clearTabStops 20 sp flushLeft tabStop����!�%clearTabStops 20 sp flushLeft tabStop���
��$K�%clearTabStops 20 sp flushLeft tabStop�����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���+�.K�%clearTabStops 20 sp flushLeft tabStop���
�#�)��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
��
�'�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�>�D��%clearTabStops 20 sp flushLeft tabStop���%�(K�%clearTabStops 20 sp flushLeft tabStop���
�#�)K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
��"K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
��$K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���'�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
��$K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���2�%clearTabStops 20 sp flushLeft tabStop������)K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���*�-K�%clearTabStops 20 sp flushLeft tabStop���
�%�+��%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop���
�"�(K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���+�%clearTabStops 20 sp flushLeft tabStop���:�=K�%clearTabStops 20 sp flushLeft tabStop���
�+�1��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop�	�
��������
�'K�%clearTabStops 20 sp flushLeft tabStop���
�,�2��%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop��
�����!K�%clearTabStops 20 sp flushLeft tabStop���
�,�2��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���$�%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���'�*K�%clearTabStops 20 sp flushLeft tabStop���
�"�(K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop���
�K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�8�>��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�1�7��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�+�1��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��
��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��
�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
���
��	�'�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���*�-K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���&�)K�%clearTabStops 20 sp flushLeft tabStop���
�"�(K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���!�%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�)�%clearTabStops 20 sp flushLeft tabStop������-K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop���$�'K�%clearTabStops 20 sp flushLeft tabStop���
� �&K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���.�%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
�� ��%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
��%K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� K�%clearTabStops 20 sp flushLeft tabStop�����
��%K�%clearTabStops 20 sp flushLeft tabStop�����
��$K�%clearTabStops 20 sp flushLeft tabStop�����
��$K�%clearTabStops 20 sp flushLeft tabStop�����
��%K�%clearTabStops 20 sp flushLeft tabStop�����
��$K�%clearTabStops 20 sp flushLeft tabStop�����
��%K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop��������0K�%clearTabStops 20 sp flushLeft tabStop���
�!�'��%clearTabStops 20 sp flushLeft tabStop����������CK�%clearTabStops 20 sp flushLeft tabStop���
�.�4��%clearTabStops 20 sp flushLeft tabStop���+���EK�%clearTabStops 20 sp flushLeft tabStop���
�J�P��%clearTabStops 20 sp flushLeft tabStop��� �#K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���&�%clearTabStops 20 sp flushLeft tabStop����������QK�%clearTabStops 20 sp flushLeft tabStop���
�>�D��%clearTabStops 20 sp flushLeft tabStop���)���AK�%clearTabStops 20 sp flushLeft tabStop���
�H�N��%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop���0�3K�%clearTabStops 20 sp flushLeft tabStop���
�$�*��%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop���+��
�6K�%clearTabStops 20 sp flushLeft tabStop���
�\�b��%clearTabStops 20 sp flushLeft tabStop���+����
�HK�%clearTabStops 20 sp flushLeft tabStop���
�8�>��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop��������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�'K�%clearTabStops 20 sp flushLeft tabStop���
�� ��%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
�"�(��%clearTabStops 20 sp flushLeft tabStop���+�.K�%clearTabStops 20 sp flushLeft tabStop���
�$�*��%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�'K�%clearTabStops 20 sp flushLeft tabStop���
�� ��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�#K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�(K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�(K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop�����(�HK�%clearTabStops 20 sp flushLeft tabStop���
�8�>��%clearTabStops 20 sp flushLeft tabStop��������>K�%clearTabStops 20 sp flushLeft tabStop���
�1�7��%clearTabStops 20 sp flushLeft tabStop������*K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��$��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���)�%clearTabStops 20 sp flushLeft tabStop����
�
� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
�0�6��%clearTabStops 20 sp flushLeft tabStop���
��
� K�%clearTabStops 20 sp flushLeft tabStop���
�<�B��%clearTabStops 20 sp flushLeft tabStop���
�����:K�%clearTabStops 20 sp flushLeft tabStop���
�2�8��%clearTabStops 20 sp flushLeft tabStop���
�����>K�%clearTabStops 20 sp flushLeft tabStop���
�2�8K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
��
�6K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����	�
�$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�������
�-K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�������
�)K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���0�%clearTabStops 20 sp flushLeft tabStop������'K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���1�%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
�W�]��%clearTabStops 20 sp flushLeft tabStop���1�4K�%clearTabStops 20 sp flushLeft tabStop���
�1�7K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���0�%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
�%�+K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���'�*K�%clearTabStops 20 sp flushLeft tabStop���
�0�6K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop���K�NK�%clearTabStops 20 sp flushLeft tabStop���
�O�U��%clearTabStops 20 sp flushLeft tabStop���)��#�SK�%clearTabStops 20 sp flushLeft tabStop���
�F�L��%clearTabStops 20 sp flushLeft tabStop���,��	�<K�%clearTabStops 20 sp flushLeft tabStop���
�3�9K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������ K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���.�1K�%clearTabStops 20 sp flushLeft tabStop���
�"�(��%clearTabStops 20 sp flushLeft tabStop������)K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������)K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���:�=K�%clearTabStops 20 sp flushLeft tabStop���
�0�6��%clearTabStops 20 sp flushLeft tabStop���-�0K�%clearTabStops 20 sp flushLeft tabStop���
�"�(��%clearTabStops 20 sp flushLeft tabStop���,�/K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop������)K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������2K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������5K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����
��6K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���4�7K�%clearTabStops 20 sp flushLeft tabStop���
�7�=��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��"K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���#�%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
�0�6K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���)�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��"��%clearTabStops 20 sp flushLeft tabStop��� �#K�%clearTabStops 20 sp flushLeft tabStop���
�/�5��%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
�8�>��%clearTabStops 20 sp flushLeft tabStop���+�.K�%clearTabStops 20 sp flushLeft tabStop���
�K�QK�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
��	�%�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�-�3��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�:�@��%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�3�9��%clearTabStops 20 sp flushLeft tabStop���.�1K�%clearTabStops 20 sp flushLeft tabStop���
�%�+��%clearTabStops 20 sp flushLeft tabStop���(��	�:K�%clearTabStops 20 sp flushLeft tabStop���
�.�4��%clearTabStops 20 sp flushLeft tabStop���,�/K�%clearTabStops 20 sp flushLeft tabStop���
�,�2��%clearTabStops 20 sp flushLeft tabStop�����	� K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������)K�%clearTabStops 20 sp flushLeft tabStop���
��%��%clearTabStops 20 sp flushLeft tabStop�������
�*K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�#K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop��������0K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop�����
��	�:K�%clearTabStops 20 sp flushLeft tabStop���
�*�0��%clearTabStops 20 sp flushLeft tabStop����
����=K�%clearTabStops 20 sp flushLeft tabStop���
�&�,��%clearTabStops 20 sp flushLeft tabStop���0�3K�%clearTabStops 20 sp flushLeft tabStop���
�0�6��%clearTabStops 20 sp flushLeft tabStop�����	�&K�%clearTabStops 20 sp flushLeft tabStop���
�)�/��%clearTabStops 20 sp flushLeft tabStop�����	�*K�%clearTabStops 20 sp flushLeft tabStop���
�"�(��%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�"K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������'K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�%K�%clearTabStops 20 sp flushLeft tabStop���
�(�.��%clearTabStops 20 sp flushLeft tabStop�����	�)K�%clearTabStops 20 sp flushLeft tabStop���
�!�'��%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��"K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���/�%clearTabStops 20 sp flushLeft tabStop������	�
�)K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
���(�%clearTabStops 20 sp flushLeft tabStop����	�
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop���
��
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
�'�-��%clearTabStops 20 sp flushLeft tabStop���(���?K�%clearTabStops 20 sp flushLeft tabStop���
�8�>K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
��
�.�%clearTabStops 20 sp flushLeft tabStop�����
�$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�.K�%clearTabStops 20 sp flushLeft tabStop���
��$K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��	���
��	�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������%K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���.�%clearTabStops 20 sp flushLeft tabStop����	�
� K�%clearTabStops 20 sp flushLeft tabStop���
���%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
���%clearTabStops 20 sp flushLeft tabStop�����
�"K�%clearTabStops 20 sp flushLeft tabStop���
�����%clearTabStops 20 sp flushLeft tabStop�����
� K�%clearTabStops 20 sp flushLeft tabStop���
���%clearTabStops 20 sp flushLeft tabStop�����
�$K�%clearTabStops 20 sp flushLeft tabStop���
�����%clearTabStops 20 sp flushLeft tabStop�����
�$K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop������&K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�-�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�A�G��%clearTabStops 20 sp flushLeft tabStop���*�-K�%clearTabStops 20 sp flushLeft tabStop���
�(�.K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�� ��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���#�%clearTabStops 20 sp flushLeft tabStop���
�	�
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���'�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
� �&��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�&�,��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��%��%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
�)�/K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
��!��%clearTabStops 20 sp flushLeft tabStop���-�0K�%clearTabStops 20 sp flushLeft tabStop���
�E�K��%clearTabStops 20 sp flushLeft tabStop���(�+K�%clearTabStops 20 sp flushLeft tabStop���
�?�E��%clearTabStops 20 sp flushLeft tabStop��� �#K�%clearTabStops 20 sp flushLeft tabStop���
�,�2K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�)�%clearTabStops 20 sp flushLeft tabStop���3�6K�%clearTabStops 20 sp flushLeft tabStop���
�2�8K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�(�%clearTabStops 20 sp flushLeft tabStop�����
����
�CK�%clearTabStops 20 sp flushLeft tabStop���
�&�,��%clearTabStops 20 sp flushLeft tabStop�����
����
�GK�%clearTabStops 20 sp flushLeft tabStop���
�&�,�%clearTabStops 20 sp flushLeft tabStop�����
��	�<K�%clearTabStops 20 sp flushLeft tabStop���
�-�3K�%clearTabStops 20 sp flushLeft tabStop�����%clearTabStops 20 sp flushLeft tabStop��	���
���"�%clearTabStops 20 sp flushLeft tabStop���'�*K�%clearTabStops 20 sp flushLeft tabStop���
�"�(��%clearTabStops 20 sp flushLeft tabStop�����	�+K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����	�+K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop���/�2K�%clearTabStops 20 sp flushLeft tabStop���
�+�1K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�,�%clearTabStops 20 sp flushLeft tabStop���"�%K�%clearTabStops 20 sp flushLeft tabStop���
��#K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���'�%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop������#K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop���%clearTabStops 20 sp flushLeft tabStop��
��K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
�+�1��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�9�?��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�O�U��%clearTabStops 20 sp flushLeft tabStop����"K�%clearTabStops 20 sp flushLeft tabStop���
�C�I�K�%clearTabStops 20 sp flushLeft tabStop��%clearTabStops 20 sp flushLeft tabStop���+�.K�%clearTabStops 20 sp flushLeft tabStop���
�D�J��%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop���
�R�X��%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�h�n��%clearTabStops 20 sp flushLeft tabStop���,�/�%clearTabStops 20 sp flushLeft tabStop���
�\�bK�%clearTabStops 20 sp flushLeft tabStop�����%clearTabStops 20 sp flushLeft tabStop��
���
���*�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�H�N��%clearTabStops 20 sp flushLeft tabStop���)�,K�%clearTabStops 20 sp flushLeft tabStop���
�(�.K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���*�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���'�*K�%clearTabStops 20 sp flushLeft tabStop���
�#�)K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��
K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���&�)K�%clearTabStops 20 sp flushLeft tabStop���
�0�6K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop���,�/K�%clearTabStops 20 sp flushLeft tabStop���
�.�4K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�(�.��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���#�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�(�.��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��$K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����!K�%clearTabStops 20 sp flushLeft tabStop���
��#��%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���#�&K�%clearTabStops 20 sp flushLeft tabStop���
��%K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��	�$�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop������*K�%clearTabStops 20 sp flushLeft tabStop���
��%��%clearTabStops 20 sp flushLeft tabStop������!K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������*K�%clearTabStops 20 sp flushLeft tabStop���
��%��%clearTabStops 20 sp flushLeft tabStop������"K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�"�%clearTabStops 20 sp flushLeft tabStop������'K�%clearTabStops 20 sp flushLeft tabStop���
�	���%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��
�&�%clearTabStops 20 sp flushLeft tabStop����K�%clearTabStops 20 sp flushLeft tabStop���
�>�D��%clearTabStops 20 sp flushLeft tabStop���&�)K�%clearTabStops 20 sp flushLeft tabStop���
�"�(K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���(�%clearTabStops 20 sp flushLeft tabStop�������
�(K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�������
��
�=K�%clearTabStops 20 sp flushLeft tabStop���
�,�2K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
��� �%clearTabStops 20 sp flushLeft tabStop���%�(K�%clearTabStops 20 sp flushLeft tabStop���
�W�]��%clearTabStops 20 sp flushLeft tabStop���1�4K�%clearTabStops 20 sp flushLeft tabStop���
�A�GK�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���"�%clearTabStops 20 sp flushLeft tabStop������&K�%clearTabStops 20 sp flushLeft tabStop���
�}��
��%clearTabStops 20 sp flushLeft tabStop������%K�%clearTabStops 20 sp flushLeft tabStop���
�;�A��%clearTabStops 20 sp flushLeft tabStop�������
���4K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop������.K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���
���K�%clearTabStops 20 sp flushLeft tabStop���
�0�6K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop��
���
���0�%clearTabStops 20 sp flushLeft tabStop������(K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���!�$K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop���%�(K�%clearTabStops 20 sp flushLeft tabStop���
��K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
���1�%clearTabStops 20 sp flushLeft tabStop���� K�%clearTabStops 20 sp flushLeft tabStop���
�K�Q��%clearTabStops 20 sp flushLeft tabStop���0�3K�%clearTabStops 20 sp flushLeft tabStop���
�.�4K�%clearTabStops 20 sp flushLeft tabStop����%clearTabStops 20 sp flushLeft tabStop�����
����%clearTabStops 20 sp flushLeft tabStop������K�%clearTabStops 20 sp flushLeft tabStop���
����%clearTabStops 20 sp flushLeft tabStop�����
�K�%clearTabStops 20 sp flushLeft tabStop���
�
���%clearTabStops 20 sp flushLeft tabStop���
��
�K�%clearTabStops 20 sp flushLeft tabStop���
�
�K�%clearTabStops 20 sp flushLeft tabStop���K�%clearTabStops 20 sp flushLeft tabStop��K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop�K�%clearTabStops 20 sp flushLeft tabStop�������