DIRECTORY AbSets, Atom, Basics, BiRelBasics, IntStuff, SetBasics;

BiRels: CEDAR DEFINITIONS
IMPORTS AbSets, BiRelBasics, IntStuff, SetBasics
= {OPEN IntStuff, SetBasics, Sets:AbSets, Sets, BiRelBasics;
EINT: TYPE ~ IntStuff.EINT;

Value: TYPE ~ SetBasics.Value;
Interval: TYPE ~ SetBasics.Interval;
IntInterval: TYPE ~ SetBasics.IntInterval;

Set: TYPE ~ Sets.Set;
Direction: TYPE ~ Sets.Direction;
Side: TYPE ~ Sets.Side;

Pair: TYPE ~ BiRelBasics.Pair;
noPair: Pair ~ BiRelBasics.noPair;
LOP: TYPE ~ LIST OF Pair;
MaybePair: TYPE ~ BiRelBasics.MaybePair;
noMaybePair: MaybePair ~ BiRelBasics.noMaybePair;
TripleMaybePair: TYPE ~ BiRelBasics.TripleMaybePair;
MaybePairInterval: TYPE ~ BiRelBasics.MaybePairInterval;
MaybePairSpace: TYPE ~ BiRelBasics.MaybePairSpace;
Had: TYPE ~ BiRelBasics.Had;
HadPair: TYPE ~ BiRelBasics.HadPair;
HadSetPair: TYPE ~ BiRelBasics.HadSetPair;
IfHad: TYPE ~ BiRelBasics.IfHad;
IfHadPair: TYPE ~ BiRelBasics.IfHadPair;
alwaysAdd: IfHadPair ~ BiRelBasics.alwaysAdd;
addIfNew: IfHadPair ~ BiRelBasics.addIfNew;
addIfOld: IfHadPair ~ BiRelBasics.addIfOld;
BoolPair: TYPE ~ BiRelBasics.BoolPair;
SpacePair: TYPE ~ BiRelBasics.SpacePair;
SetPair: TYPE ~ BiRelBasics.SetPair;
PairInterval: TYPE ~ BiRelBasics.PairInterval;
RelOrder: TYPE ~ BiRelBasics.RelOrder;
TotalRelOrder: TYPE ~ BiRelBasics.TotalRelOrder;
leftFwd: RelOrder ~ BiRelBasics.leftFwd;
leftBwd: RelOrder ~ BiRelBasics.leftBwd;
rightFwd: RelOrder ~ BiRelBasics.rightFwd;
rightBwd: RelOrder ~ BiRelBasics.rightBwd;
PairSpace: TYPE ~ BiRelBasics.PairSpace;
BiRel: TYPE ~ RECORD [class: BiRelClass, data: REF ANY];

ConsBiRel: PROC [class: BiRelClass, data: REF ANY] RETURNS [BiRel];

nilBiRel: BiRel ~ [NIL, NIL];
badBiRel: READONLY BiRel;

DeRef: PROC [ra: REF ANY] RETURNS [BiRel]
~ INLINE {RETURN [IF ra#NIL THEN NARROW[ra, RefBiRel]^ ELSE nilBiRel]};
Refify: PROC [br: BiRel] RETURNS [RefBiRel]
~ INLINE {RETURN [NEW [BiRel _ br]]};
Cant: ERROR [br: BiRel];

AsSet: PROC [br: BiRel, ro: RelOrder] RETURNS [Set--of REF Pair--]
~ INLINE {RETURN br.class.AsSet[br, ro]};

HasPair: PROC [br: BiRel, pair: Pair] RETURNS [BOOL]
~ INLINE {RETURN br.class.HasPair[br, pair]};

Image: PROC [br: BiRel, set: Set, dir: Direction _ leftToRight] RETURNS [Set]
~ INLINE {RETURN br.class.Image[br, set, dir]};

Mapping: PROC [br: BiRel, v: Value, dir: Direction _ leftToRight] RETURNS [Set]
~ INLINE {RETURN br.class.Image[br, Sets.CreateSingleton[v, br.Spaces[][Source[dir]]], dir]};

MappingA: PROC [br: BiRel, v: REF ANY, dir: Direction _ leftToRight] RETURNS [Set]
~ INLINE {RETURN br.class.Image[br, Sets.CreateSingleton[[a[v]], br.Spaces[][Source[dir]]], dir]};

MappingI: PROC [br: BiRel, v: INT, dir: Direction _ leftToRight] RETURNS [Set]
~ INLINE {RETURN br.class.Image[br, Sets.CreateSingleton[[i[v]], br.Spaces[][Source[dir]]], dir]};

Enumerate: PROC [br: BiRel, Consume: PROC [Pair], ro: RelOrder _ []];

EnumAA: PROC [br: BiRel, Consume: PROC [REF ANY, REF ANY], ro: RelOrder _ []];
EnumIA: PROC [br: BiRel, Consume: PROC [INT, REF ANY], ro: RelOrder _ []];
EnumII: PROC [br: BiRel, Consume: PROC [INT, INT], ro: RelOrder _ []];

Tester: TYPE ~ PROC [Pair] RETURNS [BOOL];
AcceptAny: Tester--={RETURN[TRUE]}--;

Scan: PROC [br: BiRel, Test: Tester, ro: RelOrder _ []] RETURNS [MaybePair]
~ INLINE {RETURN br.class.ScanRestriction[br, [], Test, ro]};

EnumerateImage: PROC [br: BiRel, set: Set, Consume: PROC [Value], dir: Direction _ leftToRight, ro: Sets.RelOrder _ no];

EnumerateMapping: PROC [br: BiRel, v: Value, Consume: PROC [Value], dir: Direction _ leftToRight, ro: Sets.RelOrder _ no]
~ INLINE {EnumerateImage[br, Sets.CreateSingleton[v, br.Spaces[][Source[dir]]], Consume, dir, ro]};

EnumerateHalfRestriction: PROC [br: BiRel, set: Set, Consume: PROC [Pair], side: Side _ left, ro: RelOrder _ []];

ScanImage: PROC [br: BiRel, set: Set, Test: Sets.Tester, dir: Direction _ leftToRight, ro: Sets.RelOrder _ no] RETURNS [MaybePair];

ScanMapping: PROC [br: BiRel, v: Value, Test: Sets.Tester, dir: Direction _ leftToRight, ro: Sets.RelOrder _ no] RETURNS [MaybePair]
~ INLINE {RETURN ScanImage[br, Sets.CreateSingleton[v, br.Spaces[][Source[dir]]], Test, dir, ro]};

ScanRestriction: PROC [br: BiRel, sets: SetPair _ [], Test: Tester, ro: RelOrder _ []] RETURNS [MaybePair]
~ INLINE {RETURN br.class.ScanRestriction[br, sets, Test, ro]};

ScanHalfRestriction: PROC [br: BiRel, set: Set, Test: Tester, side: Side _ left, ro: RelOrder _ []] RETURNS [MaybePair]
~ INLINE {RETURN br.class.ScanRestriction[br, ConsSets[side, set], Test, ro]};

ParallelScan: PROC [a, b: BiRel, Test: ParallelTester, roA, roB: RelOrder _ []] RETURNS [ParallelFind]
~ INLINE {RETURN ParallelScanRestriction[a, b, Test, [], [], roA, roB]};

ParallelScanRestriction: PROC [a, b: BiRel, Test: ParallelTester, setsA, setsB: SetPair _ [], roA, roB: RelOrder _ []] RETURNS [ParallelFind];

ParallelTester: TYPE ~ PROC [a, b: MaybePair] RETURNS [pass: BOOL _ FALSE];
ParallelFind: TYPE ~ RECORD [found: BOOL, a, b: MaybePair];

InterleavedProduceRestriction: PROC [a, b: BiRel, Consume: InterleavedConsumer, setsA, setsB: SetPair _ [], roA, roB: RelOrder _ []] RETURNS [MaybePair];

InterleavedConsumer: TYPE ~ PROC [PROC [Which] RETURNS [MaybePair]] RETURNS [MaybePair];

GetOne: PROC [br: BiRel, remove: BOOL, ro: RelOrder] RETURNS [MaybePair]
~ INLINE {RETURN br.class.GetOne[br, remove, ro]};
APair: PROC [br: BiRel, ro: RelOrder _ []] RETURNS [MaybePair]
~ INLINE {RETURN br.class.GetOne[br, FALSE, ro]};
Pop: PROC [br: BiRel, ro: RelOrder _ []] RETURNS [MaybePair]
~ INLINE {RETURN br.class.GetOne[br, TRUE, ro]};
First: PROC [br: BiRel] RETURNS [MaybePair]
~ INLINE {RETURN br.class.GetOne[br, FALSE, [ALL[fwd]]]};
Last: PROC [br: BiRel] RETURNS [MaybePair]
~ INLINE {RETURN br.class.GetOne[br, FALSE, [ALL[bwd]]]};

Next: PROC [br: BiRel, pair: Pair, ro: RelOrder _ [[fwd, no]]] RETURNS [MaybePair]
~ INLINE {RETURN [br.class.Get3[br, pair, ro, [FALSE, FALSE, TRUE]].next]};
Prev: PROC [br: BiRel, pair: Pair, ro: RelOrder _ [[fwd, no]]] RETURNS [MaybePair]
~ INLINE {RETURN [br.class.Get3[br, pair, ro, [TRUE, FALSE, FALSE]].prev]};
Get3: PROC [br: BiRel, pair: Pair, ro: RelOrder _ [[fwd, no]], want: TripleBool _ []] RETURNS [TripleMaybePair]
~ INLINE {RETURN br.class.Get3[br, pair, ro, want]};

SkipTo: PROC [br: BiRel, goal: Set, bounds: Interval _ [], side: Side _ left, bwd: BOOL _ FALSE] RETURNS [MaybePair]
~ INLINE {RETURN br.ScanRestriction[ConsSets[side, IntervalAsSet[br.Spaces[][side], bounds], goal], AcceptAny, ConsRelOrder[side, IF bwd THEN bwd ELSE fwd]]};

Lookup: PROC [br: BiRel, goal: Value, bounds: Interval _ [], side: Side _ left, bwd: BOOL _ FALSE] RETURNS [MaybeValue]
~ INLINE {RETURN br.SkipTo[Sets.CreateSingleton[goal, br.Spaces[][side]], bounds, side, bwd].KeepHalf[OtherSide[side]]};

Size: PROC [br: BiRel, limit: EINT _ lastEINT] RETURNS [EINT]
~ INLINE {RETURN [br.class.RestrictionSize[br, [], limit]]};

Empty: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.Size[one]=zero]};

RestrictionSize: PROC [br: BiRel, sets: SetPair _ [], limit: EINT _ lastEINT] RETURNS [EINT]
~ INLINE {RETURN br.class.RestrictionSize[br, sets, limit]};

ImageSize: PROC [br: BiRel, set: Set, dir: Direction _ leftToRight, limit: EINT _ lastEINT] RETURNS [EINT];

MappingSize: PROC [br: BiRel, v: Value, dir: Direction _ leftToRight, limit: EINT _ lastEINT] RETURNS [EINT]
~ INLINE {RETURN ImageSize[br, Sets.CreateSingleton[v, br.Spaces[][Source[dir]]], dir, limit]};

MappingEmpty: PROC [br: BiRel, v: Value, dir: Direction _ leftToRight] RETURNS [BOOL]
~ INLINE {RETURN [MappingSize[br, v, dir, one]=zero]};

IsDense: PROC [br: BiRel, when: When _ always, side: Side _ left] RETURNS [BOOL]
~ INLINE {RETURN br.class.IsDense[br, when, side]};
denseSide: READONLY ROPE; --complaint raised when a caller tries an operation that would put a hole in a necessarily dense side of a BiRel.

SideFixed: PROC [br: BiRel, side: Side _ left] RETURNS [BOOL]
~ INLINE {RETURN br.class.SideFixed[br, side]};
fixedSide: READONLY ROPE; --complaint raised when a caller tries an operation that would change a fixed side of a BiRel.

GetBounds: PROC [br: BiRel, want: EndBools _ [], ro: RelOrder _ [[fwd, no]]] RETURNS [MaybePairInterval]
~ INLINE {RETURN br.class.GetBounds[br, want, ro]};

MutabilityOf: PROC [br: BiRel] RETURNS [Mutability]
~ INLINE {RETURN [br.class.mutability]};

Copy: PROC [br: BiRel] RETURNS [VarBiRel]
~ INLINE {RETURN br.class.Copy[br]};

Insulate: PROC [br: BiRel] RETURNS [UWBiRel]
~ INLINE {RETURN br.class.Insulate[br]};

ValueOf: PROC [br: BiRel] RETURNS [ConstBiRel]
~ INLINE {RETURN br.class.ValueOf[br]};

Freeze: PROC [br: BiRel] RETURNS [ConstBiRel]
~ INLINE {RETURN br.class.Freeze[br]};

Thaw: PROC [br: BiRel]
~ INLINE {br.class.Thaw[br]};

Has: PROC [br, other: BiRel, want: BoolPair] RETURNS [HadSetPair];

AddPair: PROC [br: BiRel, pair: Pair, if: IfHadPair _ alwaysAdd] RETURNS [had: HadPair]
~ INLINE {RETURN br.class.AddPair[br, pair, if]};

AddAA: PROC [br: BiRel, left, right: REF ANY, if: IfHadPair _ alwaysAdd] RETURNS [had: HadPair];
AddIA: PROC [br: BiRel, left: INT, right: REF ANY, if: IfHadPair _ alwaysAdd] RETURNS [had: HadPair];
AddII: PROC [br: BiRel, left, right: INT, if: IfHadPair _ alwaysAdd] RETURNS [had: HadPair];

AddNewPair: PROC [br: BiRel, pair: Pair];

AddNewAA: PROC [br: BiRel, left, right: REF ANY];
AddNewIA: PROC [br: BiRel, left: INT, right: REF ANY];
AddNewII: PROC [br: BiRel, left, right: INT];

AddSet: PROC [br, other: BiRel, if: IfHadPair _ alwaysAdd] RETURNS [some: HadSetPair]
~ INLINE {RETURN br.class.AddSet[br, other, if]};

AddNewSet: PROC [br, other: BiRel];

Swap: PROC [br: BiRel, a, b: Value, side: Side _ left]
~ INLINE {br.class.Swap[br, a, b, side]};

RemPair: PROC [br: BiRel, pair: Pair] RETURNS [had: HadPair]
~ INLINE {RETURN br.class.RemPair[br, pair]};

RemAA: PROC [br: BiRel, left, right: REF ANY] RETURNS [had: HadPair];
RemIA: PROC [br: BiRel, left: INT, right: REF ANY] RETURNS [had: HadPair];
RemII: PROC [br: BiRel, left, right: INT] RETURNS [had: HadPair];

RemSet: PROC [br, other: BiRel] RETURNS [some: HadSetPair]
~ INLINE {RETURN br.class.RemSet[br, other]};

Erase: PROC [br: BiRel]
~ INLINE {[] _ br.RemSet[br]};

Delete: PROC [br: BiRel, val: Value, side: Side _ left] RETURNS [hadSome: BOOL]
~ INLINE {RETURN br.class.Delete[br, val, side]};

DeleteA: PROC [br: BiRel, val: REF ANY, side: Side _ left] RETURNS [hadSome: BOOL]
~ INLINE {RETURN br.class.Delete[br, [a[val]], side]};

DeleteI: PROC [br: BiRel, val: INT, side: Side _ left] RETURNS [hadSome: BOOL]
~ INLINE {RETURN br.class.Delete[br, [i[val]], side]};

DeleteSet: PROC [br: BiRel, set: Set, side: Side _ left] RETURNS [had: SomeAll]
~ INLINE {RETURN br.class.DeleteSet[br, set, side]};

Spaces: PROC [br: BiRel] RETURNS [SpacePair]
~ INLINE {RETURN br.class.Spaces[br]};

SetOn: PROC [br: BiRel, side: Side] RETURNS [UWSet]
~ INLINE {RETURN [br.class.SetOn[br, side]]};

CurSetOn: PROC [br: BiRel, side: Side] RETURNS [ConstSet]
~ INLINE {RETURN br.class.CurSetOn[br, side]};

Functional: PROC [br: BiRel] RETURNS [BoolPair]
~ INLINE {RETURN [br.class.functional]};

Equal: PROC [a, b: BiRel, bounds: SetPair _ []] RETURNS [BOOL];

Hash: PROC [br: BiRel, bounds: SetPair _ []] RETURNS [CARDINAL];

Compare: PROC [a, b: BiRel, bounds: SetPair _ [], tro: TotalRelOrder _ [ALL[fwd]]] RETURNS [Comparison];

CreateBiRelSpace: PROC [eltSpaces: SpacePair] RETURNS [Space];

QuaBiRelSpace: PROC [Space] RETURNS [found: BOOL, eltSpaces: SpacePair];
SetIsBiRel: PROC [set: Set] RETURNS [BOOL]
~ INLINE {RETURN [set.class.QuaBiRel[set].found]};
SetAsBiRel: PROC [set: Set] RETURNS [BiRel]
~ INLINE {RETURN [SetQuaBiRel[set].it]};
SetQuaBiRel: PROC [set: Set] RETURNS [MaybeBiRel]
~ INLINE {
found: BOOL;
class, data: REF ANY;
[found, class, data] _ set.class.QuaBiRel[set];
RETURN [IF found THEN [TRUE, [NARROW[class], data]] ELSE [FALSE, badBiRel]]};
VarBiRel: TYPE ~ RECORD [BiRel] --a variable BiRel--;
IsVar: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.mutability=variable]};
AsVar: PROC [br: BiRel] RETURNS [VarBiRel]
~ INLINE {IF br#nilBiRel AND br.class.mutability#variable THEN Complain[br, notVariable]; RETURN [[br]]};

UWBiRel: TYPE ~ RECORD [BiRel] --an unwritable BiRel--;
IsUW: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.mutability#variable]};
AsUW: PROC [br: BiRel] RETURNS [UWBiRel]
~ INLINE {IF br#nilBiRel AND br.class.mutability=variable THEN Complain[br, writeable]; RETURN [[br]]};

ConstBiRel: TYPE ~ RECORD [UWBiRel] --a constant BiRel--;
IsConst: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.mutability=constant]};
AsConst: PROC [br: BiRel] RETURNS [ConstBiRel]
~ INLINE {IF br#nilBiRel AND br.class.mutability#constant THEN Complain[br, notConstant]; RETURN [[[br]]]};

Function: TYPE ~ BiRel --a BiRel that doesn't have two pairs with equal left sides--;
VarFunction: TYPE ~ VarBiRel;
UWFunction: TYPE ~ UWBiRel;
ConstFunction: TYPE ~ ConstBiRel;
IsFunction: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.functional[leftToRight]]};
AsFunction: PROC [br: BiRel] RETURNS [Function]
~ INLINE {IF NOT br.class.functional[leftToRight] THEN br.Complain[narrowFault]; RETURN [br]};

