DIRECTORY
CD USING [lambda, DesignNumber, DesignPosition, Level, ObjectProcs, FetchObjectProcs, ApplicationPtr, highLightError, Error],
CDObjectProcs USING [RegisterFurther, StoreFurther],
CDProperties USING [PutPropOnTechnology],
TerminalIO USING [WriteRope],
CMos USING [cmos, ndif, pdif, pol, met, met2, nwel, nwelCont, pwelCont],
Rope USING [ROPE],
SpinifexAtoms USING [ spinifex, thymePrint, rosePrint],
SpinifexCircuit USING [CellPostProcessProc, Circuit, CircuitConstraint, CircuitNode, CombineNodePropertyProc, ConstraintResolution, ConversionProc, GeometricRule, MapRec, nodeIndex, NodeLinkage, spaceIndex, SpinifexConstraintIndex, SpinifexLayerIndex, TechHandle, BoxMapProc],
SpinifexOutput USING [LinkagePrintProc],
CMosSpinifex
;
CMosSpinifexInitImpl: CEDAR PROGRAM
IMPORTS CMos, CD, CDObjectProcs, CDProperties, TerminalIO, SpinifexAtoms, CMosSpinifex
EXPORTS CMosSpinifex
~ BEGIN
OPEN CMosSpinifex;
l: CD.DesignNumber ~ CD.lambda;
excludePolByNDif: PUBLIC REF CircuitConstraint;
excludePolByPDif: PUBLIC REF CircuitConstraint;
polXorDif: PUBLIC REF CircuitConstraint;
polAndDif: PUBLIC REF CircuitConstraint;
channelEdge: PUBLIC REF CircuitConstraint;
polDifError: REF CircuitConstraint;
nDifChannel: PUBLIC REF CircuitConstraint;
nDifInWellError: REF CircuitConstraint;
excludeNDifByWell: REF CircuitConstraint;
contactNDif: REF CircuitConstraint;
excludeNDifByPWellCont: REF CircuitConstraint;
nDifAndPDifError: REF CircuitConstraint;
buriedNDifPol: PUBLIC REF CircuitConstraint;
pDifChannel: PUBLIC REF CircuitConstraint;
pDifAndNDifError: REF CircuitConstraint;
contactPDif: REF CircuitConstraint;
excludePDifByNWellCont: REF CircuitConstraint;
ConfResSetup: PROCEDURE [result, champ: REF CircuitConstraint, p1, p2, p3, p4, p5, p6: REF CircuitConstraint _ NIL] ~ {
IF p1 # NIL THEN
champ.withConstraint _ CONS[ [p1, result], champ.withConstraint];
IF p2 # NIL THEN
champ.withConstraint _ CONS[ [p2, result], champ.withConstraint];
IF p3 # NIL THEN
champ.withConstraint _ CONS[ [p3, result], champ.withConstraint];
IF p4 # NIL THEN
champ.withConstraint _ CONS[ [p4, result], champ.withConstraint];
IF p5 # NIL THEN
champ.withConstraint _ CONS[ [p5, result], champ.withConstraint];
IF p6 # NIL THEN
champ.withConstraint _ CONS[ [p6, result], champ.withConstraint];
};
InitRules: PROCEDURE [cMosHandle: REF SpinifexCircuit.TechHandle] ~ {
Rule: TYPE ~ SpinifexCircuit.GeometricRule;
TrigMap: TYPE ~ PACKED ARRAY SpinifexCircuit.SpinifexConstraintIndex OF BOOLEAN _ ALL[FALSE];
spaceRuleTrig, widthRuleTrig, polOverDifTrig1, polDifSepTrig1, polDifSepTrig2, nDifSpaceTrig1A, nDifSpaceTrig1B, nDifSpaceTrig2, pDifSpaceTrig1A, pDifSpaceTrig1B, pDifSpaceTrig2, polWidTrig, nDifSepNWellTrig1, nDifSepNWellTrig2, nDifInWellDifTrig1, nDifAndPDifTrig1, pDifAndNDifTrig1, alwaysErrorTrig2, buriedTrig, nDifChannelTrig: TrigMap;
spaceRuleTrig[SpinifexCircuit.nodeIndex] _ TRUE;
widthRuleTrig[SpinifexCircuit.spaceIndex] _ TRUE;
nDifSpaceTrig1A[SpinifexCircuit.nodeIndex] _ TRUE;
nDifSpaceTrig1A[nDifChannel.index] _ TRUE;
nDifSpaceTrig1A[contactNDif.index] _ TRUE;
nDifSpaceTrig1B[excludeNDifByPWellCont.index] _ TRUE;
nDifSpaceTrig2[SpinifexCircuit.nodeIndex] _ TRUE;
nDifSpaceTrig2[contactNDif.index] _ TRUE;
nDifSpaceTrig2[excludeNDifByPWellCont.index] _ TRUE;
buriedTrig[buriedNDifPol.index] _ TRUE;
nDifChannelTrig[nDifChannel.index] _ TRUE;
pDifSpaceTrig1A[SpinifexCircuit.nodeIndex] _ TRUE;
pDifSpaceTrig1A[pDifChannel.index] _ TRUE;
pDifSpaceTrig1A[contactPDif.index] _ TRUE;
pDifSpaceTrig1B[excludePDifByNWellCont.index] _ TRUE;
pDifSpaceTrig2[SpinifexCircuit.nodeIndex] _ TRUE;
pDifSpaceTrig2[contactPDif.index] _ TRUE;
pDifSpaceTrig2[excludePDifByNWellCont.index] _ TRUE;
nDifSepNWellTrig1[SpinifexCircuit.nodeIndex] _ TRUE;
nDifSepNWellTrig2[excludeNDifByWell.index] _ TRUE;
polWidTrig[SpinifexCircuit.spaceIndex] _ TRUE;
polWidTrig[2] _ TRUE;
polDifSepTrig1[ SpinifexCircuit.nodeIndex] _ TRUE;
polDifSepTrig2[ excludePolByNDif.index] _ TRUE;
polOverDifTrig1[ polDifError.index] _ TRUE;
nDifInWellDifTrig1[ nDifInWellError.index] _ TRUE;
nDifAndPDifTrig1[ nDifAndPDifError.index] _ TRUE;
pDifAndNDifTrig1[ pDifAndNDifError.index] _ TRUE;
alwaysErrorTrig2 _ ALL[TRUE];
cMosHandle.rules[ ndifSpinifex] _ LIST[
NEW[ Rule _ [message~"n-Diffusion spacing", extent~3*l, okIfConnected~TRUE, trigger1~nDifSpaceTrig1A, trigger2~nDifSpaceTrig2]],
NEW[ Rule _ [message~"n-Diffusion/p-substrate-contact spacing", extent~3*l, okIfConnected~TRUE, trigger1~nDifSpaceTrig1B, trigger2~nDifSpaceTrig2]],
NEW[ Rule _ [message~"n-Diffusion width", extent~2*l, trigger1~widthRuleTrig, trigger2~widthRuleTrig]],
NEW[ Rule _ [message~"n-Diffusion/n-Well spacing", extent~nDifToWell, trigger1~nDifSepNWellTrig1, trigger2~nDifSepNWellTrig2]],
NEW[ Rule _ [message~"n-Well/n-Diffusion spacing", extent~nDifToWell, trigger1~nDifSepNWellTrig2, trigger2~nDifSepNWellTrig1]],
NEW[ Rule _ [message~"n-Diffusion in n-Well", extent~l, trigger1~nDifInWellDifTrig1, trigger2~alwaysErrorTrig2]],
NEW[ Rule _ [message~"n-Diffusion and p-substrate-contact", extent~l, trigger1~nDifAndPDifTrig1, trigger2~alwaysErrorTrig2]],
NEW[ Rule _ [message~"channel/buried-contact spacing", extent~3*l, trigger1~buriedTrig, trigger2~nDifChannelTrig]],
NEW[ Rule _ [message~"buried-contact/channel spacing", extent~3*l, trigger1~nDifChannelTrig, trigger2~buriedTrig]]
];
cMosHandle.rules[ pdifSpinifex] _ LIST[
NEW[ Rule _ [message~"p-Diffusion spacing", extent~3*l, okIfConnected~TRUE, trigger1~pDifSpaceTrig1A, trigger2~pDifSpaceTrig2]],
NEW[ Rule _ [message~"p-Diffusion/n-Well-contact spacing", extent~3*l, okIfConnected~TRUE, trigger1~pDifSpaceTrig1B, trigger2~pDifSpaceTrig2]],
NEW[ Rule _ [message~"p-Diffusion width", extent~2*l, trigger1~widthRuleTrig, trigger2~widthRuleTrig]],
NEW[ Rule _ [message~"p-Diffusion and n-Well-contact", extent~l, trigger1~pDifAndNDifTrig1, trigger2~alwaysErrorTrig2]]
];
cMosHandle.rules[ polSpinifex] _ LIST[
NEW[ Rule _ [message~"Poly spacing", extent~2*l, okIfConnected~TRUE, trigger1~spaceRuleTrig, trigger2~spaceRuleTrig]],
NEW[ Rule _ [message~"Poly width", extent~2*l, trigger1~polWidTrig, trigger2~polWidTrig]],
NEW[ Rule _ [message~"Poly/Diffusion spacing", extent~l, okIfConnected~TRUE,  trigger1~polDifSepTrig1, trigger2~polDifSepTrig2]],
NEW[ Rule _ [message~"Diffusion/Poly spacing", extent~l, okIfConnected~TRUE,  trigger1~polDifSepTrig2, trigger2~polDifSepTrig1]],
NEW[ Rule _ [message~"Poly over Diffusion", extent~l, trigger1~polOverDifTrig1, trigger2~alwaysErrorTrig2]]
];
cMosHandle.rules[ metSpinifex] _ LIST[
NEW[ Rule _ [message~"Metal spacing", extent~3*l, okIfConnected~TRUE, trigger1~spaceRuleTrig, trigger2~spaceRuleTrig]],
NEW[ Rule _ [message~"Metal width", extent~3*l, trigger1~widthRuleTrig, trigger2~widthRuleTrig]]
];
cMosHandle.rules[ m2Spinifex] _ LIST[
NEW[ Rule _ [message~"Metal 2 spacing", extent~4*l, okIfConnected~TRUE, trigger1~spaceRuleTrig, trigger2~spaceRuleTrig]],
NEW[ Rule _ [message~"Metal 2 width", extent~4*l, trigger1~widthRuleTrig, trigger2~widthRuleTrig]]
];
};
Init: PROCEDURE ~ {
ObjInit: PROCEDURE [objectType: ATOM, conv: SpinifexCircuit.ConversionProc, thyme: SpinifexOutput.LinkagePrintProc _ NIL, rose: SpinifexOutput.LinkagePrintProc _ NIL] ~ {
op: REF CD.ObjectProcs;
IF (op_CD.FetchObjectProcs[ objectType~objectType, technology~CMos.cmos]) = NIL THEN ERROR;
CDObjectProcs.StoreFurther[ p~op, key~SpinifexAtoms.spinifex, value~ NEW[SpinifexCircuit.ConversionProc_conv]];
IF thyme # NIL THEN
CDObjectProcs.StoreFurther[ p~op, key~SpinifexAtoms.thymePrint, value~ NEW[SpinifexOutput.LinkagePrintProc_thyme]];
IF rose # NIL THEN
CDObjectProcs.StoreFurther[ p~op, key~SpinifexAtoms.rosePrint, value~ NEW[SpinifexOutput.LinkagePrintProc_rose]];
};
cMosHandle: REF SpinifexCircuit.TechHandle;
nDifChannel _ NEW[ CircuitConstraint _ [ $NDifChannel, 2,,,TRUE, polSpinifex]];
nDifInWellError _ NEW[ CircuitConstraint _ [ $NDifInWellError, 3]];
excludeNDifByWell _ NEW[ CircuitConstraint _ [ $ExcludeNDifByWell, 4]];
contactNDif _ NEW[ CircuitConstraint _ [ $ContactNDif, 5,,,TRUE, ndifSpinifex]];
excludeNDifByPWellCont _ NEW[ CircuitConstraint _ [ $ExcludeNDifByPWellCont, 6,,,TRUE, pdifSpinifex]];
nDifAndPDifError _ NEW[ CircuitConstraint _ [ $NDifAndPDifError, 7]];
buriedNDifPol _ NEW[ CircuitConstraint _ [ $NDifAndPDifError, 8]];
excludeNDifByPWellCont.withNode _ nDifAndPDifError.withNode _ nDifAndPDifError;
excludeNDifByWell.withNode _ nDifInWellError.withNode _ nDifInWellError;
contactNDif.withNode _ contactNDif;
ConfResSetup[ nDifAndPDifError, nDifAndPDifError,
nDifChannel, nDifInWellError, excludeNDifByWell, contactNDif, excludeNDifByPWellCont, buriedNDifPol];
ConfResSetup[ nDifAndPDifError, excludeNDifByPWellCont,
nDifChannel, nDifInWellError, contactNDif, buriedNDifPol];
excludeNDifByPWellCont.withConstraint _ CONS[ [excludeNDifByWell, excludeNDifByPWellCont], excludeNDifByPWellCont.withConstraint];
ConfResSetup[ contactNDif, contactNDif, nDifChannel,
nDifInWellError, excludeNDifByWell];
ConfResSetup[ nDifInWellError, nDifChannel,
nDifInWellError, excludeNDifByWell];
ConfResSetup[ nDifInWellError, nDifInWellError,
excludeNDifByWell, buriedNDifPol];
buriedNDifPol.withNode _ buriedNDifPol;
buriedNDifPol.withConstraint _ CONS[ [excludeNDifByWell, nDifInWellError], buriedNDifPol.withConstraint];
ConfResSetup[ buriedNDifPol, buriedNDifPol, contactNDif, nDifChannel];
pDifChannel _ NEW[ CircuitConstraint _ [ $PDifChannel, 2,,,TRUE, polSpinifex]];
contactPDif _ NEW[ CircuitConstraint _ [ $ContactPDif, 5,,,TRUE, pdifSpinifex]];
pDifAndNDifError _ NEW[ CircuitConstraint _ [ $PDifAndNDifError, 3]];
excludePDifByNWellCont _ NEW[ CircuitConstraint _ [ $ExcludePDifByNWellCont, 4,,,TRUE, ndifSpinifex]];
contactPDif.withNode _ contactPDif;
excludePDifByNWellCont.withNode _ pDifAndNDifError.withNode _ pDifAndNDifError;
pDifChannel.withConstraint _ LIST[ [contactPDif, pDifChannel]];
ConfResSetup[ pDifAndNDifError, pDifChannel, pDifAndNDifError, excludePDifByNWellCont];
ConfResSetup[ pDifAndNDifError, contactPDif, pDifAndNDifError, excludePDifByNWellCont];
ConfResSetup[ pDifAndNDifError, pDifAndNDifError, excludePDifByNWellCont];
channelEdge _ NEW[ CircuitConstraint _ [ $ChannelEdge, SpinifexCircuit.spaceIndex]];
polXorDif _ NEW[ CircuitConstraint _ [ $PolXorDif, SpinifexCircuit.spaceIndex]];
polAndDif _ NEW[ CircuitConstraint _ [ $polAndDif, SpinifexCircuit.nodeIndex]];
excludePolByNDif _ NEW[ CircuitConstraint _ [ $ExcludePolByNDif, 2,,,TRUE, ndifSpinifex]];
excludePolByPDif _ NEW[ CircuitConstraint _ [ $ExcludePolByPDif, 2,,,TRUE, pdifSpinifex]];
polDifError _ NEW[ CircuitConstraint _ [ $PolDifError, 3]];
excludePolByNDif.withNode _ channelEdge.withNode _ polDifError.withNode _ polDifError;
excludePolByPDif.withNode _ channelEdge.withNode _ polDifError.withNode _ polDifError;
ConfResSetup[ channelEdge, channelEdge,
excludePolByNDif, excludePolByPDif, polXorDif];
ConfResSetup[ polDifError, polDifError,
excludePolByNDif, excludePolByPDif, channelEdge];
ConfResSetup[ channelEdge, polXorDif,
excludePolByNDif, excludePolByPDif];
polAndDif.withNode _ polAndDif;
ConfResSetup[ polAndDif, polAndDif,
excludePolByNDif, excludePolByPDif, polXorDif, polDifError, channelEdge];
excludePolByNDif.withConstraint _ LIST[ [excludePolByPDif, excludePolByNDif]];  -- This is always an error, but the handling for it is on the pDifLayer & nDifLayer.
cMosHandle _ NEW[SpinifexCircuit.TechHandle _ [
errorLevel~CD.highLightError,
numSpinifexLayers~6,
layerInterestBloat~[nDifLayerSep, difSep, polSep, metSep, m2Sep, l,,],
CombineNodeProperties~CopyWellConnections,
CellPostProcess~CheckWellConnections]
];
cMosHandle.illegalLevel[CMos.nwelCont] _ FALSE;
cMosHandle.illegalLevel[CMos.pwelCont] _ FALSE;
cMosHandle.illegalLevel[CMos.ndif] _ FALSE;
cMosHandle.illegalLevel[CMos.pdif] _ FALSE;
cMosHandle.illegalLevel[CMos.nwel] _ FALSE;
cMosHandle.illegalLevel[CMos.pol] _ FALSE;
cMosHandle.illegalLevel[CMos.met] _ FALSE;
cMosHandle.illegalLevel[CMos.met2] _ FALSE;
cMosHandle.cdLayerMapping[CMos.nwelCont] _ LIST[ [ndifSpinifex, difSep], [wellSpinifex, l, NEW[ SpinifexCircuit.BoxMapProc _ AttachNWellContact]], [pdifSpinifex, difSep, excludePDifByNWellCont], [ndifSpinifex, difSep, contactNDif], [polSpinifex, difToPolExtSep, excludePolByNDif]]; -- Order Important for well plugging, node is created in first mapping, and used in second.
cMosHandle.cdLayerMapping[CMos.pwelCont] _ LIST[ [pdifSpinifex, difSep], [ndifSpinifex, difSep, excludeNDifByPWellCont], [pdifSpinifex, difSep, contactPDif], [polSpinifex, difToPolExtSep, excludePolByPDif]];
cMosHandle.cdLayerMapping[CMos.ndif] _ LIST[ [ndifSpinifex, difSep], [polSpinifex, difToPolExtSep, excludePolByNDif]];
cMosHandle.cdLayerMapping[CMos.pdif] _ LIST[ [pdifSpinifex, difSep], [polSpinifex, difToPolExtSep, excludePolByPDif]];
cMosHandle.cdLayerMapping[CMos.nwel] _ LIST[ [ndifSpinifex, nDifToWell-difSep, excludeNDifByWell], [wellSpinifex, l]];  -- INTERIM
cMosHandle.cdLayerMapping[CMos.pol] _ LIST[ [polSpinifex, polSep]];
cMosHandle.cdLayerMapping[CMos.met] _ LIST[ [metSpinifex, metSep]];
cMosHandle.cdLayerMapping[CMos.met2] _ LIST[ [m2Spinifex, m2Sep]];
CDProperties.PutPropOnTechnology[onto~ CMos.cmos, prop~SpinifexAtoms.spinifex, val~cMosHandle];
cMosHandle.spinifexLayerNames[ndifSpinifex].thymeName _ "nD";
cMosHandle.spinifexLayerNames[pdifSpinifex].thymeName _ "pD";
cMosHandle.spinifexLayerNames[polSpinifex].thymeName _ "P";
cMosHandle.spinifexLayerNames[metSpinifex].thymeName _ "M";
cMosHandle.spinifexLayerNames[m2Spinifex].thymeName _ "M2";
InitRules[cMosHandle];

CDObjectProcs.RegisterFurther[key~SpinifexAtoms.spinifex, technology~CMos.cmos ! CD.Error => IF ec = doubleRegistration THEN CONTINUE];
CDObjectProcs.RegisterFurther[key~SpinifexAtoms.thymePrint, technology~CMos.cmos ! CD.Error => IF ec = doubleRegistration THEN CONTINUE];
CDObjectProcs.RegisterFurther[key~SpinifexAtoms.rosePrint, technology~CMos.cmos ! CD.Error => IF ec = doubleRegistration THEN CONTINUE];
ObjInit[ objectType~$CMosTransistor, conv~ConvTransistor, thyme~ThymeTransistor, rose~RoseTransistor];
ObjInit[ objectType~$CMosPTypeTransistor, conv~ConvTransistor, thyme~ThymeTransistor, rose~RoseTransistor];
ObjInit[ objectType~$CMosATransistor, conv~ConvTransistor, thyme~ThymeTransistor, rose~RoseTransistor];
ObjInit[ objectType~$CMosPTypeATransistor, conv~ConvTransistor, thyme~ThymeTransistor, rose~RoseTransistor];
ObjInit[ objectType~$CMosPDifRect, conv~ConvertPDifRect];
InitContacts[];
ObjInit[ objectType~$CMosContactDifAndPol, conv~ConvertContact];
ObjInit[ objectType~$CMosContactWellDifAndPol, conv~ConvertContact];
ObjInit[ objectType~$CMosContactBut, conv~ConvertContact];
ObjInit[ objectType~$CMosContactWellBut, conv~ConvertContact];
ObjInit[ objectType~$CMosBurContact, conv~ConvertContact];
ObjInit[ objectType~$CMosWellBurContact, conv~ConvertContact];
ObjInit[ objectType~$CMosMmContact, conv~ConvertContact];
};
Init[];
TerminalIO.WriteRope["cMos technology parameters Loaded\n"];
END.
BCMosSpinifexInitImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Written by Shand, September 12, 1983 11:40 pm
Last Edited by: Shand, September 7, 1984 1:36:34 pm PDT
-- Constraints used in object converters.
-- Geometric rule triggers.
Corners are defined by union of dif and gate, but checking only looks at dif
Corners are defined by union of dif and gate, but checking only looks at dif
Purely local errors are not handled in a natural manner by my scheme, so for every corner we find in polDifError we generate an error if there is anything on any layer nearby, of course there is always something so we get our error.
-- The geometric rules.
-- Layer Constraints.
-- Basic cMosHandle & cdLayerMappings.
-- Thyme stray capacitance layer names.
-- The geometric rules.
-- Technology specific objects.
�Ê‰˜
code™Kšœ
Ïm
œ1™<K™-K™7—š
Ïk	˜	Kšžœ
žœu˜}Kšœžœ!˜4Kšœ
žœ˜)Kšœžœ
˜Kšœžœ>˜HKšœžœžœ˜Kšœžœ$˜7Kšœžœÿ
˜”Kšœžœ˜(Kš
œ˜K˜
—IunitšÑaoxœžœ
ž˜#KšžœžœF˜VKšžœ
˜Kšœž˜Kšžœ˜L•StartOfExpansion, -- [appl: CD.ApplicationPtr, cir: REF ] -- šÏg
œžœžœ˜™)Lšœžœ
žœ˜/Kšœžœ
žœ˜/Kšœžœ
žœ˜(Kšœžœ
žœ˜(Kšœ
žœ
žœ˜*Kšœ
žœ˜#Lšœ
žœ
žœ˜*Kšœžœ˜'Kšœžœ˜)Kšœ
žœ˜#Kšœžœ˜.Kšœžœ˜(Kšœžœ
žœ˜,Lšœ
žœ
žœ˜*Kšœžœ˜(Kšœ
žœ˜#Kšœžœ˜.—š
Ïnœž	œžœ,žœžœ˜wšžœžœ
ž˜Kšœžœ&˜A—šžœžœ
ž˜Kšœžœ&˜A—šžœžœ
ž˜Kšœžœ&˜A—šžœžœ
ž˜Kšœžœ&˜A—šžœžœ
ž˜Kšœžœ&˜A—šžœžœ
ž˜Kšœžœ&˜A—K˜—š¡	œž	œžœ ˜ELšœžœ!˜+Lšœ	žœžœ
žœ)žœ
žœžœ
žœ˜]Lš
œÔ˜Ôš
Ïl™Lšœ+žœ
˜0Kšœ,žœ
˜1š
œL™LKšœ-žœ
˜2Kšœ%žœ
˜*Kšœ%žœ
˜*Kšœ0žœ
˜5Kšœ,žœ
˜1Kšœ$žœ
˜)Kšœ/žœ
˜4Kšœ"žœ
˜'Kšœ%žœ
˜*—š
œL™LKšœ-žœ
˜2Kšœ%žœ
˜*Kšœ%žœ
˜*Kšœ0žœ
˜5Kšœ,žœ
˜1Kšœ$žœ
˜)Kšœ/žœ
˜4Lšœ/žœ
˜4Kšœ-žœ
˜2Lšœ)žœ
˜.Kšœžœ
˜Lšœ-žœ
˜2Lšœ*žœ
˜/—š
Ϗ
™è
Kšœ&žœ
˜+Kšœ-žœ
˜2Kšœ,žœ
˜1Kšœ,žœ
˜1Kšœžœ
žœ˜——š
¢™šœ"žœ
˜'K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœÏbœ 
œžœ6˜€
K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ£'œ 
œžœ6˜”
Kšžœ£œ 
œ3˜gKšžœ£œO˜Kšžœ£œO˜Kšžœ£œ
 
