DIRECTORY
BasicLoadState,
BasicLoadStateFormat,
BasicLoadStateFormatExtension,
PrincOps,
LoadState,
LoadStateFormat,
WorldVM,
WVMPrivate USING [ WorldObject ];

WVMLoadState: MONITOR
IMPORTS WorldVM
EXPORTS LoadState--opaque type--, WorldVM--opaque type--, WVMPrivate = {

Address: TYPE = WorldVM.Address;
BcdInfo: TYPE = BasicLoadStateFormat.BcdInfo;
Config: TYPE = LoadStateFormat.Config;
ConfigObject: TYPE = LoadStateFormat.ConfigObject;
ConfigID: PUBLIC TYPE = LoadStateFormat.ConfigID;
ConfigIndex: TYPE = BasicLoadStateFormat.ConfigIndex;
nullConfig: ConfigIndex = BasicLoadStateFormat.nullConfig;
ConfigTable: TYPE = LoadStateFormat.ConfigTable;
CollisionTable: TYPE = LoadStateFormat.CollisionTable;
CollisionTableIndex: TYPE = LoadStateFormat.CollisionTableIndex;
CopyTable: TYPE = LoadStateFormat.CopyTable;
Entry: TYPE = LoadStateFormat.Entry;
Extension: TYPE = BasicLoadStateFormatExtension.Extension;
ExtensionEntry: TYPE = BasicLoadStateFormatExtension.ExtensionEntry;
ModuleInfo: TYPE = BasicLoadStateFormat.ModuleInfo;
World: TYPE = REF WorldObject;

GFTIndex: TYPE = PrincOps.GFTIndex;
GFTItem: TYPE = PrincOps.GFTItem;
GFTArray: TYPE = ARRAY GFTIndex OF GFTItem;

WorldObject: PUBLIC TYPE = WVMPrivate.WorldObject;

GetLoadState: PUBLIC PROC [world: World, basic, real: Address] = {
basicWords: NAT = SIZE[BasicLoadStateFormat.LoadStateObject[0]];
realWords: NAT =
SIZE[LoadStateFormat.Object] - LoadStateFormat.htSize*SIZE[LoadStateFormat.Entry];
cheat: ARRAY [0..MAX[basicWords, realWords]) OF CARDINAL;
IF real = 0
THEN {
basicPtr: POINTER TO BasicLoadStateFormat.LoadStateObject = LOOPHOLE[@cheat];
WorldVM.CopyRead[world: world, to: @cheat, from: basic, nwords: basicWords];
IF basicPtr.versionident # BasicLoadStateFormat.versionID THEN ERROR BadLoadState;
CopyBasicLoadState[world, basic];
}
ELSE {
realPtr: POINTER TO LoadStateFormat.Object = LOOPHOLE[@cheat];
WorldVM.CopyRead[world: world, to: @cheat, from: basic, nwords: realWords];
CopyRealLoadState[world, real];
};
};

BadLoadState: ERROR = CODE;

--LoadState.--Object: PUBLIC TYPE = LoadStateFormat.Object;

CopyRealLoadState: PROC[world: World, real: Address] = {
loadState: REF Object = NEW[Object];
loadState.useCount _ 0;
loadState.changeCount _ LOOPHOLE[WorldVM.LongRead[
world: world,
addr: real + (LOOPHOLE[@loadState.changeCount,Address]-LOOPHOLE[loadState,Address])
]];
loadState.configTable _ CopyConfigTable[
world: world,
from: WorldVM.LongRead[world,
 real + (LOOPHOLE[@loadState.configTable,Address]-LOOPHOLE[loadState,Address])]
];
loadState.copyTable _ CopyCopyTable[
world: world,
from: WorldVM.LongRead[world,
 real + (LOOPHOLE[@loadState.copyTable,Address]-LOOPHOLE[loadState,Address])]
];
loadState.collisionTable _ CopyCollisionTable[
world: world,
from: WorldVM.LongRead[world,
 real + (LOOPHOLE[@loadState.collisionTable,Address]-LOOPHOLE[loadState,Address])]
];
WorldVM.CopyRead[
world: world,
from: real + (LOOPHOLE[@loadState.gfht,Address]-LOOPHOLE[loadState,Address]),
to: @loadState.gfht,
nwords: SIZE[ARRAY LoadStateFormat.HashIndex OF LoadStateFormat.Entry]
];
world.loadState _ loadState;
};

CopyConfigTable: PROC [world: World, from: Address] RETURNS [to: REF ConfigTable] = {
minSize: CARDINAL = SIZE[LoadStateFormat.ConfigTable[0]];
temp: ARRAY [0..minSize) OF WORD;
cheat: POINTER TO LoadStateFormat.ConfigTable = LOOPHOLE[@temp];
WorldVM.CopyRead[
world: world,
from: from,
to: @temp,
nwords: minSize];
to _ NEW[LoadStateFormat.ConfigTable[cheat.length]];
to.nConfigs _ cheat.nConfigs;
FOR i: NAT IN [0..to.nConfigs)
DO to[i] _ CopyConfig[
world: world,
from: WorldVM.LongRead[world,
 from + (LOOPHOLE[@to[i],Address]-LOOPHOLE[to,Address])]
];
ENDLOOP;
};

CopyCopyTable: PROC
[world: World, from: Address] RETURNS [to: REF LoadStateFormat.CopyTable] = {
minSize: CARDINAL = SIZE[LoadStateFormat.CopyTable[0]];
temp: ARRAY [0..minSize) OF WORD;
cheat: POINTER TO LoadStateFormat.CopyTable = LOOPHOLE[@temp];
WorldVM.CopyRead[
world: world,
from: from,
to: @temp,
nwords: minSize];
to _ NEW[LoadStateFormat.CopyTable[cheat.length]];
to.nCopies _ cheat.nCopies;
FOR i: NAT IN [0..to.nCopies) DO
to[i].parent _ LOOPHOLE[WorldVM.Read[world,
 from + (LOOPHOLE[@to[i].parent,Address]-LOOPHOLE[to,Address])]];
to[i].copies _ CopyCopiesList[
world: world,
from: WorldVM.LongRead[world,
 from + (LOOPHOLE[@to[i].copies,Address]-LOOPHOLE[to,Address])]
];
ENDLOOP;
};

CopyCollisionTable: PROC
[world: World, from: Address] RETURNS [to: REF LoadStateFormat.CollisionTable] = {
minSize: CARDINAL = SIZE[LoadStateFormat.CollisionTable[0]];
temp: ARRAY [0..minSize) OF WORD;
cheat: POINTER TO LoadStateFormat.CollisionTable = LOOPHOLE[@temp];
WorldVM.CopyRead[
world: world,
from: from,
to: @temp,
nwords: minSize];
to _ NEW[LoadStateFormat.CollisionTable[cheat.length]];
to.nCollisions _ cheat.nCollisions;
FOR i: NAT IN [0..to.nCollisions) DO
to[i] _ CopyCollisionList[
world: world,
from: WorldVM.LongRead[
world, from + (LOOPHOLE[@to[i],Address]-LOOPHOLE[to,Address])]
];
ENDLOOP;
};

CopyConfig: PROC
[world: World, from: Address] RETURNS [to: REF LoadStateFormat.ConfigObject] = {
minSize: CARDINAL = SIZE[LoadStateFormat.ConfigObject[0]];
temp: ARRAY [0..minSize) OF WORD;
cheat: POINTER TO LoadStateFormat.ConfigObject = LOOPHOLE[@temp];
WorldVM.CopyRead[
world: world,
from: from,
to: @temp,
nwords: minSize];
to _ NEW[LoadStateFormat.ConfigObject[cheat.length]];
to.bcd _ cheat.bcd;
to.ref _ NIL;
to.nModules _ cheat.nModules;
IF to.nModules > 0 THEN
WorldVM.CopyRead[
world: world,
from: from + (LOOPHOLE[@to[0],Address]-LOOPHOLE[to,Address]),
to: @to[0],
nwords: to.nModules * SIZE[LoadStateFormat.ModuleEntry]
];
};

CopyCopiesList: PROC
[world: World, from: Address] RETURNS [to: LIST OF PrincOps.GlobalFrameHandle _ NIL] = {
fromPos: Address _ from;
toPos: LIST OF PrincOps.GlobalFrameHandle _ NIL;
dummy: LIST OF PrincOps.GlobalFrameHandle = CONS[first: NULL, rest: NIL];
firstOffset: CARDINAL =
LOOPHOLE[@dummy.first,Address]-LOOPHOLE[dummy,Address];
restOffset: CARDINAL =
LOOPHOLE[@dummy.rest,Address]-LOOPHOLE[dummy,Address];
UNTIL fromPos = 0--NIL-- DO
this: PrincOps.GlobalFrameHandle = LOOPHOLE[WorldVM.Read[world, fromPos + firstOffset]];
new: LIST OF PrincOps.GlobalFrameHandle = CONS[first: this, rest: NIL];
IF to = NIL THEN to _ new ELSE toPos.rest _ new;
toPos _ new;
fromPos _ WorldVM.LongRead[world, fromPos + restOffset];
ENDLOOP;
};

CopyCollisionList: PROC
[world: World, from: Address] RETURNS [to: LIST OF LoadStateFormat.Entry _ NIL] = {
fromPos: Address _ from;
toPos: LIST OF LoadStateFormat.Entry _ NIL;
dummy: LIST OF LoadStateFormat.Entry = CONS[first: NULL, rest: NIL];
firstOffset: CARDINAL =
LOOPHOLE[@dummy.first,Address]-LOOPHOLE[dummy,Address];
restOffset: CARDINAL =
LOOPHOLE[@dummy.rest,Address]-LOOPHOLE[dummy,Address];
UNTIL fromPos = 0--NIL-- DO
this: LoadStateFormat.Entry;
new: LIST OF LoadStateFormat.Entry;
WorldVM.CopyRead[
world: world,
from: fromPos + firstOffset,
to: @this,
nwords: SIZE[LoadStateFormat.Entry]];
new _ CONS[first: this, rest: NIL];
IF to = NIL THEN to _ new ELSE toPos.rest _ new;
toPos _ new;
fromPos _ WorldVM.LongRead[world, fromPos + restOffset];
ENDLOOP;
};

CopyBasicLoadState: PROC [world: World, basic: Address] = {
minSize: CARDINAL = SIZE[BasicLoadStateFormat.LoadStateObject[0]];
temp: ARRAY [0..minSize) OF WORD;
cheat: POINTER TO BasicLoadStateFormat.LoadStateObject = LOOPHOLE[@temp];
nConfigs: CARDINAL _ 0;
local: LoadStateFormat.Handle _ NIL;
extension: REF Extension = NEW[Extension];
gft: REF GFTArray = NEW[GFTArray];
basicLoadState: REF BasicLoadStateFormat.LoadStateObject _ world.basicLoadState;

WorldVM.CopyRead[world: world,
to: @temp,
from: basic,
nwords: minSize];
IF basicLoadState = NIL OR cheat.length # basicLoadState.length THEN
world.basicLoadState _ basicLoadState _
NEW[BasicLoadStateFormat.LoadStateObject[cheat.length]];

WorldVM.CopyRead[world: world,
to: LOOPHOLE[basicLoadState, LONG POINTER],
from: basic,
nwords: SIZE[BasicLoadStateFormat.LoadStateObject[cheat.length]]
];

WorldVM.CopyRead[world: world,
to: LOOPHOLE[extension, LONG POINTER],
from: basic+SIZE[BasicLoadStateFormat.LoadStateObject[cheat.length]],
nwords: SIZE[Extension]
];

WorldVM.CopyRead[world: world,
to: LOOPHOLE[gft, LONG POINTER],
from: WorldVM.Long[world, LOOPHOLE[PrincOps.GFT]],
nwords: SIZE[Extension]
];

nConfigs _ basicLoadState.nBcds;
world.loadState _ local _ NEW[LoadStateFormat.Object _ [
useCount: 0,
configTable: NEW[ConfigTable[MIN[MAX[3*nConfigs/2, 2], ConfigID.LAST]]],
copyTable: NEW[CopyTable[5]],
collisionTable: NEW[CollisionTable[10]],
gfht: ALL[[empty[]]]
]];

local.configTable.nConfigs _ local.collisionTable.nCollisions _ 0;
local.copyTable.nCopies _ 1;  -- because slot 0 isn't used

FOR outerGfi: GFTIndex IN GFTIndex DO
IF gft[outerGfi].data # 0 THEN {
cfi: ConfigIndex = basicLoadState.gft[outerGfi].config;

IF cfi # nullConfig AND local.configTable[cfi] = NIL THEN {
c: Config _ NIL;
bcdInfo: BcdInfo _ basicLoadState[cfi];
nMod: NAT _ 1;
i: NAT _ 1;  -- first index is not used (inscrutable, but true)
FOR gfi: GFTIndex IN GFTIndex DO
nmodinfo: ModuleInfo = basicLoadState.gft[gfi];
IF cfi = nmodinfo.config THEN nMod _ nMod + 1;
ENDLOOP;

c _ NEW[ConfigObject[nMod]];

local.configTable[cfi] _ c;
IF cfi > local.configTable.nConfigs THEN local.configTable.nConfigs _ cfi;

bcdInfo.exports _ bcdInfo.typeExported _ FALSE;
c.bcd _ bcdInfo.bcd;
c.ref _ NIL;
c.nModules _ nMod;
FOR gfi: GFTIndex IN GFTIndex DO
modInfo: ModuleInfo = basicLoadState.gft[gfi];
IF cfi = modInfo.config THEN {
ee: ExtensionEntry = extension[gfi];
item: GFTItem _ gft[gfi];
hi: CARDINAL = item.data MOD LoadStateFormat.htSize;
entry: LoadStateFormat.Entry _ [original[
copyIndex: LoadStateFormat.nullCopyIndex,
configID: cfi,
module: modInfo.module]];
oldEntry: LoadStateFormat.Entry = local.gfht[hi];
item.epbias _ 0;  -- to make the frame pointer OK
c[i].mti _ ee.mti;
c[i].gfh _ item.framePtr;
c[i].type _ LOOPHOLE[ee.type];  -- is this really the same thing?
i _ i + 1;
WITH e: oldEntry SELECT FROM
empty => local.gfht[hi] _ entry;
collision =>
local.collisionTable.collisions[e.list] _
CONS[entry, local.collisionTable.collisions[e.list]];
ENDCASE => {
ct: REF CollisionTable _ local.collisionTable;
ci: CollisionTableIndex;
FOR ci IN [0..ct.nCollisions) DO
IF ct.collisions[ci] = NIL THEN EXIT;
REPEAT
FINISHED => {
IF ct.nCollisions = ct.length THEN {
newCT: REF CollisionTable = NEW[CollisionTable[3*ct.length/2]];
newCT.nCollisions _ ct.nCollisions;
FOR ci: CollisionTableIndex IN [0..newCT.nCollisions) DO
newCT.collisions[ci] _ ct.collisions[ci];
ENDLOOP;
local.collisionTable _ ct _ newCT;
};
ci _ ct.nCollisions;
ct.nCollisions _ ct.nCollisions.SUCC;
};
ENDLOOP;
ct.collisions[ci] _ CONS[entry, CONS[local.gfht[hi], NIL]];
local.gfht[hi] _ [collision[list: ci]];
};
};
ENDLOOP;

};
};
ENDLOOP;