InvFunction: TYPE ~ BiRel --a BiRel that doesn't have two pairs with equal right sides--;
IsInvFunction: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.functional[rightToLeft]]};
AsInvFunction: PROC [br: BiRel] RETURNS [InvFunction]
~ INLINE {IF NOT br.class.functional[rightToLeft] THEN br.Complain[narrowFault]; RETURN [br]};

OneToOne: TYPE ~ BiRel --a one-to-one BiRel--;
VarOneToOne: TYPE ~ VarBiRel;
ConstOneToOne: TYPE ~ ConstBiRel;
IsOneToOne: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.class.functional=ALL[TRUE]]};
AsOneToOne: PROC [br: BiRel] RETURNS [OneToOne]
~ INLINE {IF NOT br.class.functional=ALL[TRUE] THEN br.Complain[narrowFault]; RETURN [br]};

Apply: PROC [br: BiRel, v: Value, dir: Direction _ leftToRight] RETURNS [MaybeValue]
~ INLINE {RETURN br.class.Apply[br, v, dir]};
mappingNotSingleton: READONLY ROPE;

ApplyA: PROC [br: BiRel, v: REF ANY, dir: Direction _ leftToRight] RETURNS [MaybeValue]
~ INLINE {RETURN br.class.Apply[br, [a[v]], dir]};

