
<<IFUSrcLSForm.mesa >>
    <<Copyright c 1986 by Xerox Corporation.  All rights reserved.>>
    <<Curry, October 21, 1986 9:18:43 pm PDT>>
    <<Don Curry October 25, 1986 2:00:33 pm PDT>>
<<>>
DIRECTORY Core, CoreFrame, CoreName, CoreXform, DragOpsCross, IFUSrc, IFUCoreData;

IFUSrcLSForm: CEDAR PROGRAM    
IMPORTS CoreFrame, CoreName, IFUCoreData, IFUSrc
EXPORTS IFUSrc =
BEGIN

ROPE:        TYPE = Core.ROPE;

GND:        ROPE = CoreName.RopeNm["GND"];
VDD:        ROPE = CoreName.RopeNm["VDD"];
xBus:        ROPE = CoreName.RopeNm["XBus."];
zero:            ROPE = "GND";
version:        ROPE = "(GND, GND, GND, GND, GND, GND, GND, VDD )";
lSum17:     ROPE = "(NIL        LSum.1  LSum.2  LSum.3  LSum.4  LSum.5  LSum.6  LSum.7)";
lSum17in: ROPE = "(GND    LSum.1  LSum.2  LSum.3  LSum.4  LSum.5  LSum.6  LSum.7)";
sSum17:    ROPE = "(NIL        SSum.1  SSum.2  SSum.3  SSum.4  SSum.5  SSum.6  SSum.7)";
sSum17in: ROPE = "(GND    SSum.1  SSum.2  SSum.3  SSum.4  SSum.5  SSum.6  SSum.7)";
cSum17: ROPE = "
(GND  CSum.1  CSum.2  CSum.3  CSum.4  CSum.5  CSum.6  CSum.7)";
cOffset:    ROPE = "(
NotCRegOffBA.0 NotCRegOffBA.0    NotCRegOffBA.0    NotCRegOffBA.0
NotCRegOffBA.0 NotCRegOffBA.0     CRegOffBA.1     CRegOffBA.2 )";
cBase:        REF = IFUSrc.ProcRegToList[euConstant];
aBase:        REF = IFUSrc.ProcRegToList[euAux];
noStore:    REF = IFUSrc.ProcRegToList[euJunk];

userTrapsDisRec:    DragOpsCross.StackedStatusWord _ [userMode: TRUE, trapsEnabled: FALSE];
userTrapsDisCard:    LONG CARDINAL _ LOOPHOLE[userTrapsDisRec];
flagBubbleByte:        CARDINAL _ userTrapsDisCard MOD 256;    -- (record words swapped)
flagBubble:            REF = IFUSrc.CardToList[flagBubbleByte, 8];

one: ROPE = "
(GND  GND  GND  GND  GND  GND  GND  VDD)";
op47: ROPE = "
(GND  GND  GND  GND  OpBA.4  OpBA.5  OpBA.6  OpBA.7)";
s2AB: ROPE = "
(S2AB.0 S2AB.1 S2AB.2 S2AB.3 S2AB.4 S2AB.5 S2AB.6 S2AB.7)";
alpha: ROPE = "AlphaBA.";
alpha47: ROPE = "
(GND  GND  GND  GND  AlphaBA.4  AlphaBA.5  AlphaBA.6  AlphaBA.7)";
beta: ROPE = "BetaBA.";
beta47: ROPE = "
(GND  GND  GND  GND  BetaBA.4  BetaBA.5  BetaBA.6  BetaBA.7)";
beta03: ROPE = "
(GND  GND  GND  GND  BetaBA.0  BetaBA.1  BetaBA.2  BetaBA.3)";
op47AlBeBA: LIST OF REF = LIST[op47, NIL, alpha, beta ];

StatStackRdPreChargeTop:        LIST OF REF = LIST -- Op03 dropped here
[xBus, op47AlBeBA, NIL, "StatStackWtDataA.", "NotStatStackRdDataA." ];

StatStackRdPreCharge:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "StatStackRdPreCharge",
type:        "DpPreChg",
top:        StatStackRdPreChargeTop,
left:         "(    NotPhB    )",
out:        "( NotStatStackRdDataA. )",
bot:        StatStackRdPreChargeTop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackRdInv:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "StatStackRdInv",
type:        "DpInv",
top:        StatStackRdPreChargeTop,
in:            "( NotStatStackRdDataA. )",
out:        "( StatStackRdDataA. )",
bot:        StatStackRdMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackRdMuxTop:        LIST OF REF = LIST
[xBus, op47AlBeBA, "StatStackRdDataA.", "StatStackWtDataA."];

