
<<IFUSrcLSForm.mesa >>
    <<Copyright c 1986 by Xerox Corporation.  All rights reserved.>>
    <<Curry, July 9, 1986 11:18:36 am PDT>>
<<>>
DIRECTORY Core, CoreFrame, CoreName, CoreXform, 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";
lSum17: ROPE = "
(GND  LSum.1  LSum.2  LSum.3  LSum.4  LSum.5  LSum.6  LSum.7)";
sSum17: 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 = "(GND GND GND GND GND CRegOffBA.0 CRegOffBA.1 CRegOffBA.2 )";
cBase:        REF = IFUSrc.ProcRegToList[euConstant];
aBase:        REF = IFUSrc.ProcRegToList[euAux];
noStore:    REF = IFUSrc.ProcRegToList[euJunk];

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 ];

LStackRdMuxTop:        LIST OF REF = LIST[
xBus,
op47AlBeBA,    -- Op03 dropped here
"(    NIL                    NIL                    NIL                    NIL                    )",
"(    NIL                    NIL                    NIL                    LStackWtDataA.3    )",
"(    NIL                    NIL                    NIL                    LStackRdDataA.3    )" ];

LStackRdMux:                PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "LStackRdMux",
top:        LStackRdMuxTop,
left:         "(    Push3BA    NotPush3BA    )",
in:            "(    
(    LStackWtDataA.3      NIL  NIL  NIL    )
(    LStackRdDataA.3      NIL  NIL  NIL    ) )",
out:        "(
(    SelLStackRdDataA.3  NIL  NIL  NIL    )    )",
bot:        LStackIOSwitchingTop,
xform:        IFUCoreData.Interleaved48 ]};

LStackIOSwitchingTop:        LIST OF REF = LIST[
xBus,
op47AlBeBA,
"(    NIL                    NIL                    NIL                    NIL                    )",
"(    LStackRdDataA.3    NIL                    NIL                    LStackWtDataA.3    )",
"(    LStackWtDataA.3    NIL                    NIL                    LStackRdDataA.3    )",
"(    SelLStackRdDataA.3    NIL                    NIL                    NIL                    )" ];

LSStackIOSwitching:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "LSStackIOSwitching",
top:        LStackIOSwitchingTop,
left:        "( NotPhA )",
right:        "( X1ASrcStackLAc    NotX1ASrcStackLAc )",
bot:        LStackLatchIOTop,
xform:        IFUCoreData.Interleaved48 ]};

LStackLatchIOTop:        LIST OF REF = LIST[
xBus,
op47AlBeBA,
"(    NIL                    NotX1ASrcStackLAc    NIL                    NIL                    )",
"(    NIL                    X1ASrcStackLAc        LStackRdDataA.3    LStackWtDataA.3    )",
"(    LStkTopAB.            XBus.3                NotPhA                NIL                    )",
"(    SelLStackRdDataA.3    LStkTopAB.            NIL                    LStkTopAB.            )" ];

LStackLatchIO:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LStackLatchIO",
type:        "(
DpLatch                    DpLatchTriDr        DpLatchPreChg        DpLatchBuf)",
top:        LStackLatchIOTop,
left:         "(    PhA    VBB    )",
in:            "(
(SelLStackRdDataA.3    LStkTopAB.            NotPhA                PreLStackWtDataA.3    )
(NIL                        X1ASrcStackLAc        NIL                    NIL                    )
(NIL                        NotX1ASrcStackLAc    NIL                    NIL                    )
(NIL                        NIL                    NIL                    NIL                    )
)",
out:        "(
(LStkTopAB.                XBus.3                LStackRdDataA.3    LStackWtDataA.3 ))",
bot:        LStackWtMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

LStackWtMuxTop:        LIST OF REF = LIST[
xBus,
op47AlBeBA,
"(    NIL                    NIL                    NIL                    PreLStackWtDataA.3    )",
"(    NIL                    NIL                    NIL                    NIL                    )",
"(    NIL                    NIL                    NIL                    NIL                    )",
"(    NIL                    NIL                    NIL                    LStkTopAB.            )" ];