ApplyI: PROC [br: BiRel, v: INT, dir: Direction _ leftToRight] RETURNS [MaybeValue]
~ INLINE {RETURN br.class.Apply[br, [i[v]], dir]};

IntRel: TYPE ~ BiRel --where left side may only contain integers--;
IsIntRel: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [QuaIntRel[br].found]};
AsIntRel: PROC [br: BiRel] RETURNS [IntRel]
~ INLINE {RETURN [QuaIntRel[br].it]};
QuaIntRel: PROC [br: BiRel] RETURNS [MaybeBiRel];

GetIntDom: PROC [br: BiRel, want: EndBools _ []] RETURNS [IntInterval];

ShiftAndClipMe: PROC [br: IntRel, shift: EINT _ zero, clip: IntInterval _ []]
~ INLINE {br.class.ShiftAndClipMe[br, shift, clip]};

Index: PROC [br, goal: IntRel, bounds: IntInterval _ [], bwd: BOOL _ FALSE] RETURNS [MaybeValue]
~ INLINE {RETURN br.class.Index[br, goal, bounds, bwd]};

ReplaceMe: PROC [br, with: IntRel, where: IntInterval]
~ INLINE {br.class.ReplaceMe[br, with, where]};

Insert: PROC [br: IntRel, val: Value, before: INT]
~ INLINE {[] _ ReplaceMe[br, CreateSingleton[[[i[0]], val], br.Spaces], [before, before-1]]};

Append: PROC [br: IntRel, val: Value]
~ INLINE {Insert[br, val, br.GetIntDom.max+1]};

AppendA: PROC [br: IntRel, val: REF ANY]
~ INLINE {Insert[br, [a[val]], br.GetIntDom.max+1]};

AppendI: PROC [br: IntRel, val: INT]
~ INLINE {Insert[br, [i[val]], br.GetIntDom.max+1]};

IntFn: TYPE ~ IntRel --that is Functional[leftToRight]--;
ConstIntFn: TYPE ~ ConstBiRel;
IsIntFn: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [QuaIntFn[br].found]};
AsIntFn: PROC [br: BiRel] RETURNS [IntFn]
~ INLINE {RETURN [QuaIntFn[br].it]};
QuaIntFn: PROC [br: BiRel] RETURNS [MaybeBiRel];

Array: TYPE ~ IntFn --whose domain is an interval--;
IsArray: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [IsIntFn[br] AND br.IsDense[now, left]]};
AsArray: PROC [br: BiRel] RETURNS [Array]
~ INLINE {IF NOT (IsIntFn[br] AND br.IsDense[now, left]) THEN br.Complain[narrowFault]; RETURN [br]};

FixedArray: TYPE ~ Array --whose domain will never change--;
IsFixedArray: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [IsIntFn[br] AND br.IsDense[always, left] AND br.SideFixed[left]]};
AsFixdArray: PROC [br: BiRel] RETURNS [FixedArray]
~ INLINE {IF NOT IsFixedArray[br] THEN br.Complain[narrowFault]; RETURN [br]};

Sequence: TYPE ~ Array --whose lower bound is 0--;
IsSequence: PROC [br: BiRel] RETURNS [BOOL]
~ INLINE {RETURN [br.IsArray AND br.GetIntDom[].min=0]};

Automorphism: TYPE ~ BiRel--that's one-to-one, and domain = range--;
Permutation: TYPE ~ Sequence--that's an Automorphism--;