StatStackRdMux:                PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "StatStackRdMux",
top:        StatStackRdMuxTop,
left:         "(    Push3BA                NotPush3BA    )",
in:            "(     StatStackWtDataA.    StatStackRdDataA. )",
out:        "(    SelStatStackRdDataA.    )",
bot:        StatStackRdLatchATop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackRdLatchATop:        LIST OF REF = LIST
[xBus, op47AlBeBA, NIL, "StatStackWtDataA.", NIL, "SelStatStackRdDataA." ];

StatStackRdLatchA:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "StatStackRdLatchA",
type:        "DpLatch",
top:        StatStackRdLatchATop,
left:         "(    PhA VBB            )",
in:            "(    SelStatStackRdDataA.    )",
out:        "(( VStkTopAB. FlagsStkTopAB. SStkTopAB. LStkTopAB. ))",
bot:        StatStackXBusDrTop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackXBusDrTop:        LIST OF REF = LIST [
xBus,
op47AlBeBA,
NIL,
"StatStackWtDataA.",
NIL,
"( VStkTopAB. FlagsStkTopAB. SStkTopAB. LStkTopAB. )" ];

StatStackXBusDr:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "StatStackXBusDr",
type:        "DpTriDr",
top:        StatStackXBusDrTop,
right:        "(    X1ASrcStackLAc NotX1ASrcStackLAc    )",        -- from InstrDecode
in:            "(( VStkTopAB. FlagsStkTopAB. SStkTopAB. LStkTopAB. ))",
out:        "(    XBus.    )",
bot:        StatStackWtBufTop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackWtBufTop:        LIST OF REF = LIST [
xBus,
op47AlBeBA,
NIL,
"StatStackWtDataA.",
NIL,
"( NIL FlagsStkTopAB. NIL LStkTopAB. )" ];

StatStackWtBuf:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "StatStackWtBuf",
type:        "DpBuf",
top:        StatStackWtBufTop,
in:            "(    PreStatStackWtDataA.    )",
out:        "(    StatStackWtDataA.        )",
bot:        StatStackWtMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

StatStackWtMuxTop:        LIST OF REF = LIST [
xBus,
op47AlBeBA,
"PreStatStackWtDataA.",
NIL,
NIL,
"( NIL FlagsStkTopAB. NIL LStkTopAB. )" ];

StatStackWtMux:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "StatStackWtMux",
top:        StatStackWtMuxTop,
right:     "(    X1ADstStackBA        NotX1ADstStackBA    GND)",
in:            LIST[
xBus,
<<LIST[ version, "Flags3BA.", "S3BA.", "L3BA."] ],    -- wb easy to stack S here>>
LIST[ version, "Flags3BA.", GND, "L3BA."],
NIL ],
out:        "(    PreStatStackWtDataA.    )",
bot:        LSMuxSwitchingTop,
xform:        IFUCoreData.Interleaved48 ]};

LSMuxSwitchingTop:        LIST OF REF = LIST [
xBus,
op47AlBeBA,
NIL,
NIL,
LIST[ version,    "Flags3BA.",            "S3BA.",        "L3BA."],
LIST[ NIL,        "FlagsStkTopAB.",    NIL,            "LStkTopAB." ] ];

LSMuxSwitching:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "LSMuxSwitching",
top:        LSMuxSwitchingTop,
left:        NIL,
right:        "( PopSaBA NotCRegOffBA.0 CRegOffBA.1 CRegOffBA.2 )",
bot:        LSCDRtArgFormMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCDRtArgFormMuxTop:            LIST OF REF = LIST [
xBus,
op47AlBeBA,
LIST[    "AlphaBA.",        "AlphaBA.",    "S3BA.",    "Flags3BA."            ],
LIST[    "LStkTopAB.",    "SDeltaB.",    NIL,        "FlagsStkTopAB."    ],
LIST[    NIL,                NIL,            op47,        "SDeltaB."             ],
LIST[    NIL,                NIL,            "L3BA.",    "PopSaBA"            ],
GND,
VDD,
LIST[    NIL,                NIL,            beta,        NIL        ],
LIST[    NIL,                NIL,            beta03,    NIL        ],
LIST[    NIL,                NIL,            cOffset,    NIL        ]    ];