{exitCrock: BOOL _ TRUE;
exitCrock _ FALSE;
};
};

}.


šWVMLoadState.mesa
Cedar Remote Debugging: cache of client pages
Andrew Birrell  December 2, 1983 3:08 pm
Russ Atkinson, May 15, 1984 5:07:14 pm PDT
Types and things
The world we are examining has no "real" load state, so check its version, then copy the basic load state.
The world we are exmining claims to have a "real" load state.
RRA: This routine was written nearly from scratch to transform a basic load state into a real live Cedar load state.  It is used whenever there is a basic load state and no real Cedar load state, which is true during the initialization of the world.  Once things start to get loaded from Basic.Loadees, the load state is just fine.
Copy the first part of the basic load state to determine the real length
Copy the basic load state, which maps
gft:     gfi -> <ConfigIndex, ModuleIndex>
bcds:   ConfigIndex -> BcdInfo
Copy the load state extension, which maps gfi -> <mti, type> 
Copy the GFT, which maps gfi -> <gfh, epi>
Allocate the load state
Now initialize the load state, using the GFT and the extension
We MAY have a new config!
We have a new config, sports fans!
Allocate the new config object
Place the config info into the config table
Initialize the new config info
Ensure no garbage in the bcd.  Unfortunately, I don't know where this info gets used in the new load state (if at all)!
Fill in the entries for multi-gfi modules
Now place the new gfh info into the hash table as well