GradeUp: PROC [a: IntFn, o: SetBasics.Order] RETURNS [p: Permutation];
TransPermute: PROC [from: IntFn, to: Sequence, p: Permutation];
PermuteInPlace: PROC [a: Sequence, p: Permutation];
CreateEmptyBiRel: PROC [SpacePair] RETURNS [ConstBiRel];
CreateIDSubset: PROC [Set] RETURNS [BiRel];
IsIDSubset: PROC [BiRel] RETURNS [BOOL];
CreateFullIDSubset: PROC [s: Space] RETURNS [ConstOneToOne]
~ INLINE {RETURN [CreateIDSubset[CreateFullSet[s]].AsConst]};
CreateAllPairs: PROC [SpacePair] RETURNS [ConstOneToOne];

CreateSingleton: PROC [elt: Pair, spaces: SpacePair] RETURNS [ConstBiRel]
~ INLINE {RETURN [[[[GetSingletonClass[spaces], NEW [Pair _ elt]]]]]};
GetSingletonClass: PROC [spaces: SpacePair] RETURNS [BiRelClass];

NCreateSingleton: PROC [elt: Pair, spaces: SpacePair] RETURNS [ConstBiRel];

CreateConstant: PROC [bounds: Interval, val: Value, spaces: SpacePair _ [ints, basic]] RETURNS [ConstIntFn]
~ INLINE {RETURN CreateProduct[[IntervalAsSet[spaces[left], bounds], Sets.CreateSingleton[val, spaces[right]]]].AsConst};

CreateProduct: PROC [SetPair] RETURNS [BiRel];

FnFromProc: PROC
[
Apply: PROC [data: REF ANY, v: Value] RETURNS [mv: MaybeValue],
spaces: SpacePair _ [basic, basic],
data: REF ANY _ NIL,
constant, oneToOne: BOOL _ FALSE,
ScanInverse: PROC [data: REF ANY, v: Value, Test: Tester] RETURNS [MaybePair] _ NIL
]
RETURNS [Function];

CreateSimple: PROC [bounds: IntInterval _ [0, -1], val: Value _ noValue, oneToOne, dense, domainFixed: BOOL _ FALSE, rightSpace: Space _ basic] RETURNS [IntFn];

CreateSimpleCopy: PROC [of: IntFn, bounds: IntInterval _ [], oneToOne, dense, domainFixed: RelBool _ SAME, rightSpace: Space _ NIL] RETURNS [IntFn];

CreateList: PROC [vals: LOP, functional: BoolPair _ [FALSE, FALSE], spaces: SpacePair _ [basic, basic], mutability: Mutability _ variable, order: RelOrder _ [], assumeSorted: BOOL _ FALSE] RETURNS [VarBiRel];

HashFn: TYPE ~ VarFunction;

CreateHashReln: PROC [spaces: SpacePair _ [basic, basic], functional: BoolPair _ [FALSE, FALSE], mappable: BoolPair _ [TRUE, TRUE]] RETURNS [VarBiRel];
CreateHashOTO: PROC [spaces: SpacePair _ [basic, basic]] RETURNS [VarOneToOne]
~ INLINE {RETURN CreateHashReln[spaces, ALL[TRUE]]};
CreateHashFn: PROC [spaces: SpacePair _ [basic, basic], invable: BOOL _ TRUE] RETURNS [HashFn]
~ INLINE {RETURN CreateHashReln[spaces, [TRUE, FALSE], [TRUE, invable]]};
CreateHashTable: PROC [right: Space _ basic, invable: BOOL _ TRUE] RETURNS [HashFn]
~ INLINE {RETURN CreateHashReln[[basic, right], [TRUE, FALSE], [TRUE, invable]]};
CreateHashDictionary: PROC [case: BOOL _ TRUE, right: Space _ basic, invable: BOOL _ TRUE] RETURNS [HashFn]
~ INLINE {RETURN CreateHashReln[[ropes[case], right], [TRUE, FALSE], [TRUE, invable]]};
CreateHashCopy: PROC [br: BiRel, spaces: SpacePair _ [NIL, NIL], mappable: BoolPair _ [FALSE, FALSE]] RETURNS [HashFn];

Union: PROC [a, b: BiRel, disjoint: BOOL _ FALSE, ro: RelOrder _ []] RETURNS [UWBiRel];
Intersection: PROC [BiRel, BiRel] RETURNS [UWBiRel];
Difference: PROC [BiRel, BiRel] RETURNS [UWBiRel];
SymmetricDifference: PROC [a, b: BiRel] RETURNS [c: UWBiRel];
Negate: PROC [BiRel] RETURNS [BiRel];
Compose: PROC [left, right: BiRel, restricts: ARRAY Side OF BOOL _ [TRUE, TRUE]] RETURNS [BiRel];
Invert: PROC [BiRel] RETURNS [BiRel];
Collect: PROC [u: BiRel, side: Side _ right] RETURNS [c: Function];
UnCollect: PROC [c: Function, side: Side _ right] RETURNS [u: BiRel];

Replace: PROC [br, with: IntRel, where: IntInterval] RETURNS [IntRel];

ShiftAndClip: PROC [br: IntRel, shift: EINT _ zero, clip: IntInterval _ []] RETURNS [IntRel];

CreateShiftAndClipper: PROC [shift: EINT _ zero, clip: IntInterval _ []] RETURNS [ConstOneToOne];

Shift: PROC [br: IntRel, shift: EINT] RETURNS [IntRel]
~ INLINE {RETURN ShiftAndClip[br, shift]};

Subseq: PROC [br: IntRel, bounds: IntInterval] RETURNS [IntRel]
~ INLINE {RETURN ShiftAndClip[br, IE[bounds.min].Neg, bounds]};

ImplementSetBySequence: PROC [seq: Sequence, addat: SeqAddPlace, closeGaps: BOOL] RETURNS [Set];
SeqAddPlace: TYPE ~ {front, back};

ImplementSetByIDSubset: PROC [ids: OneToOne] RETURNS [Set];

EnumSeqOfSet: PROC [set: Set, ro: Sets.RelOrder _ no] RETURNS [Sequence];
BiRelClass: TYPE ~ REF BiRelClassPrivate;
BiRelClassPrivate: TYPE ~ MONITORED RECORD [
Primitive: PROC [br: BiRel, op: ATOM, arg1, arg2: REF ANY _ NIL] RETURNS [PrimitiveAnswer] _ NIL,
AsSet: PROC [br: BiRel, ro: RelOrder] RETURNS [Set--of REF Pair--] _ NIL,
HasPair: PROC [br: BiRel, pair: Pair] RETURNS [BOOL] _ NIL,
Image: PROC [br: BiRel, set: Set, dir: Direction] RETURNS [Set] _ NIL,
Apply: PROC [br: BiRel, v: Value, dir: Direction] RETURNS [MaybeValue] _ NIL,
ScanRestriction: PROC [br: BiRel, sets: SetPair, Test: Tester, ro: RelOrder] RETURNS [MaybePair] _ NIL,
GetOne: PROC [br: BiRel, remove: BOOL, ro: RelOrder] RETURNS [MaybePair] _ NIL,
Get3: PROC [br: BiRel, pair: Pair, ro: RelOrder, want: TripleBool] RETURNS [TripleMaybePair] _ NIL,
Index: PROC [br, goal: IntRel, bounds: IntInterval, bwd: BOOL] RETURNS [MaybeValue] _ NIL,
RestrictionSize: PROC [br: BiRel, sets: SetPair, limit: EINT] RETURNS [EINT] _ NIL,
GetBounds: PROC [br: BiRel, want: EndBools, ro: RelOrder] RETURNS [MaybePairInterval] _ NIL,
Copy: PROC [br: BiRel] RETURNS [VarBiRel] _ NIL,
Insulate: PROC [br: BiRel] RETURNS [UWBiRel] _ NIL,
ValueOf: PROC [br: BiRel] RETURNS [ConstBiRel] _ NIL,
Freeze: PROC [br: BiRel] RETURNS [ConstBiRel] _ NIL,
Thaw: PROC [br: BiRel] _ NIL,
SetOn: PROC [br: BiRel, side: Side] RETURNS [UWSet] _ NIL,
CurSetOn: PROC [br: BiRel, side: Side] RETURNS [ConstSet] _ NIL,
AddPair: PROC [br: BiRel, pair: Pair, if: IfHadPair] RETURNS [had: HadPair] _ NIL,
AddSet: PROC [br, other: BiRel, if: IfHadPair] RETURNS [some: HadSetPair] _ NIL,
Swap: PROC [br: BiRel, a, b: Value, side: Side] _ NIL,
RemPair: PROC [br: BiRel, pair: Pair] RETURNS [had: HadPair] _ NIL,
RemSet: PROC [br, other: BiRel] RETURNS [some: HadSetPair] _ NIL,
Delete: PROC [br: BiRel, val: Value, side: Side] RETURNS [hadSome: BOOL] _ NIL,
DeleteSet: PROC [br: BiRel, set: Set, side: Side] RETURNS [had: SomeAll] _ NIL,
ReplaceMe: PROC [br, with: IntRel, where: IntInterval] _ NIL,
ShiftAndClipMe: PROC [br: BiRel, shift: EINT, clip: IntInterval] _ NIL,
Spaces: PROC [br: BiRel] RETURNS [SpacePair] _,
IsDense: PROC [br: BiRel, when: When, side: Side] RETURNS [BOOL] _ NIL,
SideFixed: PROC [br: BiRel, side: Side] RETURNS [BOOL] _ NIL,
functional: BoolPair _ [FALSE, FALSE],
mutability: Mutability _ variable,
other: Atom.PropList _ NIL, --the canonical expansion slot
data: REF ANY _ NIL
];