LSCDRtArgFormMux:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "LSCDRtArgFormMux",
top:        LSCDRtArgFormMuxTop,
right:        "(
LSourceRtZeroBA    LSourceRtAlphaBA    LSourceRtStackBA    LSourceRtOneBA
SSourceRtDeltaSBA    SSourceRtAlphaBA    SSourceRtZeroBA    SSourceRtOneBA
CRegRtOp47BA        CRegRtAlphaBA                                CRegRtAlpha47BA
CRegRtOffsetBA        CRegRtBetaBA        CRegRtBeta03BA        CRegRtBeta47BA    )",
in:     LIST[
LIST[    zero,                NIL,            NIL,            NIL    ],
LIST[    alpha,                NIL,            NIL,            NIL    ],
LIST[    "LStkTopAB.",    NIL,            NIL,            NIL    ],
LIST[    one,                NIL,            NIL,            NIL    ],
LIST[    NIL,                "SDeltaB.",    NIL,            NIL    ],
LIST[    NIL,                alpha,            NIL,            NIL    ],
LIST[    NIL,                zero,            NIL,            NIL    ],
LIST[    NIL,                one,            NIL,            NIL    ],
LIST[    NIL,                NIL,            op47,            NIL    ],
LIST[    NIL,                NIL,            alpha,            NIL    ],
LIST[    NIL,                NIL,            alpha47,        NIL    ],
LIST[    NIL,                NIL,            cOffset,        NIL    ],
LIST[    NIL,                NIL,            beta,            NIL    ],
LIST[    NIL,                NIL,            beta03,        NIL    ],
LIST[    NIL,                NIL,            beta47,        NIL    ] ],
out:        "( ( LSumRt.        SSumRt.        CRt.            NIL ) )",
bot:        LSCDAdderTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCDAdderTop:            LIST OF REF = LIST[
xBus,
op47AlBeBA,
"(    NIL            NIL            S3BA.        Flags3BA.        )",
"(    NIL            NIL            CRt.        FlagsStkTopAB.    )",
"(    NIL            NIL            NIL        SDeltaB.            )",
"(    LSumRt.        SSumRt.        L3BA.        PopSaBA        )"    ];

LSCDAdder:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Adder",
name:        "LSCDAdder",
top:        LSCDAdderTop,
right:        "(    GND GND GND PushScBA    )",    -- automatically becomes NotPushScBA
in:            "(    
(            LSumRt.    SSumRt.        CRt.        PopSaBA    )
(            LSumLt.    SSumLt.        CLt.        PopSbBA    )     )",    -- no dot expansion.
out:    LIST[ LIST[    lSum17,    sSum17,        "CSum.",        "SDeltaB."    ] ],
bot:        LSCDLtArgFormTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCDLtArgFormTop:            LIST OF REF = LIST[
xBus,
op47AlBeBA,
"(        NIL            NIL            S3BA.        Flags3BA.        )",
"(        NIL            NIL            CLt.        FlagsStkTopAB.    )",
LIST[    lSum17,        sSum17,        "CSum.",    NIL                ],
"(        LSumLt.        SSumLt.        L3BA.        PopSbBA            )"    ];

LSCDLtArgForm: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "LSCDLtArgForm",
top:        LSCDLtArgFormTop,
right:        "(
LSourceLtLBA        LSourceLtSBA        LSourceLtZeroBA    LSourceLtL3BA
SSourceLtSBA        SSourceLtLBA        SSourceLtS2BA        SSourceLtS3BA
CRegLtCBaseBA     CRegLtABaseBA    CRegLtSBA    CRegLtLBA    CRegLtZeroBA
GND )",
in:     LIST[
"(        LAB.        NIL        NIL        NIL    )",
"(        SAB.        NIL        NIL        NIL    )",
LIST[    zero,        NIL,        NIL,        NIL    ],
"(        L3AB.        NIL        NIL        NIL    )",
"(        NIL        SAB.        NIL        NIL    )",
"(        NIL        LAB.        NIL        NIL    )",
"(        NIL        S2AB.        NIL        NIL    )",
"(        NIL        S3AB.        NIL        NIL    )",
LIST[    NIL,        NIL,        cBase,        NIL    ],
LIST[    NIL,        NIL,        aBase,        NIL    ],
"(        NIL        NIL        SAB.        NIL    )",
"(        NIL        NIL        LAB.        NIL    )",
LIST[    NIL,        NIL,        zero,        NIL    ],
NIL ],
out:    "( ( LSumLt.    SSumLt.    CLt.        NIL    ) )",
bot:        LSCrossConnLSTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCrossConnLSTop:            LIST OF REF = LIST[
xBus,
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            S3BA.        Flags3BA.        )",
"(        L3AB.            S3AB.            NIL        FlagsStkTopAB.    )",
LIST[    lSum17,        sSum17,        "CSum.",    NIL                ],
"(        NIL            NIL            L3BA.        PopSbBA            )",
GND, VDD,
"(        SAB.            LAB.            LAB.        NIL            )",
"(        NIL            NIL            SAB.        NIL            )" ];

