
DIRECTORY
Basics USING [ Card16FromH, Card32FromF, FFromCard32, FFromInt32, FWORD, HFromCard16, HFromInt16, HWORD, Int16FromH, Int32FromF, LongNumber, LowHalf, RawBytes ],
IO USING [ STREAM, UnsafeGetBlock, UnsafePutBlock ],
KipperSupport USING [ Kipperer, KippererBody, KipperCard16, KipperCard32, KipperRef, KipperRope, Reason, UnKipperCard16, UnKipperCard32, UnKipperRef, UnKipperRope, UnKipperer, UnKippererBody ],
RefTab USING [ Create, EqualProc, Fetch, HashProc, Insert, Ref ],
RefText USING [ ObtainScratch, ReleaseScratch ],
Rope USING [ AppendChars, Concat, FromRefText, Length, ROPE, ToRefText ];

KipperSupportImpl: CEDAR PROGRAM
IMPORTS Basics, IO, KipperSupport, RefTab, RefText, Rope
EXPORTS KipperSupport ~ {
OPEN KipperSupport;
Error: PUBLIC ERROR [ reason: Reason ] ~ CODE;
KipperKey: CARD32 ~ 4207557320B; -- 221EDED0h, 572448464
KipperKeyFSwapped: CARD32 ~ 33664021036B; -- 0DED0221Eh, -556785122
KipperVersion: TYPE ~ MACHINE DEPENDENT { unknown(0), dMachine(1), fword(2), adaptive(3) };

CreateKipperer: PUBLIC PROC [ s: IO.STREAM ] RETURNS [ k: Kipperer ] ~ {
context: Context ~ NEW[ContextObject ¬ [version: fword] ];
k ¬ NEW [KippererBody ¬ [s, 1, NIL, context]];
k.KipperCard32[KipperKey];
k.KipperCard16[KipperVersion.fword.ORD];
};

Context: TYPE ~ REF ContextObject;
ContextObject: TYPE ~ RECORD [
version: KipperVersion
];

CreateUnKipperer: PUBLIC PROC [ s: IO.STREAM ] RETURNS [ u: UnKipperer ] ~ {
key: CARD32;
version: CARD16;
context: Context ~ NEW[ContextObject ¬ [version: unknown] ];
u ¬ NEW [UnKippererBody ¬ [s, 1, NIL, context]];
key ¬ u.UnKipperCard32[];
SELECT TRUE FROM
( key = KipperKey ) => { NULL };
( key = KipperKeyFSwapped ) => { NULL };
ENDCASE => { Error[notAKipperStream] };
version ¬ u.UnKipperCard16[];
SELECT version FROM
( KipperVersion.dMachine.ORD ) => { NULL };
( KipperVersion.fword.ORD ) => { NULL };
( KipperVersion.adaptive.ORD ) => { Error[unsupportedVersion] };
ENDCASE => { Error[wrongKipperVersion] };
context.version ¬ VAL[version];
};
fzero: Basics.FWORD ~ [[0, 0], [0, 0]];

RawBytes: PROC [ local: POINTER ] RETURNS [ raw: LONG POINTER TO Basics.RawBytes ] ~
TRUSTED INLINE { raw ¬ LOOPHOLE[LONG[local], LONG POINTER TO Basics.RawBytes] };

InternalPut16: PROC [ k: Kipperer, ptr: POINTER ] ~ TRUSTED INLINE {
k.stream.UnsafePutBlock[[RawBytes[ptr], 2, 2]]; -- magic here: dorado: 0, sparc: 2!
};

InternalGet16: PROC [ u: UnKipperer, ptr: POINTER ] ~ TRUSTED INLINE {
IF ( u.stream.UnsafeGetBlock[[RawBytes[ptr], 2, 2]] # 2 ) THEN ERROR;
};

InternalPut32: PROC [ k: Kipperer, ptr: POINTER ] ~ TRUSTED INLINE {
k.stream.UnsafePutBlock[[RawBytes[ptr], 0, 4]];
};

InternalGet32: PROC [ u: UnKipperer, ptr: POINTER ] ~ TRUSTED INLINE {
context: Context ~ NARROW[u.private];
IF ( context.version = dMachine )
THEN {
dword32: Basics.LongNumber;
SwapHalves: PROC[ln: Basics.LongNumber] RETURNS[swp: Basics.LongNumber] ~ TRUSTED INLINE {
swp.hi ¬ ln.lo;
swp.lo ¬ ln.hi;
};
IF ( u.stream.UnsafeGetBlock[[RawBytes[@dword32], 0, 4]] # 4 ) THEN ERROR;
LOOPHOLE[ptr, POINTER TO Basics.LongNumber]­ ¬ SwapHalves[dword32];
}
ELSE {
IF ( u.stream.UnsafeGetBlock[[RawBytes[ptr], 0, 4]] # 4 ) THEN ERROR;
};
};

InternalPutBytes: PROC [ k: Kipperer, ptr: POINTER, bytes: CARD16 ] ~ TRUSTED INLINE {
k.stream.UnsafePutBlock[[RawBytes[ptr], 0, bytes]];
};

InternalGetBytes: PROC [ u: UnKipperer, ptr: POINTER, bytes: CARD16 ] ~ TRUSTED INLINE {
IF ( u.stream.UnsafeGetBlock[[RawBytes[ptr], 0, bytes]] # bytes ) THEN ERROR;
};

KipperBool: PUBLIC PROC [ k: Kipperer, bool: BOOL ] ~ {
k.KipperCard16[IF ( bool ) THEN 1 ELSE 0];
};

UnKipperBool: PUBLIC PROC [ u: UnKipperer ] RETURNS [ BOOL ] ~ {
RETURN [( u.UnKipperCard16[] = 1 )];
};

KipperCard16: PUBLIC PROC [ k: Kipperer, card16: CARD16 ] ~ TRUSTED {
hword: Basics.HWORD ¬ Basics.HFromCard16[card16];
InternalPut16[k, @hword];
};

UnKipperCard16: PUBLIC PROC [ u: UnKipperer ] RETURNS [ card16: CARD16 ] ~ TRUSTED {
fword: Basics.FWORD ¬ fzero; -- so we don't get trash
InternalGet16[u, @fword];
card16 ¬ Basics.Card16FromH[fword.lo];
};

KipperCard32: PUBLIC PROC [ k: Kipperer, card32: CARD32 ] ~ TRUSTED {
fword: Basics.FWORD ¬ Basics.FFromCard32[card32];
InternalPut32[k, @fword];
};

UnKipperCard32: PUBLIC PROC [u: UnKipperer] RETURNS [ card32: CARD32 ] ~ TRUSTED {
fword: Basics.FWORD;
InternalGet32[u, @fword];
card32 ¬ Basics.Card32FromF[fword];
};

KipperChar: PUBLIC PROC [ k: Kipperer, char: CHAR ] ~ {
k.KipperCard16[char.ORD];
};

UnKipperChar: PUBLIC PROC [ u: UnKipperer ] RETURNS [ char: CHAR ] ~ {
RETURN [VAL[u.UnKipperCard16[]]];
};

KipperInt16: PUBLIC PROC [ k: Kipperer, int16: INT16 ] ~ TRUSTED {
hword: Basics.HWORD ¬ Basics.HFromInt16[int16];
InternalPut16[k, @hword];
};

UnKipperInt16: PUBLIC PROC [ u: UnKipperer ] RETURNS [ int16: INT16 ] ~ TRUSTED {
fword: Basics.FWORD ¬ fzero; -- so we don't get trash
InternalGet16[u, @fword];
int16 ¬ Basics.Int16FromH[fword.lo];
};

KipperInt32: PUBLIC PROC [ k: Kipperer, int32: INT32 ] ~ TRUSTED {
fword: Basics.FWORD ¬ Basics.FFromInt32[int32];
InternalPut32[k, @fword];
};

UnKipperInt32: PUBLIC PROC [ u: UnKipperer ] RETURNS [ int32: INT32 ] ~ TRUSTED {
fword: Basics.FWORD;
InternalGet32[u, @fword];
int32 ¬ Basics.Int32FromF[fword];
};

KipperNat31: PUBLIC PROC [ k: Kipperer, nat: NAT ] ~ TRUSTED {
fword: Basics.FWORD ¬ Basics.FFromCard32[nat];
InternalPut32[k, @fword];
};

UnKipperNat31: PUBLIC PROC [ u: UnKipperer ] RETURNS [ nat: NAT ]  ~ TRUSTED {
fword: Basics.FWORD;
InternalGet32[u, @fword];
nat ¬ Basics.Card32FromF[fword];
};

FFromReal: PROC [n: REAL] RETURNS [Basics.FWORD]
= INLINE { RETURN[LOOPHOLE[n]] };
RealFromF: PROC [f: Basics.FWORD] RETURNS [REAL]
= INLINE { RETURN[LOOPHOLE[f]] };

KipperReal: PUBLIC PROC [ k: Kipperer, real: REAL ] ~ TRUSTED {
fword: Basics.FWORD ¬ --Basics.--FFromReal[real];
InternalPut32[k, @fword];
};

UnKipperReal: PUBLIC PROC [ u: UnKipperer ] RETURNS [ real: REAL ] ~ TRUSTED {
fword: Basics.FWORD;
InternalGet32[u, @fword];
real ¬ --Basics.--RealFromF[fword];
};

KipperRefText: PUBLIC PROC [ k: Kipperer, refText: REF TEXT ] ~ {
k.KipperRope[Rope.FromRefText[refText]];
};

UnKipperRefText: PUBLIC PROC [ u: UnKipperer ] RETURNS [ refText: REF TEXT ] ~ {
refText ¬  Rope.ToRefText[u.UnKipperRope[]];
};

RopeBundleSize: CARD16 ¬ 100;

KipperRope: PUBLIC PROC [ k: Kipperer, rope: Rope.ROPE ] ~ TRUSTED {
IF ( k.KipperRef[rope] ) THEN {
textBuffer: REF TEXT ¬ RefText.ObtainScratch[RopeBundleSize];
{
ENABLE { UNWIND => RefText.ReleaseScratch[textBuffer] };
position: INT ¬ 0;
remaining: INT ¬ rope.Length[];
thisBundleSize: CARD16;
thisByteCount: CARD16;
WHILE ( remaining > 0 ) DO
thisBundleSize ¬ Rope.AppendChars[textBuffer, rope, position, RopeBundleSize];
thisByteCount ¬ ( ( thisBundleSize + 1 ) / 2 ) * 2;
InternalPut16[k, @thisBundleSize];
InternalPutBytes[k, BASE[DESCRIPTOR[textBuffer­]], thisByteCount];
textBuffer.length ¬ 0;
position ¬ position + thisBundleSize;
remaining ¬ remaining - thisBundleSize;
ENDLOOP;
thisBundleSize ¬ 0;
InternalPut16[k, @thisBundleSize];
};
RefText.ReleaseScratch[textBuffer];
};
};

UnKipperRope: PUBLIC PROC [ u: UnKipperer ] RETURNS [ rope: Rope.ROPE ¬ NIL ] ~ TRUSTED {
flag: BOOL; ref: REF ANY;
[flag, ref] ¬ u.UnKipperRef[];
IF ( NOT flag )
THEN {
rope ¬ NARROW[ref];
RETURN;
}
ELSE {
textBuffer: REF TEXT ¬ RefText.ObtainScratch[RopeBundleSize];
{
ENABLE { UNWIND => RefText.ReleaseScratch[textBuffer] };
thisBundleSize: CARD16 ¬ u.UnKipperCard16[];
WHILE ( thisBundleSize > 0 ) DO
thisByteCount: CARD16 ~ ( ( thisBundleSize + 1 ) / 2 ) * 2;
InternalGetBytes[u, BASE[DESCRIPTOR[textBuffer­]], thisByteCount];
textBuffer.length ¬ thisBundleSize;
rope ¬ rope.Concat[Rope.FromRefText[textBuffer]];
thisBundleSize ¬ u.UnKipperCard16[];
ENDLOOP;
};
RefText.ReleaseScratch[textBuffer];
RecordUnKipperedRef[u, rope];
RETURN;
};
};

KipperWord: PUBLIC PROC [ k: Kipperer, word: WORD ] ~ TRUSTED {
hword: Basics.HWORD ¬ Basics.HFromCard16[word];
InternalPut16[k, @hword];
};

UnKipperWord: PUBLIC PROC [ u: UnKipperer ] RETURNS [ word: WORD ] ~ TRUSTED {
fword: Basics.FWORD ¬ fzero; -- so we don't get trash
InternalGet16[u, @fword];
word ¬ Basics.Card16FromH[fword.lo];
};
KipperRef: PUBLIC PROC [ k: Kipperer, r: REF ANY ] RETURNS [ kipperTheBody: BOOL ] ~ TRUSTED {

IF ( r = NIL )
THEN {
one: CARD16 ¬ 1;
InternalPut16[k, @one];
kipperTheBody ¬ FALSE;
RETURN;
}
ELSE {
refEncoding: CARD32 ¬ LookUpPossiblyKipperedRef[k, r, k.refCounter];
IF ( refEncoding # 0 )
THEN {
two: CARD16 ¬ 2;
InternalPut16[k, @two];
InternalPut32[k, @refEncoding];
kipperTheBody ¬ FALSE;
RETURN;
}
ELSE {
zero: CARD16 ¬ 0;
InternalPut16[k, @zero];
k.refCounter ¬ k.refCounter.SUCC;
kipperTheBody ¬ TRUE;
RETURN;
};
};
};

UnKipperRef: PUBLIC PROC [ u: UnKipperer ]
RETURNS [ kipperTheBody: BOOL, ref: REF ANY ] ~ TRUSTED {
flag: CARD16 ¬ u.UnKipperCard16[];
SELECT flag FROM
0 => { RETURN [TRUE, NIL] };
1 => { RETURN [FALSE, NIL] };
2 =>  {
code: CARD32;
InternalGet32[u, @code];
RETURN [FALSE, LookUpPreviouslyUnKipperedRef[u.refTable, code]];
};
ENDCASE => { ERROR };
};

RecordUnKipperedRef: PUBLIC PROC [ u: UnKipperer, r: REF ANY ] ~ {
IF ( u.refTable = NIL ) THEN {
u.refTable ¬ RefTab.Create[equal: EqualCode, hash: HashCode];
};
IF ( NOT u.refTable.Insert[NEW [CARD32 ¬ u.refCounter], r] ) THEN ERROR;
u.refCounter ¬ u.refCounter.SUCC;
};

LookUpPreviouslyUnKipperedRef: PROC [ t: RefTab.Ref, code: CARD32 ]
RETURNS [ ref: REF ANY ] ~ {
found: BOOL;
[found, ref] ¬ t.Fetch[NEW [CARD32 ¬ code]];
IF ( NOT found ) THEN ERROR;
RETURN;
};

LookUpPossiblyKipperedRef: PROC [ k: Kipperer, r: REF ANY, c: CARD32 ]
RETURNS [ card32: CARD32 ¬ 0 ] ~ {
IF ( k.refTable = NIL ) THEN {
k.refTable ¬ RefTab.Create[equal: EqualRef, hash: HashRef];
};
{
found: BOOL; indexRef: REF ANY;
[found, indexRef] ¬ k.refTable.Fetch[r];
IF ( found ) THEN { card32 ¬ NARROW[indexRef, REF CARD32]­; RETURN};
};
{
codedRef: REF CARD32;
codedRef ¬ NEW [CARD32 ¬ c];
IF ( NOT k.refTable.Insert[r, codedRef] ) THEN ERROR;
};
RETURN;
};

EqualRef: RefTab.EqualProc ~ CHECKED {
RETURN [( key1 = key2 )];
};

HashRef: RefTab.HashProc ~ CHECKED {
RETURN [Basics.LowHalf[LOOPHOLE[key]]];
};

EqualCode: RefTab.EqualProc ~ CHECKED {
RETURN [NARROW[key1, REF CARD32]­ = NARROW[key2, REF CARD32]­];
};

HashCode: RefTab.HashProc ~ CHECKED {
RETURN [Basics.LowHalf[NARROW[key, REF CARD32]­]];
};

}.

   F  
KipperSupportImpl.mesa December 6, 1985 9:35:33 am PST
Copyright س 1985, 1986, 1987, 1992 by Xerox Corporation.  All rights reserved.
Sturgis, January 6, 1986 1:26:43 pm PST
Bill Jackson (bj) October 19, 1988 3:32:45 pm PDT
Willie-s, April 9, 1992 10:03 am PDT
Creation procedures
RETURN [k];
RETURN [u];
Internal procedures
Client callable procedures
InternalGet16[u, @thisBundleSize]; - could be more efficient
InternalGet16[u, @thisBundleSize]; - could be more efficient
Private Procedures called by generated stubs
first a one word flag, perhaps followed by more data
0 for body follows -- this agrees with Lupine "ref=NIL", when ref is non NIL.
1 for NIL -- this agrees with Lupine "ref=NIL", when ref is NIL.
2 for encoding as INT follows, assumes same ref was seen earlier
InternalGet16[u, @flag]; - could be more efficient
‌تج  –(cedarcode) style•NewlineDelimiter
™ codeڑœ3دk™6Kڑœ
دeœC™NKڑœ$‌™'Kڑœ1™1K™$—Kک ڑ‌	ک	Kڑœ‌œ6‌œ‌œ:ک،Kڑ‌œ‌œ‌œ#ک4Kڑœ‌œ®کءKڑœ‌œ5کAKڑœ‌œ#ک0Kڑœ‌œ-‌œکIKک —ڑدnœ‌œ‌ک Kڑ‌œ	‌œ&ک8Kڑ‌œکKڑ‌œکheadڑدz™Kڑذbnœ‌œ‌œ‌œک.Kڑں	œ‌œدcک8Kڑںœ‌œ¢کCKڑœ‌œ‌œ‌	œ4ک[Kک ڑ،œ‌œ‌œ‌œ‌œ‌œکHKڑœ‌œ$ک:Kڑœ‌œ‌œک.KڑœکKڑœ#‌œک(Kڑ‌œ™Kڑœک—Kک Kڑœ	‌œ‌œک"ڑœ‌œ‌œکKڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ‌œ‌œکLKڑœ‌œکKڑœ	‌œکKڑœ‌œ&ک<Kڑœ‌œ‌œک0Kکڑ‌œ‌œ‌کKڑœ‌œک Kڑœ!‌œک(Kڑ‌œ ک'—Kکڑ‌œ	‌کKڑœ‌œ‌œک+Kڑœ‌œ‌œک(Kڑœ‌œ$ک@Kڑ‌œ"ک)—Kڑœ‌œ
کKڑ‌œ™Kڑœک——ڑ ™Kڑœ‌œک'Kک Kڑںœ‌œ
‌œ‌œ‌œ‌œ‌œ‌œ‌œ	‌œ‌œ	‌œ‌œ‌œک¥Kک ڑ
ںœ‌œ‌œ‌œ‌œکDKڑœ0¢#کSKڑœکKک —ڑ
ںœ‌œ‌œ‌œ‌œکFKڑ‌œ8‌œ‌œکEKڑœکKک —ڑ
ںœ‌œ‌œ‌œ‌œکDKڑœ/ک/KڑœکKک —ڑ
ںœ‌œ‌œ‌œ‌œکFKڑœ‌œک%ڑ‌œک!ڑ‌œکKڑœ‌œکڑ
ں
œ‌œ‌œ‌œ‌œکZKڑœکKڑœکKک—Kڑ‌œ=‌œ‌œکJKڑ‌œ‌œ‌œ‌œ#کCKڑœک—ڑ‌œکKڑ‌œ8‌œ‌œکEKڑœک——KڑœکKک —ڑںœ‌œ‌œ	‌œ‌œ‌œکVKڑœ3ک3KڑœکKک —ڑںœ‌œ‌œ	‌œ‌œ‌œکXKڑ‌œ@‌œ‌œکMKڑœکKک ——ڑ ™ڑ،
œ‌œ‌œ‌œک7Kڑœ‌œ
‌œ‌œک*KڑœکKک —ڑ
،œ‌œ‌œ‌œ‌œک@Kڑ‌œک$Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œکEKڑœ‌œک1KڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ‌œ‌œکTKڑœ‌œ
¢ک5KڑœکKک&Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œکEKڑœ‌œک1KڑœکKڑœک—Kک ڑ،œ‌œ‌œ‌œ‌œ‌œکRKڑœ‌œکKڑœکKک#Kڑœک—Kک ڑ،
œ‌œ‌œ‌œک7Kڑœ‌œکKڑœکKک —ڑ
،œ‌œ‌œ‌œ	‌œکFKڑ‌œ‌œک!Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œکBKڑœ‌œک/KڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ
‌œ‌œکQKڑœ‌œ
¢ک5KڑœکKک$Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œکBKڑœ‌œک/KڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ
‌œ‌œکQKڑœ‌œکKڑœکKک!Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œک>Kڑœ‌œک.KڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ‌œ‌œکNKڑœ‌œکKڑœکKک Kڑœک—Kک ڑ
ں	œ‌œ‌œ‌œ	‌œک0Kڑœ‌œ‌œ‌œک!—ڑ
ں	œ‌œ‌œ‌œ‌œک0Kڑœ‌œ‌œ‌œک!Kک —ڑ
،
œ‌œ‌œ‌œ‌œک?Kڑœ‌œ¢œک1KڑœکKڑœکKک —ڑ،œ‌œ‌œ‌œ	‌œ‌œکNKڑœ‌œکKڑœکKڑœ¢œک#KڑœکKک —ڑ
،œ‌œ‌œ‌œ‌œکAKڑœ(ک(Kڑœک—Kک ڑ،œ‌œ‌œ‌œ‌œ‌œکPKک,Kڑœک——ک Kڑںœ‌œکKک ڑ
،
œ‌œ‌œ‌œ‌œکDڑ‌œ‌œکKڑœ‌œ‌œ)ک=ڑœکKڑ‌œ‌œ)ک8Kڑœ
‌œکKڑœ‌œکKڑœ‌œکKڑœ‌œکڑ‌œ‌کKکNKک3Kڑœ"ک"Kڑœ‌œ‌
œکBKکKک%Kک'Kڑ‌œک—KکKڑœ"ک"Kڑœک—Kک#Kڑœک—Kڑœک—Kک ڑ،œ‌œ‌œ‌œ‌œ‌œ‌œکYKڑœ‌œ‌œ‌œکKکڑ‌œ‌œکڑ‌œکKڑœ‌œکKڑ‌œکKک—ڑ‌œکKڑœ‌œ‌œ)ک=ڑœکKڑ‌œ‌œ)ک8ڑœ‌œک,Kڑœ<™<—ڑ‌œ‌کKڑœ‌œ&ک;Kڑœ‌œ‌
œکBKک#Kک1ک$Kڑœ<™<—Kڑ‌œک—Kڑœک—Kک#KڑœکKڑ‌œکKڑœک——Kڑœک—Kک ڑ
،
œ‌œ‌œ‌œ‌œک?Kڑœ‌œک/KڑœکKڑœک—Kک ڑ،œ‌œ‌œ‌œ	‌œ‌œکNKڑœ‌œ
¢ک5KڑœکKک$Kڑœک——ڑ ,™,ڑ،	œ‌œ‌œ‌œ‌œ‌œ‌œ‌œک^™4Kڑœ¢:™MKڑœ‌œ¢6™@Kڑœ‌œ+™@—Kک ڑ‌œ‌œکڑ‌œکKڑœ‌œکKڑœکKڑœ‌œکKڑ‌œکKڑœک—ڑ‌œکKڑœ‌œ1کDڑ‌œکڑ‌œکKڑœ‌œکKڑœکKڑœکKڑœ‌œکKڑ‌œکKڑœک—ڑ‌œکKڑœ‌œکKڑœکKڑœ‌œک!Kڑœ‌œکKڑ‌œکKڑœک——Kڑœک——Kڑœک—Kک ڑ،œ‌œ‌œ‌œ‌œ‌œ‌œ‌œکdڑœ‌œک"Kڑœ2™2—ڑ‌œ‌کKڑœ‌œ‌œ‌œکKڑœ‌œ‌œ‌œکڑœکKڑœ‌œکKڑœکKڑ‌œ‌œ3ک@Kڑœک—Kڑ‌œ‌œک—Kڑœک—Kک ڑ
،œ‌œ‌œ‌œ‌œکBڑ‌œ‌œ‌œکKک=Kڑœک—Kڑ‌œ‌œ‌œ‌œ‌œ‌œکHKڑœ‌œک!Kڑœک—Kک ڑںœ‌œ‌œ‌œ‌œ‌œک`Kڑœ‌œکKڑœ‌œ‌œ
ک,Kڑ‌œ‌œ	‌œ‌œکKڑ‌œکKڑœک—Kک ڑںœ‌œ‌œ‌œ‌œ‌œ‌œ
کiڑ‌œ‌œ‌œکKک;Kک—ڑœکKڑœ‌œ‌œ‌œکKک(Kڑ‌œ‌œ‌œ‌œ‌œ‌œکDKڑœک—ڑœکKڑœ
‌œ‌œکKڑœ‌œ‌œکKڑ‌œ‌œ"‌œ‌œک5Kڑœک—Kڑ‌œکKڑœک—Kک ڑںœ‌œک&Kڑ‌œکKڑœک—Kک ڑںœ‌œک$Kڑ‌œ‌œک'Kڑœک—Kک ڑں	œ‌œک'Kڑ‌œ‌œ‌œ‌œ‌œ‌œ‌œک?Kڑœک—Kک ڑںœ‌œک%Kڑ‌œ‌œ‌œ‌œک2KڑœکKک ——KڑœکKک —— …—    (^  ;p  