CreateClass: PROC [cp: BiRelClassPrivate, dirable: BoolPair _ [TRUE, FALSE]] RETURNS [BiRelClass];

DefaultAsSet: PROC [br: BiRel, ro: RelOrder] RETURNS [Set--of REF Pair--];
DefaultHasPair: PROC [br: BiRel, pair: Pair] RETURNS [BOOL];
DefaultImage: PROC [br: BiRel, set: Set, dir: Direction] RETURNS [Set];
DefaultApply: PROC [br: BiRel, v: Value, dir: Direction] RETURNS [MaybeValue];
DefaultScanRestriction: PROC [br: BiRel, sets: SetPair, Test: Tester, ro: RelOrder] RETURNS [MaybePair];
DefaultGetOne: PROC [br: BiRel, remove: BOOL, ro: RelOrder] RETURNS [MaybePair];
DefaultGet3: PROC [br: BiRel, pair: Pair, ro: RelOrder, want: TripleBool] RETURNS [TripleMaybePair];
DefaultIndex: PROC [br, goal: IntRel, bounds: IntInterval, bwd: BOOL] RETURNS [MaybeValue];
DefaultRestrictionSize: PROC [br: BiRel, sets: SetPair, limit: EINT] RETURNS [EINT];
DefaultGetBounds: PROC [br: BiRel, want: EndBools, ro: RelOrder] RETURNS [MaybePairInterval];
DefaultCopy: PROC [br: BiRel] RETURNS [VarBiRel];
DefaultInsulate: PROC [br: BiRel] RETURNS [UWBiRel];
DefaultValueOf: PROC [br: BiRel] RETURNS [ConstBiRel];
DefaultFreeze: PROC [br: BiRel] RETURNS [ConstBiRel];
DefaultThaw: PROC [br: BiRel];
DefaultSetOn: PROC [br: BiRel, side: Side] RETURNS [UWSet];
DefaultCurSetOn: PROC [br: BiRel, side: Side] RETURNS [ConstSet];
DefaultAddPair: PROC [br: BiRel, pair: Pair, if: IfHadPair] RETURNS [had: HadPair];
DefaultAddSet: PROC [br, other: BiRel, if: IfHadPair] RETURNS [some: HadSetPair];
DefaultSwap: PROC [br: BiRel, a, b: Value, side: Side];
DefaultRemPair: PROC [br: BiRel, pair: Pair] RETURNS [had: HadPair];
DefaultRemSet: PROC [br, other: BiRel] RETURNS [some: HadSetPair];
DefaultDelete: PROC [br: BiRel, val: Value, side: Side] RETURNS [hadSome: BOOL];
DefaultDeleteSet: PROC [br: BiRel, set: Set, side: Side] RETURNS [had: SomeAll];
DefaultReplaceMe: PROC [br, with: IntRel, where: IntInterval];
DefaultShiftAndClipMe: PROC [br: BiRel, shift: EINT, clip: IntInterval];
DefaultIsDense: PROC [br: BiRel, when: When, side: Side] RETURNS [BOOL];
DefaultSideFixed: PROC [br: BiRel, side: Side] RETURNS [BOOL];

UpdateBiRelClassOther: PROC [class: BiRelClass, Update: PROC [Atom.PropList] RETURNS [Atom.PropList]];
QualityOf: PROC [br: BiRel, op: ATOM, arg1, arg2, arg3, arg4: REF ANY _ NIL] RETURNS [ImplQuality];

RefBiRel: TYPE ~ REF BiRel;
RefSetPair: TYPE ~ REF SetPair;
refNilSets: READONLY RefSetPair;

ToSide: PROC [arg: REF ANY, default: Side _ left] RETURNS [Side];
ToDir: PROC [arg: REF ANY, default: Direction _ leftToRight] RETURNS [Direction];
ToBiRel: PROC [arg: REF ANY] RETURNS [RefBiRel];
ToSets: PROC [arg: REF ANY, default: RefSetPair _ refNilSets] RETURNS [RefSetPair];
ToRO: PROC [arg: REF ANY, default: RelOrder _ []] RETURNS [RelOrder];
FromSide: PROC [side: Side] RETURNS [ATOM]
~ INLINE {RETURN [IF side=left THEN $left ELSE $right]};
FromDir: PROC [dir: Direction] RETURNS [ATOM]
~ INLINE {RETURN [IF dir=leftToRight THEN $leftToRight ELSE $rightToLeft]};
FakeSingleton: PROC [sp: SpacePair] RETURNS [ConstBiRel]
~ INLINE {RETURN CreateSingleton[noPair, sp]};
FakeRefSingleton: PROC [sp: SpacePair] RETURNS [RefBiRel]
~ INLINE {RETURN CreateSingleton[noPair, sp].Refify};
FromSets: PROC [sp: SetPair] RETURNS [RefSetPair];
FromRO: PROC [ro: RelOrder] RETURNS [ATOM];