LSCrossConnLS:        PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "LSCrossConnLS",
top:        LSCrossConnLSTop,
left:        NIL,
right:        "( PopSbBA )",
bot:        ChopCMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

ChopCMuxTop:            LIST OF REF = LIST[
xBus,
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.        )",
"(        L3AB.            S3AB.            NIL        FlagsStkTopAB.    )",
LIST[    lSum17,        sSum17,        "CSum.",    NIL                ],
"(        L3BA.            S3BA.            NIL        NIL                )" ];

ChopCMux: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "ChopCMux",
top:        ChopCMuxTop,
right:        "(    CRegModFullBA CRegModHalfBA )",
in:     LIST[
LIST[    NIL,    NIL,    "CSum.",    NIL    ],
LIST[    NIL,    NIL,    cSum17,    NIL    ] ],
out:        "( (    NIL    NIL    CSumx.    NIL    ) )",
bot:        FlagMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

FlagMuxTop:            LIST OF REF = LIST[
xBus,
LIST[    op47,            s2AB,            alpha,        beta                ],
"(        LAB.            SAB.            NIL        Flags3BA.        )",
"(        L3AB.            S3AB.            CSumx.    FlagsStkTopAB.    )",
LIST[    lSum17,        sSum17,        NIL,        NIL                ],
"(        L3BA.            S3BA.            NIL        NIL                )" ];

FlagMux: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "FlagMux",
top:        FlagMuxTop,
right:        "(    FlagSrcLev3BA FlagSrcSameBA FlagSrcClearBA FlagSrcStackBA )",
in:     "(
( NIL NIL NIL    Flag3AB.         ),
( NIL NIL NIL    FlagAB             ),
( NIL NIL NIL    GND                ),
( NIL NIL NIL    FlagsStkTopAB.    ) )",
out: "( (    NIL    NIL    NIL    FlagB.    ) )",
bot:        LSLatchBTop,
xform:        IFUCoreData.Interleaved48 ]};

LSLatchBTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            CSumx.    Flag3AB.        )",
LIST[    lSum17,        sSum17,        NIL,        "FlagB."    ],
"(        L3BA.            S3BA.            NIL        FlagAB.        )" ];

LSLatchB:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSLatchB",
type:         "DpLatch",
top:        LSLatchBTop,
left:        "(    PhB VBB    )",
in:            LIST[LIST[    lSum17in,    sSum17in,    NIL,    "FlagB."        ]],
out:        LIST[LIST[    "LBA.",        "SBA.",        NIL,    "FlagBA."    ]],
bot:        LSLatchATop,
xform:        IFUCoreData.Interleaved48 ]};

LSLatchATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            CSumx.    Flag3AB.        )",
"(        LBA.            SBA.            NIL        FlagBA.        )",
"(        L3BA.            S3BA.            NIL        FlagAB.        )" ];

LSLatchA:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSLatchA",
type:         "DpLatch",
top:        LSLatchATop,
left:        "(    PhA VBB    )",
in:            "((    LBA.    SBA.    NIL    FlagBA.        ))",
out:        "((    LAB.    SAB.    NIL    FlagAB.        ))",
bot:        LSCLatch0BTop,
xform:        IFUCoreData.Interleaved48 ]};