LStackWtMux:                PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "LStackWtMux",
top:        LStackWtMuxTop,
right:         "(    X1ADstStackBA    NotX1ADstStackBA                    )",
in:            "(    XBus.    (    NIL  NIL  NIL  L3BA.                    )    )",
out:        "(            (    NIL  NIL  NIL  PreLStackWtDataA.3    )    )",
bot:        LSMuxSwitchingTop,
xform:        IFUCoreData.Interleaved48 ]};

LSMuxSwitchingTop:        LIST OF REF = LIST[
xBus,
op47AlBeBA,
NIL,
NIL,
"(    NIL                    NIL                    NIL                    L3BA.                )",
"(    NIL                    NIL                    NIL                    LStkTopAB.        )" ];

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

LSCDRtArgFormMuxTop:            LIST OF REF = LIST[
xBus,
op47AlBeBA,
LIST[    "AlphaBA.",        "AlphaBA.",    op47,        "SDeltaB." ],
LIST[    "LStkTopAB.",    "SDeltaB.",    beta,        NIL        ],
LIST[    NIL,                NIL,            beta03    ,    "L3BA."    ],
NIL,
GND,
VDD,
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            NIL        SDeltaB.    )",
"(    NIL            NIL            NIL        NIL        )",
"(    NIL            NIL            NIL        L3BA.        )",
"(    LSumRt.        SSumRt.        CRt.        NIL        )"    ];

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

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

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    )",
in:     LIST[
"(        LAB.        NIL        NIL        NIL    )",
"(        SAB.        NIL        NIL        NIL    )",
LIST[    zero,        NIL,        NIL,        NIL    ],
"(        L3BA.        NIL        NIL        NIL    )",
"(        NIL        SAB.        NIL        NIL    )",
"(        NIL        LAB.        NIL        NIL    )",
"(        NIL        S2BA.        NIL        NIL    )",
"(        NIL        S3BA.        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    ] ],
out:    "( ( LSumLt.    SSumLt.    CLt.        NIL    ) )",
bot:        LSCrossConnLSTop,
xform:        IFUCoreData.Interleaved48 ]};

LSCrossConnLSTop:            LIST OF REF = LIST[
xBus,
LIST[    op47,        s2AB,        alpha,        beta            ],
"(        LAB.        SAB.        NIL        NIL            )",
"(        L3AB.        S3AB.        NIL        PopSbBA        )",
LIST[    lSum17,    sSum17,    "CSum.",    "L3BA."        ],
"(        NIL        NIL        NIL        PopSaBA        )",
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 PopSaBA )",
bot:        ChopCMuxTop,
xform:        IFUCoreData.Interleaved48 ]};

ChopCMuxTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        s2AB,        alpha,        beta        ],
"(        LAB.        SAB.        NIL        L3BA.        )",
"(        L3AB.        S3AB.        NIL        NIL        )",
LIST[    lSum17,    sSum17,    "CSum.",    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:        LSLatchBTop,
xform:        IFUCoreData.Interleaved48 ]};

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

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

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

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

LSCLatch0BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        s2AB,        alpha,        beta        ],
"(        LAB.        SAB.        NIL        L3BA.        )",
"(        L3AB.        S3AB.        CSumx.    NIL        )",
"(        NIL        NIL        NIL        NIL        )" ];

LSCLatch0B:                    PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "GPRow",
name:        "LSCLatch0B",
type:         "DpLatch",
top:        LSCLatch0BTop,
left:        "(    PhB VBB    )",
in:            "(    (    LAB.    SAB.    CSumx.    NIL        ))",
out:        "(    (    L0BA.    S0BA.    C0BA.        NIL        ))",
bot:        LSCLatch1ATop,
xform:        IFUCoreData.Interleaved48 ]};

LSCLatch1ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        s2AB,        alpha,        beta        ],
"(        LAB.        SAB.        NIL        L3BA.        )",
"(        L3AB.        S3AB.        NIL        NIL        )",
"(        L0BA.        S0BA.        C0BA.        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.    NIL        ))",
out:        "(    (    L1AB.    S1AB.    C1AB.    NIL        ))",
bot:        LSCLatch1BTop,
xform:        IFUCoreData.Interleaved48 ]};

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