Can: PROC [br: BiRel, op: ATOM, arg1, arg2, arg3, arg4: REF ANY _ NIL] RETURNS [BOOL]
~ INLINE {RETURN [QualityOf[br, op, arg1, arg2, arg3, arg4]#cant]};

GoodImpl: PROC [br: BiRel, op: ATOM, arg1, arg2, arg3, arg4: REF ANY _ NIL] RETURNS [BOOL]
~ INLINE {RETURN [QualityOf[br, op, arg1, arg2, arg3, arg4]>=goodDefault]};

Complain: PROC [br: BiRel, msg: ROPE, args: LOV _ NIL]
~ INLINE {Error[msg, CONS[[a[NEW [BiRel _ br]]], args]]};

MaybeBiRel: TYPE ~ RECORD [found: BOOL, it: BiRel];
}.
ÂBiRels.Mesa
Last tweaked by Mike Spreitzer on December 14, 1987 1:04:11 pm PST
Random Old Stuff
Binary Relations (i.e., Sets of Pairs)
A binary relation (i.e., a set of Pairs), or a variable such.
Good for calling from the interpreter.
Operations on BiRels
Raised when a BiRel is asked to perform an operation it can't.
The ordering of the space of the result respects the relative order given.
For leftToRight, the result is henceforth the things that are on the right sides of pairs in br that have an element of set on their left side.  The result tracks changes to br, and changes to the result change br (in any one of the possible ways).
The image of a singleton.
The enumeration order respects the ordering specified by the ro argument relative to the BiRel's spaces.  That is, if ro says p1 < p2, then p1 is enumerated before p2; if ro says p1 = p2, they may be enumerated in either order.
Enumerates those pairs such that pair[side] is in set.
If one of the restricting sets is nilSet, that means don't restrict.
result is (if bwd then greatest else least) solution in bounds to: br[i]=v AND goal.HasMember[v]; if no such solution, result.found=FALSE and result.it is unrestricted.
Implies br.SetOn[side].IsDense, now or forever, as requested.
SideFixed[br, side] => br.SetOn[side] won't change.
May also cause deletions in order to preserve functionality.
Like AddPair, with the expectation that the pair is new.
Equivalent to a series of AddPairs. some[n][dir] iff some AddPair[..][dir]=n.
Same as AddSet[if: addIfNew], and then in functional directions d insist that some[d][same] = some[d][different] = FALSE.
side=left => br after HasPair[[a, v]] iff br before HasPair[[b, v]], and so on.
Equivalent to a bunch of RemPairs.
Remove pair(s) with equivalent values on the given side.  hadSome tells whether there were any.
Every BiRel knows its spaces.
Returns a collection of the elements on the given side of the pairs of br.  Result tracks changes to br.
Returns the current value, and thus does not track changes to br.
Functional[br][leftToRight] => br can't have two pairs with equivalent left Values and non-equivalent right Values.
A x in bounds[left], y in bounds[right] : <x,y> in a W <x,y> in b.
More Special Cases of Sets
Special Cases of BiRels
Error raised if mapping bigger than 1. Returns noMaybe if mapping empty.
new[i+shift, v] iff (old[i, v] AND i in clip AND i+shift in []).
result is (if bwd then greatest else least) solution in bounds to: Equal[Shift[br, -result.i], goal, goal.bounds] (or, equivelently, Equal[br, Shift[goal, result.i], Shift[goal.bounds, result.i]]); if no such solution, result.found=FALSE and result.val is unrestricted.
Let clip=with.GetIntDom in:
new[i, v] iff
old[i, v] & i < where.min, or
with[i-where.min+clip.min, v] & where.min <= i < where.min+clip.Length, or
old[i-clip.Length+where.Length, v] & where.min+clip.Length <= i.
Only current value of with is used.
i < j g a[p[i]] < a[p[j]].
for each [new, old] in p: to[new] _ from[old].
Some Implementations of BiRels
Like CreateSimple, but the function is initialized from the given one, subject to the given bounds.  Giving rightSpace=NIL means to use the original's.
(functional[dir] OR mappable[dir]) tells whether the result can Image in direction dir.
NIL space means use the same space as the given BiRel.  Can map in direction d iff mappable[d] OR functional[d].
The following use a standard implementation.  The result tracks changes to the arguments, if any.  Result may duplicate iff any argument may.
restricts[left]=FALSE means caller is guaranteeing that henceforth SetOn[right, left] is included in SetOn[left, right].
When side=right, c[l, {r | u[l, r]}] OR MappingSize[c, l]=0 AND MappingSize[u, l]=0.
When side=right, c is function yielding sets, and u[l, r] iff r in c[l].
result[i+shift, v] iff (br[i, v] AND i in clip AND i+shift in []).
Result has pair [i, i+shift] when i IN clip AND i+shift IN [INT.FIRST..INT.LAST].
result[i+shift, v] iff br[i, v].
ith element of result is ith element enumerated by set.
Implementing BiRels
The only part that may vary is the other, and that must be accessed through the update procedure below.
NIL procs mean the implementor declines to implement the proc; NIL fields get filled in with default procedures that compute with provided fields.  Iff Primitive is elided, `bkwdable' and `dirable' are taken into consideration when constructing Primitive.
Asking About a BiRel's Implementation
Use this to investigate what operations a BiRel supports, and how well it does so.  The quality depends on the BiRel, the operation, and certain arguments.  Those arguments are indicated to QualityOf as arg1, arg2, and so on.  An enumerated value is passed by an ATOM whose name is the name of the value; a RelOrder is passed by a coding indicated below; an other non-ref kind of value is passed as a REF to itself.  The op is the name of a procedure in this interface (other than QualityOf and derivatives) that calls class procedures.
Arguments that are passed are: Sets; BiRels; Directions; Sides; RelOrders; bwd, want*: BOOL; EndBools; Interval; limit: EINT; SetPairs; When.
Arguments not passed are: Values; Pairs; callback procedures; remove: BOOL; IntInterval; IfHadPair.
e.g.: FromRO[[[no, Bwd], left]] = $leftNoBwd
Other Random New Stuff
�Ê"h–

"cedar" style˜
code™Kš
œB™B—K˜KšÏk	œ8˜AK˜šÏnœ�œ
�˜Kš�œ)˜0Kšœ�œžœ˜<—
head™Kš�œ�œ�œ
˜K˜Kšœ�œ˜Kšœ
�œ˜$Kšœ
�œ˜*K˜Kšœ�œ˜Kšœ�œ˜!Kšœ�œ
˜K˜Kšœ�œ˜Kš
œ"˜"Kš�œ�œ�œ
�œ˜Kšœ�œ˜(Kš
œ1˜1Kšœ�œ˜4Kšœ�œ!˜8Kšœ�œ˜2Kšœ�œ˜Kšœ	�œ˜$Kšœ�œ˜*Kšœ�œ˜ Kšœ�œ˜(Kš
œ-˜-Kš
œ+˜+Kš
œ+˜+Kšœ
�œ˜&Kšœ�œ˜(Kšœ	�œ˜$Kšœ�œ˜.Kšœ
�œ˜&Kšœ�œ˜0Kš
œ(˜(Kš
œ(˜(Kš
œ*˜*Kš
œ*˜*Kšœ�œ˜(—š
œ&™&š	œ�œ�œ�œ
�œ˜8KšœÏzœŸœ1™=—K˜š
ž	œ�œ�œ
�œ�œ	˜CK™&—K˜Kšœ�œ�œ˜Kšœ
�œ˜K˜š
žœ�œ�œ
�œ�œ˜)Kšœ�œ�œ�œ�œ
�œ
�œ�œ˜G—šžœ�œ
�œ˜+Kšœ�œ�œ�œ˜%——š
œ™šžœ�œ
˜K™>—K˜šžœ�œ�œÏcœ
˜BK™JKšœ�œ�œ˜)—K˜šžœ�œ�œ�œ
˜4Kšœ�œ�œ˜-—K˜šžœ�œ5�œ˜MKš
Ͽ
™ø
Kšœ�œ�œ˜/—K˜šžœ�œ5�œ˜OKš
œ™Kšœ�œ�œM˜]—K˜š
žœ�œ�œ
�œ �œ˜RKšœ�œ�œR˜b—K˜šžœ�œ�œ �œ˜NKšœ�œ�œR˜b—K˜šž	œ�œ
žœ�œ˜EKšœ=Ïeœ7¡œ3¡œ6™ã
—K˜Kšžœ�œ
žœ�œ�œ
�œ�œ
�œ˜NKšžœ�œ
žœ�œ�œ�œ
�œ˜JKšžœ�œ
žœ�œ�œ�œ˜FK˜Kš	œ�œ�œ�œ�œ˜*Kšž	œ œ
˜%K˜šžœ�œ
žœ�œ˜KKšœ�œ�œ-˜=K˜—Kšžœ�œžœ�œ@˜xK˜šžœ�œžœ�œ?˜yKšœ�œ[˜c—K˜šžœ�œžœ�œ/˜qK™6—K˜Kšž	œ�œžœE�œ
˜ƒ
K˜šžœ�œžœE�œ˜„
Kšœ�œ�œR˜b—K˜šžœ�œ!žœ�œ˜jKšœ"¡œ™DKšœ�œ�œ/˜?—K˜šžœ�œžœ0�œ˜wKšœ�œ�œ>˜N—K˜šžœ�œžœ+�œ˜fKšœ�œ�œ8˜H—K˜Kšžœ�œžœG�œ˜Ž
K˜Kšœ�œ�œ�œ�œ�œ˜KKšœ�œ�œ	�œ˜;K˜Kšžœ�œžœL�œ
˜™
K˜Kšœ�œ�œ�œ	�œ�œ
˜XK˜šžœ�œ�œ�œ˜HKšœ�œ�œ"˜2—šžœ�œ �œ˜>Kšœ�œ�œ�œ˜1—šžœ�œ �œ˜<Kšœ�œ�œ�œ˜0—šžœ�œ
�œ˜+Kš	œ�œ�œ�œ�œ	˜9—šžœ�œ
�œ˜*Kš	œ�œ�œ�œ�œ	˜9—K˜šžœ�œ5�œ˜RKšœ�œ�œ�œ�œ�œ
˜K—šžœ�œ5�œ˜RKšœ�œ�œ�œ�œ�œ
˜K—šžœ�œL�œ˜oKšœ�œ�œ$˜4—K˜š
žœ�œG�œ�œ�œ˜tKšœK�œ6�œ™¨
Kšœ�œ�œr�œ�œ�œ˜ž
—K˜š
žœ�œI�œ�œ�œ
˜wKšœ�œ�œh˜x—K˜š
žœ�œ�œ
�œ�œ
˜=Kšœ�œ�œ,˜<—K˜šžœ�œ
�œ�œ
˜&Kšœ�œ�œ˜&—K˜š
žœ�œ(�œ
�œ�œ
˜\Kšœ�œ�œ,˜<—K˜Kš
ž	œ�œ<�œ
�œ�œ˜kK˜š
žœ�œ<�œ
�œ�œ
˜lKšœ�œ�œO˜_—K˜šžœ�œ5�œ�œ
˜UKšœ�œ�œ&˜6—K˜šžœ�œ5�œ�œ
˜PKš
œ=™=Kšœ�œ�œ#˜3Kšœ�œ
�œ q˜‹
—K˜šž	œ�œ �œ�œ
˜=K™3Kšœ�œ�œ˜/Kšœ�œ
�œ ^˜x—K˜šž	œ�œ>�œ˜hKšœ�œ�œ#˜3—K˜šžœ�œ
�œ
˜3Kšœ�œ�œ˜(—K˜šžœ�œ
�œ˜)Kšœ�œ�œ˜$—K˜šžœ�œ
�œ
˜,Kšœ�œ�œ˜(—K˜šžœ�œ
�œ
˜.Kšœ�œ�œ˜'—K˜šžœ�œ
�œ
˜-Kšœ�œ�œ˜&—K˜šžœ�œ˜Kšœ�œ˜—K˜Kšžœ�œ$�œ˜BK˜šžœ�œ4�œ˜WK™<Kšœ�œ�œ!˜1—K˜Kš
žœ�œ�œ
�œ�œ˜`Kšžœ�œ�œ	�œ
�œ�œ˜eKšžœ�œ�œ�œ˜\K˜šž
œ�œ˜)Kš
œ8™8—K˜Kšžœ�œ�œ
�œ˜1Kš
žœ�œ�œ	�œ
�œ˜6Kšžœ�œ�œ˜-K˜šžœ�œ/�œ˜UKš
œM™MKšœ�œ�œ!˜1—K˜šž	œ�œ˜#K™y—K˜šžœ�œ,˜6K™OKšœ�œ!˜)—K˜šžœ�œ�œ˜<Kšœ�œ�œ˜-—K˜Kš
žœ�œ�œ
�œ�œ˜EKšžœ�œ�œ	�œ
�œ�œ˜JKšžœ�œ�œ�œ˜AK˜šžœ�œ�œ˜:Kš
œ"™"Kšœ�œ�œ˜-—K˜šžœ�œ˜Kšœ�œ˜—K˜šžœ�œ,�œ�œ
˜OKš
œ_™_Kšœ�œ�œ!˜1—K˜šžœ�œ�œ
�œ�œ�œ
˜RKšœ�œ�œ&˜6—K˜š
žœ�œ�œ�œ�œ
˜NKšœ�œ�œ&˜6—K˜šž	œ�œ*�œ˜OKšœ�œ�œ$˜4—K˜šžœ�œ
�œ˜,K™Kšœ�œ�œ˜&—K˜šžœ�œ�œ˜3K™hKšœ�œ�œ˜-—K˜šžœ�œ�œ˜9K™AKšœ�œ�œ˜.—K˜šž
œ�œ
�œ˜/K™sKšœ�œ�œ˜(—K˜šžœ�œ%�œ�œ˜?KšÏm
œ4¢
œ™B—K˜Kšžœ�œ#�œ�œ˜@K˜Kšžœ�œ;�œ�œ˜hK˜Kšžœ�œ�œ	˜>K˜Kšž
œ�œ	�œ	�œ˜H—™šž
œ�œ�œ�œ
˜*Kšœ�œ�œ"˜2—šž
œ�œ�œ˜+Kšœ�œ�œ˜(—šžœ�œ�œ
˜1šœ�œ˜
Kšœ�œ
˜Kšœ
�œ
�œ
˜Kš
œ/˜/Kš�œ�œ�œ�œ�œ�œ�œ˜M———™Kšœ
�œ�œ	 œ
˜5šžœ�œ
�œ�œ
˜&Kšœ�œ�œ!˜1—šžœ�œ
�œ˜*Kšœ�œ�œ
�œ�œ�œ	˜i—K˜Kšœ	�œ�œ	 œ
˜7šžœ�œ
�œ�œ
˜%Kšœ�œ�œ!˜1—šžœ�œ
�œ
˜(Kšœ�œ�œ
�œ�œ�œ	˜g—K˜Kšœ�œ�œ œ
˜9šžœ�œ
�œ�œ
˜(Kšœ�œ�œ!˜1—šžœ�œ
�œ
˜.Kšœ�œ�œ
�œ�œ�œ˜k—K˜Kšœ
�œ	 =œ
˜UKšœ
�œ˜Kšœ�œ˜Kšœ�œ˜!šž
œ�œ
�œ�œ
˜+Kšœ�œ�œ%˜5—šž
œ�œ
�œ˜/Kšœ�œ�œ
�œ"�œ�œ˜^—K˜Kšœ
�œ	 >œ
˜Yšž
œ�œ
�œ�œ
˜.Kšœ�œ�œ%˜5—šž
œ�œ
�œ˜5Kšœ�œ�œ
�œ"�œ�œ˜^—K˜Kšœ
�œ	 œ
˜.Kšœ
�œ˜Kšœ�œ˜!šž
œ�œ
�œ�œ
˜+Kš	œ�œ�œ�œ
�œ˜2—šž
œ�œ
�œ˜/Kšœ�œ�œ
�œ�œ
�œ�œ�œ˜[—K˜šžœ�œ5�œ
˜TKš
œH™HKšœ�œ�œ˜-Kšœ�œ
�œ
˜#—K˜š
žœ�œ�œ
�œ �œ
˜WKšœ�œ�œ"˜2—K˜šžœ�œ�œ �œ
˜SKšœ�œ�œ"˜2—K˜Kšœ�œ	 -œ
˜Cšžœ�œ
�œ�œ
˜)Kšœ�œ�œ˜(—šžœ�œ
�œ	˜+Kšœ�œ�œ˜%—Kšž	œ�œ
�œ˜1K˜Kšž	œ�œ"�œ˜GK˜šžœ�œ�œ ˜MKšœ�œ™@Kšœ�œ,˜4—K˜š
žœ�œ3�œ�œ�œ
˜`Kšœè
�œ ™�Kšœ�œ�œ(˜8—K˜šž	œ�œ'˜6Kš
œ™K™
K™K™JK™@K™#Kšœ�œ'˜/—K˜šžœ�œ"�œ
˜2Kšœ�œU˜]—K˜šžœ�œ˜%Kšœ�œ'˜/—K˜šžœ�œ�œ
�œ
˜(Kšœ�œ,˜4—K˜šžœ�œ�œ
˜$Kšœ�œ,˜4—K˜Kšœ�œ
 #œ
˜9Kšœ�œ˜šžœ�œ
�œ�œ
˜(Kšœ�œ�œ˜'—šžœ�œ
�œ˜)Kšœ�œ�œ˜$—Kšžœ�œ
�œ˜0K˜Kšœ�œ	 œ
˜4šžœ�œ
�œ�œ
˜(Kšœ�œ�œ�œ˜:—šžœ�œ
�œ˜)Kš
œ�œ�œ
�œ�œ�œ�œ˜e—K˜Kšœ�œ,˜<šžœ�œ
�œ�œ
˜-Kš	œ�œ�œ�œ�œ˜T—šžœ�œ
�œ
˜2Kšœ�œ�œ
�œ�œ�œ˜N—K˜Kšœ
�œ	 œ
˜2šž
œ�œ
�œ�œ
˜+Kšœ�œ�œ
�œ˜8—K˜Kšœ�œ )œ
˜DKšœ
�œ œ
˜7K˜šžœ�œ �œ˜FKšœ¢
œ	¢
œ	™—šžœ�œ-˜?K™.—Kšžœ�œ˜3—™Kšžœ�œ
�œ˜8Kšžœ�œ�œ	˜+Kšž
œ�œ	�œ�œ˜(šžœ�œ�œ˜;Kšœ�œ�œ-˜=—Kšžœ�œ
�œ˜9K˜šžœ�œ �œ
˜IKšœ�œ�œ �œ˜FKšžœ�œ�œ˜A—K˜Kšžœ�œ �œ˜KK˜šžœ�œC�œ
˜kKšœ�œ�œi˜yK˜—Kšž
œ�œ�œ	˜.K˜šž
œ�˜š
œ
˜
Kš
žœ�œ�œ
�œ�œ˜?Kš
œ#˜#Kšœ�œ
�œ�œ
˜Kšœ�œ�œ
˜!Kš
žœ�œ�œ
�œžœ
�œ�˜SKš
œ
˜
—Kš�œ˜—K˜Kš
žœ�œU�œ�œ�œ	˜ 
K˜š
žœ�œO�œ�œ�œ	˜”
Kš
œ—
™—
—K˜Kšž
œ�œ�œ�œ�œn�œ�œ�œ˜Ð
K˜Kšœ�œ˜K˜šžœ�œ>�œ�œ�œ�œ�œ˜—
Kš
œW™W—šž
œ�œ&�œ˜NKš	œ�œ�œ�œ
�œ˜4—š
žœ�œ/�œ�œ�œ	˜^Kšœ�œ�œ�œ�œ�œ
˜I—š
žœ�œ!�œ�œ�œ	˜SKšœ�œ�œ!�œ�œ�œ
˜Q—šžœ�œ�œ�œ!�œ�œ�œ	˜kKšœ�œ�œ'�œ�œ�œ
˜W—šžœ�œ"�œ�œ�œ�œ�œ
˜wKš
œp™p—K˜Kš
œ�
™�
Kš
žœ�œ�œ�œ�œ˜WKšžœ�œ�œ˜4Kšž
œ�œ�œ˜2Kšžœ�œ�œ˜=Kšžœ�œ	�œ	˜%šžœ�œ!�œ�œ
�œ�œ�œ�œ	˜aKš
œx™x—Kšžœ�œ	�œ	˜%šžœ�œ �œ˜CKš
œT™T—šž	œ�œ#�œ˜EK™H—K˜Kšžœ�œ(�œ
˜FK˜šžœ�œ�œ!�œ
˜]Kšœ!�œ™B—K˜šžœ�œ	�œ!�œ˜aKš
œ$�œ�œ�œ
�œ�œ
�œ™Q—K˜šžœ�œ�œ�œ	˜6Kš
œ ™ Kšœ�œ�œ˜*—K˜šžœ�œ#�œ	˜?Kšœ�œ�œ�œ˜?—K˜šžœ�œ0�œ�œ˜`Kšœ
�œ˜"—K˜Kšžœ�œ�œ˜;K˜šžœ�œ$�œ˜IKšœ
Ïuœ£œ™7——š
œ™Kšœ�œ�œ˜)šœ�œ�	œ
�œ˜,Kšž	œ�œ�œ�œ
�œ�œ�œ�œ
˜aKš
žœ�œ�œ œ�œ
˜IKš
žœ�œ�œ�œ�œ
˜;Kšžœ�œ'�œ	�œ
˜FKšžœ�œ'�œ�œ
˜MKš
žœ�œžœ�œ�œ
˜gKš
žœ�œ�œ�œ�œ
˜OKšžœ�œ9�œ�œ
˜cKš
žœ�œ.�œ�œ�œ
˜ZKšžœ�œ#�œ�œ�œ�œ
˜SKšž	œ�œ+�œ�œ
˜\Kšžœ�œ
�œ�œ
˜0Kšžœ�œ
�œ
�œ
˜3Kšžœ�œ
�œ�œ
˜5Kšžœ�œ
�œ�œ
˜4Kšžœ�œ�œ
˜Kšžœ�œ�œ�œ
˜:Kšžœ�œ�œ�œ
˜@Kšžœ�œ(�œ�œ
˜RKšžœ�œ#�œ�œ
˜PKšžœ�œ(�œ
˜6Kšžœ�œ�œ�œ
˜CKšžœ�œ�œ�œ
˜AKš
žœ�œ%�œ�œ�œ
˜OKšž	œ�œ#�œ�œ
˜OKšž	œ�œ*�œ
˜=Kšžœ�œ�œ�œ
˜GKšžœ�œ
�œ˜/Kš
žœ�œ%�œ�œ�œ
˜GKš
ž	œ�œ�œ�œ�œ
˜=Kšœ�œ�œ˜&K˜"Kšœ�œ ˜:Kšœ�œ
�œ�˜K˜Kšœ#¡œ?™g—K˜š
žœ�œ.�œ�œ�œ˜bKš
œÿ
™ÿ
—K˜Kšžœ�œ�œ œ˜JKšžœ�œ�œ�œ˜<Kšžœ�œ'�œ˜GKšžœ�œ'�œ˜NKšžœ�œžœ�œ
˜hKšž
œ�œ�œ�œ
˜PKšžœ�œ9�œ˜dKšžœ�œ.�œ�œ˜[Kš
žœ�œ#�œ�œ�œ˜TKšžœ�œ+�œ˜]Kšžœ�œ
�œ˜1Kšžœ�œ
�œ˜4Kšžœ�œ
�œ˜6Kšž
œ�œ
�œ˜5Kšžœ�œ
˜Kšžœ�œ�œ	˜;Kšžœ�œ�œ˜AKšžœ�œ(�œ˜SKšž
œ�œ#�œ˜QKšžœ�œ&˜7Kšžœ�œ�œ˜DKšž
œ�œ�œ˜BKšž
œ�œ%�œ�œ˜PKšžœ�œ#�œ˜PKšžœ�œ(˜>Kšžœ�œ�œ˜HKšžœ�œ%�œ�œ˜HKšžœ�œ�œ�œ˜>K˜Kš
žœ�œžœ�œ�œ˜f—š
œ%™%šž	œ�œ�œ�œ
�œ�œ�œ˜cKš
œ˜™˜KšœW�œ�œ™�
Kš
œc™c—K˜Kšœ
�œ�œ˜Kšœ�œ�œ	˜Kšœ�œ˜ K˜Kš
žœ�œ�œ
�œ�œ˜AKš
žœ�œ�œ
�œ$�œ
˜QKš
žœ�œ�œ
�œ�œ˜0Kš
žœ�œ�œ
�œ$�œ˜SKš
žœ�œ�œ
�œ�œ˜Ešžœ�œ�œ�œ
˜*Kšœ�œ�œ�œ�œ�œ
˜8—šžœ�œ�œ�œ
˜-Kšœ�œ�œ�œ�œ�œ˜K—šž
œ�œ�œ
˜8Kšœ�œ�œ˜.—šžœ�œ�œ˜9Kšœ�œ�œ%˜5—Kšžœ�œ�œ˜2šžœ�œ�œ�œ˜+K™,—K˜šžœ�œ�œ�œ
�œ�œ�œ�œ
˜UKšœ�œ�œ3˜C—K˜šžœ�œ�œ�œ
�œ�œ�œ�œ
˜ZKšœ�œ�œ;˜K—K˜—™š
žœ�œ�œ�œ�œ
˜6Kšœ�œ
�œ�œ˜9—K˜Kšœ�œ�œ	�œ
˜3—L˜—…—i¤ Î