SwitchABFlag:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "SwitchABFlag",
top:        LSCLatch0BTop,
right:        "( FlagAB.6 )",    -- UserMode2BA to right pads
bot:        LSCLatch0BTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch0BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            CSumx.    Flag3AB.        )",
"(        NIL            NIL            NIL        NIL        )",
"(        L3BA.            S3BA.            NIL        FlagAB.        )" ];
 
LSCLatch0B:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch0B",
type:         "DpLatch",
top:        LSCLatch0BTop,
left:        "(    PhB VBB    )",
in:            "(    (    LAB.    SAB.    CSumx.    FlagAB.        ))",
out:        "(    (    L0BA.    S0BA.    C0BA.        Flag0BA.        ))",
bot:        LSCLatch1ATop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch1ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            NIL        Flag3AB.        )",
"(        L0BA.            S0BA.            C0BA.        Flag0BA.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch1A:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch1A",
type:         "DpLatch",
top:        LSCLatch1ATop,
left:        "(    LoadStage1Ac VBB    )",
in:            "(    (    L0BA.    S0BA.    C0BA.    Flag0BA.        ))",
out:        "(    (    L1AB.    S1AB.    C1AB.    Flag1AB.        ))",
bot:        LSCLatch1BTop,
xform:        IFUCoreData.Interleaved48 ]};

DebugLSCF: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "DebugLSCF",
type:         "DpDebugDr",
top:        LSCLatch1BTop,
right:        "(    DebugLSCF    )",
in:            "(    ( LAB. SAB. C1AB. Flag1AB. ) )",
out:        "(    XBus.            )",
bot:        LSCLatch1BTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch1BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            NIL        Flag3AB.        )",
"(        L1AB.            S1AB.            C1AB.        Flag1AB.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch1B:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch1B",
type:         "DpLatch",
top:        LSCLatch1BTop,
left:        "(    LoadStage1Bc VBB    )",
in:            "(    (    L1AB.    S1AB.    C1AB.    Flag1AB.        ))",
out:        "(    (    L1BA.    S1BA.    C1BA.    Flag1BA.        ))",
bot:        CMux2ATop,
xform:        IFUCoreData.Interleaved48 ]};

CMux2ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            NIL        Flag3AB.        )",
"(        L1BA.            S1BA.            NIL        NIL            )",
"(        L3BA.            S3BA.            C1BA.        Flag1BA.        )" ];

CMux2A: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux2A",
top:        CMux2ATop,
left:        "(    Stage2ANormalBA Stage2ABubbleBA GND)",
in:     LIST[
LIST[            NIL,    NIL,    "C1BA.",    "Flag1BA."    ],
LIST[            NIL,    NIL,    noStore,    flagBubble    ],
NIL ],
out:        "( (    NIL    NIL    C2A.        Flag2A.        ) )",
bot:        LSCLatch2ATop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch2ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            NIL        Flag3AB.        )",
"(        L1BA.            S1BA.            C2A.        Flag2A.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch2A:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch2A",
type:         "DpLatch",
top:        LSCLatch2ATop,
left:        "(    LoadStage2Ac VBB    )",
in:            "(    (    L1BA.    S1BA.    C2A.    Flag2A.        ))",
out:        "(    (    L2AB.    S2AB.    C2AB.    Flag2AB.        ))",
bot:        CMux2BTop,
xform:        IFUCoreData.Interleaved48 ]};

CMux2BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        L2AB.            S2AB.            NIL        Flag2AB.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

CMux2B: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux2B",
top:        CMux2BTop,
left:        "(    Stage2BNormalAB Stage2BAbortAB GND )",
in:     LIST[
LIST[            NIL,    NIL,    "C2AB.",    NIL    ],
LIST[            NIL,    NIL,    noStore,    NIL    ],
NIL ],
out:        "( (    NIL    NIL    C2B.    NIL    ) )",
bot:        LSCLatch2BTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch2BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            s2AB,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        L2AB.            S2AB.            C2B.        Flag2AB.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch2B:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch2B",
type:         "DpLatch",
top:        LSCLatch2BTop,
left:        "(    PhB VBB    )",
in:            "(    (    L2AB.    S2AB.    C2B.    Flag2AB.        ))",
out:        "(    (    L2BA.    S2BA.    C2BA.    Flag2BA.        ))",
bot:        CMux3ATop,
xform:        IFUCoreData.Interleaved48 ]};