LSCLatch1BTop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        s2AB,        alpha,        beta        ],
"(        LAB.        SAB.        NIL        L3BA.        )",
"(        L3AB.        S3AB.        NIL        NIL        )",
"(        L1AB.        S1AB.        C1AB.        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.    NIL        ))",
out:        "(    (    L1BA.    S1BA.    C1BA.    NIL        ))",
bot:        CMux2ATop,
xform:        IFUCoreData.Interleaved48 ]};

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

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

LSCLatch2ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        s2AB,        alpha,        beta        ],
"(        LAB.        SAB.        NIL        L3BA.        )",
"(        L3AB.        S3AB.        NIL        NIL        )",
"(        L1BA.        S1BA.        C2A.        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.    NIL        ))",
out:        "(    (    L2AB.    S2AB.    C2AB.    NIL        ))",
bot:        CMux2BTop,
xform:        IFUCoreData.Interleaved48 ]};

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

CMux2B: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux2B",
top:        CMux2BTop,
left:        "(    Stage2BNormalAB Stage2BAbortAB )",
in:     LIST[
LIST[            NIL,    NIL,    "C2AB.",    NIL    ],
LIST[            NIL,    NIL,    noStore,    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        L3BA.        )",
"(        L3AB.        S3AB.        C2AB.        NIL        )",
"(        L2AB.        NIL        C2B.        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.    NIL        ))",
out:        "(    (    L2BA.    S2BA.    C2BA.    NIL        ))",
bot:        CMux3ATop,
xform:        IFUCoreData.Interleaved48 ]};

CMux3ATop:            LIST OF REF = LIST[
xBus,    
LIST[    op47,        NIL,        alpha,        beta        ],
"(        LAB.        SAB.        C2BA.        L3BA.        )",
"(        L3AB.        S3AB.        C2AB.        NIL        )",
"(        L2BA.        S2BA.        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        L3BA.        )",
"(        L3AB.        S3AB.        C2AB.        NIL        )",
"(        L2BA.        S2BA.        C3A.        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.    NIL        ))",
out:        "(    (    L3AB.    S3AB.    C3AB.    NIL        ))",
bot:        CMux3BTop,
xform:        IFUCoreData.Interleaved48 ]};

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

CMux3B: PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "Mux",
name:        "CMux3B",
top:        CMux3BTop,
left:        "(    Stage3BCPipeNormalAB Stage3BCPipeAbortAB )",
in:     LIST[
LIST[            NIL,    NIL,    "C3AB.",    NIL    ],
LIST[            NIL,    NIL,    noStore,    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.        L3BA.        )",
"(        L3AB.        NIL    C2AB.        NIL        )",
"(        NIL        NIL    C3B.        NIL        )" ];

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

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

LSCBotSwitchBox:            PROC RETURNS[cellType: Core.CellType] = {
cellType _ IFUCoreData.CellProc[
subClass:    "SwitchBox",
name:        "LSCBotSwitchBox",
top:        LSCBotSwitchBoxTop,
left:        NIL,
right:        NIL,
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[
LStackRdMux[],
LSStackIOSwitching[],
LStackLatchIO[],
LStackWtMux[],
LSMuxSwitching[],
LSCDRtArgFormMux[],
LSCDAdder[],
LSCDLtArgForm[],
LSCrossConnLS[],
ChopCMux[],
LSLatchB[],
LSLatchA[],
LSCLatch0B[],
LSCLatch1A[],
DebugLSC[],
LSCLatch1B[],
CMux2A[],
LSCLatch2A[],
CMux2B[],
LSCLatch2B[],
CMux3A[],
LSCLatch3A[],
CMux3B[],
LSCLatch3B[],
LSCBotSwitchBox[]     ] ];
CoreFrame.WriteFrameCache[cellType]}};

END. 
<<>>
<<>>