�ʘš
œ™Jš
œ-™-Jš
œ(™(J™*—J˜š
Ïk	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ	˜	Jš
œ
˜
Jš
œ˜Jš
œ˜Jšœ�œ˜!—J˜šœ�˜Jš�œ˜Jš�œ
Ïcœ	žœ˜H—J˜š
œ™Jšœ	�œ˜ Jšœ	�œ ˜-šœ�œ˜&Jšœ�œ ˜2—Jšœ
�œ˜1šœ
�œ$˜5Jš
œ:˜:—Jšœ
�œ˜0Jšœ�œ"˜6Jšœ�œ'˜@Jšœ�œ˜,Jšœ�œ˜$Jšœ�œ+˜:Jšœ�œ0˜DJšœ�œ#˜3Jšœ�œ�œ
˜J˜Jšœ
�œ˜#Jšœ	�œ˜!Jšœ
�œ�œ
�œ	˜+J˜Jšœ
�œ
�œ˜2J˜—šÏnœ�œ
�œ)˜BJšœ�œ�œ*˜@šœ�œ˜Jš�œ2�œ˜R—Jš	œ�œ�œ�œ
�œ
˜9š�œ	˜š�œ˜Jš
œj™jJšœ
�œ
�œ(�œ	˜MJš
œL˜LJš�œ8�œ
�œ˜RJš
œ!˜!J˜
—š�œ˜Jš
œ=™=Jšœ	�œ
�œ�œ	˜>Jš
œK˜KJš
œ˜Jš
œ˜——Jš
œ˜J˜—Jšœ�œ�œ
˜J˜Jšžœ�œ
�œ˜;J˜šŸœ�œ!˜8Jšœ�œ
�œ	˜$Jš
œ˜šœ�œ˜2J˜
Jšœ�œ!�œ˜SJ˜—š
œ(˜(J˜
š
œ˜Jšœ	�œ!�œ˜O—J˜—š
œ$˜$J˜
š
œ˜Jšœ	�œ�œ˜M—J˜—š
œ.˜.J˜
š
œ˜Jšœ	�œ$�œ˜R—J˜—˜J˜
Jšœ�œ�œ˜MJš
œ˜Jšœ�œ
�œ�œ˜FJ˜—J˜Jš
œ˜—J˜šŸœ�œ�œ�œ˜UJšœ	�œ�œ!˜9Jšœ�œ�œ
�œ
˜!Jšœ�œ
�œ�œ˜@˜J˜
Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ,˜4Jš
œ˜Jš�œ�œ
�œ˜š�œ˜J˜
š
œ˜Jšœ	�œ�œ˜8—J˜—Jš�œ
˜Jš
œ˜—J˜šŸ
œ�˜Jšœ�œ�œ˜MJšœ	�œ�œ˜7Jšœ�œ�œ
�œ
˜!Jšœ�œ
�œ�œ˜>˜J˜
Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ*˜2Jš
œ˜š�œ�œ
�œ�˜ šœ�œ˜+Jšœ	�œ�œ˜A—š
œ˜J˜
š
œ˜Jšœ	�œ�œ˜?—J˜—Jš�œ
˜—Jš
œ˜—J˜šŸœ�˜Jšœ�œ�œ$˜RJšœ	�œ�œ$˜<Jšœ�œ�œ
�œ
˜!Jšœ�œ
�œ"�œ˜C˜J˜
Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ/˜7Jš
œ#˜#š�œ�œ
�œ�˜$š
œ˜J˜
š
œ˜Jšœ�œ�œ˜>——J˜—Jš�œ
˜Jš
œ˜—J˜šŸ
œ�˜Jšœ�œ�œ"˜PJšœ	�œ�œ"˜:Jšœ�œ�œ
�œ
˜!Jšœ�œ
�œ �œ˜A˜J˜
Jš
œ˜Jš
œ
˜
Jš
œ˜—Jšœ�œ-˜5Jš
œ˜Jšœ	�œ
˜
Jš
œ˜š�œ�˜˜J˜
Jšœ�œ�œ˜=Jš
œ˜Jšœ�œ˜7Jš
œ˜——Jš
œ˜—J˜šŸœ�˜Jš	œ�œ�œ
�œ�œ˜XJš
œ˜Jšœ�œ
�œ�œ
˜0Jšœ�œ
�œ�œ�œ�œ˜Išœ
�œ˜Jš�œ�œ˜7—šœ�œ˜Jš�œ�œ˜6—š�œž�˜Jšœ#�œ-˜XJš	œ�œ
�œ�œ�œ˜GJš�œ�œ
�œ
�œ˜0Jš
œ˜Jš
œ8˜8—Jš�œ
˜Jš
œ˜—J˜šŸœ�˜Jš	œ�œ�œ
�œ�œ˜SJš
œ˜Jšœ�œ
�œ�œ
˜+Jšœ�œ
�œ�œ�œ�œ˜Dšœ
�œ˜Jš�œ�œ˜7—šœ�œ˜Jš�œ�œ˜6—š�œž�˜Jš
œ˜Jšœ�œ
�œ˜#˜J˜
Jš
œ˜J˜
Jšœ�œ˜%—Jšœ�œ�œ˜#Jš�œ�œ
�œ
�œ˜0Jš
œ˜Jš
œ8˜8—Jš�œ
˜Jš
œ˜—J˜šŸœ�œ"˜;Jš
œË™ËJšœ	�œ�œ*˜BJšœ�œ�œ
�œ
˜!Jšœ�œ
�œ(�œ˜IJšœ
�œ˜Jšœ �œ
˜$Jšœ�œ
�œ˜*Jšœ�œ�œ˜"Jšœ�œ=˜PJ˜Jš
œH™H˜Jš
œ
˜
J˜Jš
œ˜—š�œ�œ
�œ&�˜Dš
œ'˜'Jš�œ5˜8——J˜š
œ%™%Jš
œ*™*Jš
œ™—˜Jšœ�œ�œ
�œ˜+J˜Jšœ�œ4˜@Jš
œ˜J˜—Jš
œ=™=˜Jšœ�œ�œ
�œ˜&Jšœ�œ5˜EJšœ�œ˜Jš
œ˜J˜—J™*˜Jšœ�œ�œ
�œ˜ Jšœ�œ
�œ˜2Jšœ�œ˜Jš
œ˜—J˜Jš
œ™Jš
œ ˜ šœ�œ˜8Jš
œ˜Jš	œ
�œ
�œ
�œ�œ˜HJšœ�œ˜Jšœ�œ˜(Jšœ�œ˜Jš
œ˜J˜—Jš
œB˜BJšœž˜:J˜Jš
œ>™>š�œ�œ
�˜%š�œ�œ˜ Jšœ�œ™Jš
œ7˜7J˜š�œ�œ�œ
�œ˜;Jš
œ"™"Jšœ�œ
˜Jš
œ'˜'Jšœ�œ˜Jšœ�œž2˜?š�œ�œ
�˜ Jš
œ/˜/Jš�œ�œ˜.Jš�œ
˜—J˜Jš
œ™Jšœ�œ˜J˜Jš
œ+™+Jš
œ˜Jš�œ"�œ"˜JJ˜Jš
œ™šœ)�œ
˜/Jš
œw™w—Jš
œ˜Jšœ�œ
˜Jš
œ˜š�œ�œ
�˜ Jš
œ)™)Jš
œ.˜.š�œ�œ˜Jš
œ$˜$Jš
œ˜Jšœ�œ
�œ˜4š
œ)˜)Jš
œ)˜)Jš
œ˜Jš
œ˜—Jš
œ1˜1Jšœž˜1J˜Jš
œ˜Jšœ�œž!˜AJ˜
Jš
œ6™6š�œ
�œ
�˜Jš
œ ˜ š
œ˜š
œ)˜)Jš�œ1˜5——š�œ˜Jšœ�œ'˜.Jš
œ˜š�œ�œ�˜ Jš�œ�œ
�œ
�œ
˜%š
�˜š�œ˜
š�œ�œ˜$Jšœ�œ�œ ˜?Jš
œ#˜#š�œ�œ�˜8Jš
œ)˜)Jš�œ
˜—Jš
œ"˜"J˜—Jš
œ˜Jšœ �œ
˜%J˜——Jš�œ
˜—Jšœ�œ�œ�œ˜;Jš
œ'˜'Jš
œ˜——J˜—Jš�œ
˜J˜—J˜—J˜—Jš�œ
˜J˜—šœ�œ�œ
˜Jšœ�œ
˜J˜—J™Jš
œ˜J˜—Jš
œ˜J˜J˜—…—*~>