Switch2BAFlags:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "Switch2BAFlags",
top:        CMux3ATop,
left:        "( Flag2BA.7 )",    -- TrapsEnabled2BA to left control
right:        "( Flag2BA.6 )",    -- UserMode2BA to right pads
bot:        CMux3ATop,
xform:        IFUCoreData.Interleaved48 ]};

CMux3ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            NIL,            alpha,        beta            ],
"(        LAB.            SAB.            C2BA.        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        L2BA.            S2BA.            NIL        Flag2BA.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

CMux3A: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux3A",
top:        CMux3ATop,
left:        "(    Stage3ANormalBA Stage3AAbortBA )",
in:     LIST[
LIST[            NIL,    NIL,    "C2BA.",    NIL    ],
LIST[            NIL,    NIL,    noStore,    NIL    ] ],
out:        "( (    NIL    NIL        C3A.        NIL    ) )",
bot:        LSCLatch3ATop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch3ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            NIL,            alpha,        beta            ],
"(        LAB.            SAB.            NIL        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        L2BA.            S2BA.            C3A.        Flag2BA.        )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch3A:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch3A",
type:         "DpLatch",
top:        LSCLatch3ATop,
left:        "(    LoadStage3Ac VBB    )",
in:            "(    (    L2BA.    S2BA.    C3A.    Flag2BA.        ))",
out:        "(    (    L3AB.    S3AB.    C3AB.    Flag3AB.        ))",
bot:        CMux3BTop,
xform:        IFUCoreData.Interleaved48 ]};

CMux3BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            NIL,            alpha,        beta            ],
"(        LAB.            SAB.            C3AB.        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        NIL            NIL            NIL        NIL            )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

CMux3B: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux3B",
top:        CMux3BTop,
left:        "(    Stage3BCPipeNormalAB Stage3BCPipeAbortAB GND )",
in:     LIST[
LIST[            NIL,    NIL,    "C3AB.",    NIL    ],
LIST[            NIL,    NIL,    noStore,    NIL    ],
NIL ],
out:        "( (    NIL    NIL    C3B.        NIL    ) )",
bot:        LSCLatch3BTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch3BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            NIL,            alpha,        beta            ],
"(        LAB.            SAB.            C3AB.        Flags3BA.    )",
"(        L3AB.            S3AB.            C2AB.        Flag3AB.        )",
"(        NIL            NIL            C3B.        NIL            )",
"(        L3BA.            S3BA.            NIL        NIL            )" ];

LSCLatch3B:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch3B",
type:         "DpLatch",
top:        LSCLatch3BTop,
left:        "(    PhB VBB    )",
in:            "(    (    L3AB.    S3AB.    C3B.    Flag3AB.        ))",
out:        "(    (    L3BA.    S3BA.    C3BA.    Flags3BA.        ))",
bot:        LSCBot,
xform:        IFUCoreData.Interleaved48 ]};

LSCBot:            LIST OF REF = LIST[
xBus,    
LIST[    op47,            NIL,            alpha,        beta    ],
"(        LAB.            SAB.            C3AB.        NIL    )",
"(        NIL            NIL            C2AB.        NIL    )",
"(        NIL            NIL            C3BA.        NIL    )" ];


LSForm: PUBLIC PROC RETURNS[cellType: Core.CellType] = {
name:    ROPE _ CoreName.RopeNm["IFULSForm"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[
name:        name,
rec:        [first: top],
cells: LIST[
StatStackRdPreCharge[],
StatStackRdInv[],
StatStackRdMux[],
StatStackRdLatchA[],
StatStackXBusDr[],
StatStackWtBuf[],
StatStackWtMux[],
LSMuxSwitching[],
LSCDRtArgFormMux[],
LSCDAdder[],
LSCDLtArgForm[],
LSCrossConnLS[],
ChopCMux[],
FlagMux[],
LSLatchB[],
LSLatchA[],
SwitchABFlag[],
LSCLatch0B[],
LSCLatch1A[],
DebugLSCF[],
LSCLatch1B[],
CMux2A[],
LSCLatch2A[],
CMux2B[],
LSCLatch2B[],
Switch2BAFlags[],
CMux3A[],
LSCLatch3A[],
CMux3B[],
LSCLatch3B[]     ] ];
CoreFrame.WriteFrameCache[cellType]}};

END. 
<<>>