œ;˜qKšžœ£#œ
 
œ9˜}Kšžœ£œ 
œ2˜sKšžœ£œ 
œ1˜rKš
œ˜—šœ"žœ
˜'K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ£œ 
œžœ6˜€
K–M[key: 
REF ANY, technology: 
CD.Technology _ NIL, default: 
REF ANY _ NIL]šžœ£"œ 
œžœ6˜�
Kšžœ£œ 
œ3˜gKšžœ£œ
 
œ8˜wKš
œ˜—šœ!žœ
˜&Kšžœ£œ 
œžœ3˜vKšžœ£
œ 
œ-˜ZKšžœ£œ
 
œžœ6˜�
Kšžœ£œ
 
œžœ6˜�
Kšžœ£œ
 
œ7˜kKš
œ˜—šœ!žœ
˜&Kšžœ£
œ 
œžœ3˜wKšžœ£œ 
œ2˜`Kš
œ˜—šœ žœ
˜%Kšžœ£œ 
œžœ3˜yKšžœ£
œ 
œ2˜bKš
œ˜——K˜—š¡œž	œ˜š
¡œž	œžœQžœ*žœ˜ª
Kšœžœ
žœ
˜Lš
žœžœCžœ
žœ
žœ
˜[KšœEžœ'˜ošžœ	žœ
ž˜KšœGžœ)˜s—šžœžœ
ž˜KšœFžœ(˜q—K˜—LšÐbl
œžœ˜+š
¢™Lšœžœ*žœ˜OKšœžœ.˜CKšœžœ0˜GKšœžœ*žœ˜PKšœžœ5žœ˜fKšœžœ/˜EKšœžœ/˜BKš
œO˜OKš
œH˜HKš
œ#˜#Kš
œ—
˜—
Kš
œr˜rKšœ(žœV˜‚
Kš
œY˜YKš
œP˜PKš
œR˜RKš
œ'˜'KšœžœF˜iKš
œF˜FLšœžœ*žœ˜OKšœžœ*žœ˜PKšœžœ/˜EKšœžœ5žœ˜fKš
œ#˜#Kš
œO˜OKšœžœ˜?Kš
œW˜WKš
œW˜WKš
œJ˜JLšœžœC˜TKšœžœA˜PKšœžœ@˜OKšœžœ/žœ˜ZKšœžœ/žœ˜ZKšœžœ*˜;Kš
œV˜VKš
œV˜VKš
œW˜WKš
œY˜YKš
œJ˜JKš
œ˜Kš
œm˜mKšœ"žœ*ÏcT˜¤
—š
¢&™&Lšœ
žœ+žœg 
œX˜ý
Kšœ£œžœ
˜/Kšœ£œžœ
˜/Kšœ£œžœ
˜+Kšœ£œžœ
˜+Kšœ£œžœ
˜+Kšœ£œžœ
˜*Kšœ£œžœ
˜*Kšœ£œžœ
˜+Kš
œ£œžœ) 
œžœ¼
¥[˜õKšœ£œžœ 
˜Ï
Kšœ£œžœK˜vKšœ£œžœK˜vKš	œ£œžœG 
œ¥Ñacl˜‚
Kšœ£œžœ˜CKšœ£œžœ˜CKšœ£œžœ˜BL–<[propList: 
Atom.PropList, prop: 
REF ANY, val: 
REF ANY]š
œ_˜_—š
¢'™'Lš
œ=˜=Kš
œ=˜=Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;—š
¢™Lš
œ˜—š
¢™L˜Lš	œQžœ
žœžœ
žœ˜‡
Kš	œSžœ
žœžœ
žœ˜‰
Kš	œRžœ
žœžœ
žœ˜ˆ
Lš
œf˜fKš
œk˜kKš
œg˜gKš
œl˜lLš
œ9˜9L˜Lš
œ@˜@Kš
œD˜DKš
œ:˜:Kš
œ>˜>Kš
œ:˜:Kš
œ>˜>Kš
œ9˜9—K˜—L˜K˜<Kšžœ
˜—…—:jJ5