Google
 

Trailing-Edge - PDP-10 Archives - klad_sources - klad.sources/msdpmd.b36
There are no other files named msdpmd.b36 in the archive.
%TITLE 'STIRS FAULT ISOLATION DATA FOR M8621 (DPM) BOARD'

MODULE MSDPMD	(
		LANGUAGE(BLISS36)
		) =

BEGIN

!
!			  COPYRIGHT (C) 1979 BY
!	      DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
!
! THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND  COPIED
! ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH  LICENSE AND WITH THE
! INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY  OTHER
! COPIES  THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
! OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS  HEREBY
! TRANSFERRED.
!
! THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT  NOTICE
! AND  SHOULD  NOT  BE  CONSTRUED  AS  A COMMITMENT BY DIGITAL EQUIPMENT
! CORPORATION.
!
! DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF  ITS
! SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!

!++
! FACILITY:	DECSYSTEM 2020 DIAGNOSTIC RELEASE TAPE 'DSTIR'
!
! ABSTRACT:
!
!	THIS MODULE CONTAINS THE FAULT ISOLATION DATA FOR THE KS10
!	STIMULUS/RESPONSE (STIRS) DIAGNOSTIC FOR THE M8621 (DPM) BOARD.
!	IT IS LINKED TO THE 'MSSTRC' AND 'MSDPMT' MODULES TO PRODUCE
!	THE 'MSDPM.EXE' FILE.
!
! ENVIRONMENT: 	RUNS UNDER 'CSL' ON A TOPS-20 SYSTEM.
!
! AUTHOR: ARON INSINGA	, CREATION DATE: 01-SEP-78!
! MODIFIED BY:
!
!	ARON INSINGA, 23-MAY-79; VERSION 0.1
!--
!
! EQUATED SYMBOLS:
!

    GLOBAL LITERAL
	DATA_VERSION = 1,
	DATA_EDIT = 0;

    COMPILETIME
	ALLOC_B = 35,	! PDP-11 STYLE BIT # IN WORD, READY TO OVERFLOW
	ALLOC_W = -1,	! WORD #, SO WE WILL START WITH 0 AFTER OVERFLOW
	ALLOC_N = 0,	! NUMBER OF THINGS ALLOCATED
	ALLOC_N_1 = 0,	! (ALLOC_N - 1) TEMPORARY
	ALLOC_W_1 = 0,	! (ALLOC_W + 1) TEMPORARY
	ALLOC_B_1 = 0;	! (35 - ALLOC_B) TEMPORARY

!
! MACROS:
!

    MACRO
	ALLOC(ALLOC_NAME,ALLOC_SLIT) =	! ALLOCATE FAULT ANALYSIS BITS
	    %ASSIGN(ALLOC_B,ALLOC_B + 1)
	    %IF ALLOC_B EQL 36
	    %THEN
		%ASSIGN(ALLOC_B,0)
		%ASSIGN(ALLOC_W,ALLOC_W + 1)
		COMPILETIME
		    %NAME(W_,%NUMBER(ALLOC_W)) = 0;
	    %FI
	    ! PRINT THE WORD # AND PDP-10 BIT # INTO THE LISTING
	    %ASSIGN(ALLOC_B_1,35 - ALLOC_B)
	    %PRINT(%NUMBER(ALLOC_W),',',%NUMBER(ALLOC_B_1))
	    MACRO
		ALLOC_NAME =
		    %QUOTE %ASSIGN
		    (
			%QUOTE %EXPAND %NAME(W_,%NUMBER(ALLOC_W)),
			%QUOTE %EXPAND %NAME(W_,%NUMBER(ALLOC_W)) OR
			    (1 ^ %QUOTE %EXPAND %NUMBER(ALLOC_B))
		    )
		    %QUOTE % ;
	    BIND
		%NAME(N_,%NUMBER(ALLOC_N)) =
		    %IF %NULL(ALLOC_SLIT)
		    %THEN
			%ASSIGN(ALLOC_N_1,ALLOC_N - 1)
			%NAME(N_,%NUMBER(ALLOC_N_1))
		    %ELSE
			UPLIT(%ASCIZ ALLOC_SLIT)
		    %FI ;
	    %ASSIGN(ALLOC_N,ALLOC_N + 1)
	%,
	DUMP(X,N)[] =		! X0, ... XN
	    %IF %COUNT GEQ N %THEN %EXITMACRO %FI
	    %IF %COUNT NEQ 0 %THEN , %FI
	    %NAME(X,%NUMBER(%COUNT))
	    DUMP(X,N)
	%,
	DUMP_ASSIGN(N)[] =	! %ASSIGN(X0,0) ... %ASSIGN(XN,0)
	    %IF %COUNT GEQ N %THEN %EXITMACRO %FI
	    %QUOTE %ASSIGN (%NAME(W_,%NUMBER(%COUNT)),0)
	    DUMP_ASSIGN(N)
	%;
    ! DPM 1
    ALLOC(DBM_SEL_SCAD,'DPM1: DBM MUX SELECT')
    ALLOC(DBM_SEL_PF)
    ALLOC(DBM_SEL_APR)
    ALLOC(DBM_SEL_APR_EN)
    ALLOC(DBM_SEL_BYTES)
    ALLOC(DBM_SEL_BYTES35)
    ALLOC(DBM_SEL_EXP)
    ALLOC(DBM_SEL_MSEC)
    ALLOC(DBM_SEL_DP)
    ALLOC(DBM_SEL_DP_SWAP)
    ALLOC(DBM_SEL_VMA)
    ALLOC(DBM_SEL_MEM)
    ALLOC(DBM_SEL_N)

    ! DPM 1,2
    ALLOC(DBM_SCAD,'DPM1,2: DBM MUX')
    ALLOC(DBM_PF)
    ALLOC(DBM_APR)
    ALLOC(DBM_APR_EN)
    ALLOC(DBM_BYTES)
    ALLOC(DBM_BYTES35)
    ALLOC(DBM_EXP)
    ALLOC(DBM_MSEC)
    ALLOC(DBM_DP)
    ALLOC(DBM_DP_SWAP)
    ALLOC(DBM_VMA)
    ALLOC(DBM_VMA_MEM)
    ALLOC(DBM_MEM)
    ALLOC(DBM_N)

    ! DPM 3
    ALLOC(SCADA_SC,'DPM3: SCAD A MUX')
    ALLOC(SCADA_SN)
    ALLOC(SCADA_44)
    ALLOC(SCADA_BYTE1)
    ALLOC(SCADA_BYTE2)
    ALLOC(SCADA_BYTE3)
    ALLOC(SCADA_BYTE4)
    ALLOC(SCADA_BYTE5)
    ALLOC(SCADA_SEL_SC,'DPM3: SCAD A MUX SELECT')
    ALLOC(SCADA_SEL_SN)
    ALLOC(SCADA_SEL_44)
    ALLOC(SCADA_SEL_BYTE1)
    ALLOC(SCADA_SEL_BYTE2)
    ALLOC(SCADA_SEL_BYTE3)
    ALLOC(SCADA_SEL_BYTE4)
    ALLOC(SCADA_SEL_BYTE5)
    ALLOC(SCADB_FE,'DPM3: SCAD B MUX')
    ALLOC(SCADB_EXP)
    ALLOC(SCADB_SHIFT)
    ALLOC(SCADB_SIZE)
    ALLOC(SCADB_SEL_FE,'DPM3: SCAD B MUX SELECT')
    ALLOC(SCADB_SEL_EXP)
    ALLOC(SCADB_SEL_SHIFT)
    ALLOC(SCADB_SEL_SIZE)

    ! DPM 3,4
    ALLOC(SCAD_A_MUL2,'DPB3,4: SCAD')
    ALLOC(SCAD_OR)
    ALLOC(SCAD_SUBB)
    ALLOC(SCAD_SUB)
    ALLOC(SCAD_ADD)
    ALLOC(SCAD_AND)
    ALLOC(SCAD_A_DEC)
    ALLOC(SCAD_A)

    ! DPM 4
    ALLOC(VMA_USER_DP,'DPM4: VMA USER')
    ALLOC(VMA_USER_N)
    ALLOC(VMA_PREV_DP,'DPM4: VMA PREVIOUS')
    ALLOC(VMA_PREV_N)
    ALLOC(VMA_PHYS_DP,'DPM4: VMA PHYSICAL')
    ALLOC(VMA_PHYS_N)
    ALLOC(VMA_FETCH_DP,'DPM4: VMA FETCH')
    ALLOC(VMA_FETCH_N)
    ALLOC(VMA_CYCLE_DP,'DPM4: VMA CYCLE')
    ALLOC(VMA_CYCLE_N)
    ALLOC(VMA_SWEEP,'DPM4: VMA SWEEP')
    ALLOC(VMA_SWEEP_CD)
    ALLOC(VMA_SWEEP_PT)
    ALLOC(VMA,'DPM4: VMA REGISTER')
    ALLOC(FE,'DPM4: FE REGISTER')
    ALLOC(FE_EN,'DPM4: FE ENABLE')
    ALLOC(FE_SIGN,'DPM4: FE SIGN')
    ALLOC(SC,'DPM4: SC REGISTER')
    ALLOC(SC_EN,'DPM4: SC ENABLE')
    ALLOC(SC_SIGN,'DPM4: SC SIGN')
    ALLOC(AC_REF,'DPM4: VMA IS AC')

    ! DPM 5
    ALLOC(MEM_READ_N,'DPM5: MEM READ')
    ALLOC(MEM_READ_DP)
    ALLOC(MEM_READ_DRO)
    ALLOC(MEM_WRITE_N,'DPM5: MEM WRITE')
    ALLOC(MEM_WRITE_DP)
    ALLOC(MEM_WRITE_DRO)
    ALLOC(MEM_WR_TEST_N,'DPM5: MEM WRITE TEST')
    ALLOC(MEM_WR_TEST_DP)
    ALLOC(MEM_WR_TEST_DRO)
    ALLOC(MEM_CAC_INH_N,'DPM5: MEM CACHE INHIBIT')
    ALLOC(MEM_CAC_INH_DP)
    ALLOC(MEM_CAC_INH_DRO)
    ALLOC(BUS_REQ,'DPM5: BUS REQUEST')
    ALLOC(BUS_REQ_A)
    ALLOC(CLK_APR,'DPM5: CLOCK APR')
    ALLOC(MEM_DELAY,'DPM5: MEM DELAY')
    ALLOC(VMA_EN,'DPM5: VMA EN')
    ALLOC(MEM_EN,'DPM5: MEM EN')
    ALLOC(SPEC,'DPM5: SPEC')
    ALLOC(STOP,'DPM5: STOP MEM')
    ALLOC(MEM_WAIT,'DPM5: MEM WAIT')
    ALLOC(FORCE,'DPM5: FORCE RAMFILE')

    ! DPM 5,6,C
    ALLOC(BUS_CYCLE,'DPM5,6,C: BUS CYCLE CONTROL')

    ! DPM 6
    ALLOC(PT_ADR,'DPM6: PAGE TABLE')
    ALLOC(PT_IO)
    ALLOC(PT_VAL_WRT)
    ALLOC(PT_USR)
    ALLOC(PT_CAC)
    ALLOC(PT_PAR)
    ALLOC(PT_RAM_PAG_USR)
    ALLOC(PT_RAM_VAL_WRT)
    ALLOC(PT_RAM_CAC)
    ALLOC(PT_RAM_PAR)
    ALLOC(PF,'DPM6: PAGE FAIL')
    ALLOC(PF_WT)
    ALLOC(PF_NXM)
    ALLOC(PF_BAD)
    ALLOC(PF_OK)
    ALLOC(PT_PAR_GEN,'DPM6: PT PARITY')
    ALLOC(PAR_ERR,'DPM6: PARITY ERR')

    ! DPM 7
    ALLOC(CD_ADR,'DPM7: CACHE DIR')
    ALLOC(CD_IO)
    ALLOC(CD_VAL)
    ALLOC(CD_CMP,'DPM7: CD COMPARATOR')
    ALLOC(CD_HIT,'DPM7: CD HIT')
    ALLOC(CD_PAR,'DPM7: CD PARITY')
    ALLOC(CD_RAM_PAG_USR)
    ALLOC(CD_RAM_VAL)
    ALLOC(CD_RAM_PAR)

    ! DPM 8,9
    ALLOC(BUS_MUX_DP,'DPM8,9: DBM MUX')
    ALLOC(BUS_MUX_VMA)
    ALLOC(BUS_MUX_PAGE)
    ALLOC(BUS_PAR,'DPM8,9: BUS PARITY')

    ! DPM 8,9,C
    ALLOC(BUS_T,'DPM8,9: BUS XCVR')
    ALLOC(BUS_R);

    ! DPM A
    ALLOC(CLK,'DPMA: CLOCK')
    ALLOC(RAM_CLK,'DPMA: RAM CLOCK')
    ALLOC(BUS_CLK,'DPMA: BUS CLOCK')
    ALLOC(BUS_XMIT,'DPMA: BUS XMIT')
    ALLOC(RESET,'DPMA: RESET')
    ALLOC(PXCT,'DPMA: PXCT')
    ALLOC(PXCT_MUX,'DPMA: PXCT MUX')
    ALLOC(PXCT_MUX_DPE)
    ALLOC(SPEC_PREV,'DPMA: SPEC 10')
    ALLOC(SPEC_APR)
    ALLOC(SPEC_SWEEP)
    ALLOC(SPEC_APR_EN)
    ALLOC(SPEC_PXCT_OFF)
    ALLOC(SPEC_MEMCLR)
    ALLOC(SPEC_MEMCLR_NXM)
    ALLOC(SPEC_MEMCLR_BAD)
    ALLOC(SPEC_MSEC,'DPMA: SPEC 20')
    ALLOC(SPEC_PAGE)
    ALLOC(SPEC_PXCT_EN)

    ! DPM A,C
    ALLOC(PT_CLK,'DPMA,C: PT CLOCK')

    ! DPM B
    ALLOC(APR,'DPMB: APR FLAGS')
    ALLOC(APR_EN,'DPMB: APR EN')
    ALLOC(TRAP_EN,'DPMB: TRAP EN')
    ALLOC(PAGE_EN,'DPMB: PAGE EN')

    ! DPM C
    ALLOC(BUS_TIMEOUT,'DPMC: BUS TIMEOUT')
    ALLOC(BUS_NXM,'DPMC: NXM ERR')
    ALLOC(BAD_DATA,'DPMC: BAD DATA')
    ALLOC(MEM_CYCLE,'DPMC: MEM CYCLE')
    ALLOC(IO_CYCLE,'DPMC: IO CYCLE')
    ALLOC(MSEC,'DPMC: MSEC')
    ALLOC(MSEC_FREQ,'DPMC: MSEC FREQUENCY')
! COMBINATIONS

    MACRO
	BUS = BUS_T BUS_R %,
	BUS_MUX = BUS_MUX_DP BUS_MUX_VMA BUS_MUX_PAGE %,
	BUS_ALL = BUS BUS_REQ BUS_TIMEOUT BUS_CYCLE BUS_CLK BUS_XMIT BUS_NXM %,
	VMA_ALL_DP = VMA_CYCLE_DP VMA_EN VMA VMA_PHYS_DP VMA_PREV_DP VMA_USER_DP %,
	VMA_ALL_N = VMA_CYCLE_N VMA_EN VMA VMA_PHYS_N VMA_PREV_N VMA_USER_N N_ALL %,
	N_ALL = DBM_N DBM_SEL_N %,
	PT_MESS = SPEC_PAGE PF BUS_ALL MEM_EN BUS_REQ MEM_WRITE_N MEM_READ_N BUS_MUX_PAGE VMA_ALL_N %,
	PF_CODE = PF DBM_PF DBM_SEL_PF %,
	VMA_USER_PREV = VMA_USER_DP VMA_USER_N VMA_PREV_DP VMA_PREV_N %,
	SPEC_PXCT = SPEC_PXCT_OFF SPEC_PXCT_EN %;
!
! EQUATED SYMBOLS:
!

    GLOBAL LITERAL
	MAXNETS = ALLOC_N;

    MACRO
	NTWK =
	    %ASSIGN(ALLOC_W_1,ALLOC_W + 1)
	    DUMP(W_,%NUMBER(ALLOC_W_1))
	    DUMP_ASSIGN(%NUMBER(ALLOC_W_1))
	%;

    ! THIS MAKES A  V E R Y  LONG LISTING WITH EXPANSIONS
    SWITCHES LIST(NOEXPAND);

    GLOBAL BIND
	NET_NAMES = PLIT
	(
	    DUMP(N_,%NUMBER(ALLOC_N))
	);

    ! DOCUMENT WHAT JUST HAPPENED
    %PRINT(%NUMBER(ALLOC_N))
    %PRINT(%NUMBER(ALLOC_W))
    %PRINT(%NUMBER(ALLOC_B))
BIND		T1_E1 = UPLIT(DBM_N NTWK);
BIND		T1_NE1 = UPLIT(DBM_N NTWK);
BIND		T1_E2 = UPLIT(DBM_SEL_N NTWK);
BIND		T1_NE2 = UPLIT(DBM_SEL_N NTWK);

BIND	T1_ES = PLIT(	T1_E1,
			T1_E2);
BIND	T1_NES = PLIT(	T1_NE1,
			T1_NE2);


BIND		T2_E1 = UPLIT(DBM_DP_SWAP NTWK);
BIND		T2_NE1 = UPLIT(DBM_DP_SWAP NTWK);
BIND		T2_E2 = UPLIT(DBM_SEL_DP_SWAP NTWK);
BIND		T2_NE2 = UPLIT(DBM_SEL_DP_SWAP NTWK);

BIND	T2_ES = PLIT(	T2_E1,
			T2_E2);
BIND	T2_NES = PLIT(	T2_NE1,
			T2_NE2);


BIND		T3_E1 = UPLIT(DBM_DP NTWK);
BIND		T3_NE1 = UPLIT(DBM_DP NTWK);
BIND		T3_E2 = UPLIT(DBM_SEL_DP NTWK);
BIND		T3_NE2 = UPLIT(DBM_SEL_DP NTWK);

BIND	T3_ES = PLIT(	T3_E1,
			T3_E2);
BIND	T3_NES = PLIT(	T3_NE1,
			T3_NE2);


BIND		T4_E1 = UPLIT(SCAD_A SCADA_SN DBM_SCAD NTWK);
BIND		T4_NE1 = UPLIT(SCAD_A SCADA_SN DBM_SCAD NTWK);
BIND		T4_E2 = UPLIT(SCAD_A SCADA_SEL_SN DBM_SEL_SCAD NTWK);
BIND		T4_NE2 = UPLIT(SCAD_A SCADA_SEL_SN DBM_SEL_SCAD NTWK);

BIND	T4_ES = PLIT(	T4_E1,
			T4_E2);
BIND	T4_NES = PLIT(	T4_NE1,
			T4_NE2);


BIND		T5_E1 = UPLIT(SCAD_A_DEC SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);
BIND		T5_NE1 = UPLIT(SCAD_A_DEC SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);

BIND	T5_ES = PLIT(	T5_E1);
BIND	T5_NES = PLIT(	T5_NE1);


BIND		T6_E1 = UPLIT(SCAD_A_MUL2 SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);
BIND		T6_NE1 = UPLIT(SCAD_A_MUL2 SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);

BIND	T6_ES = PLIT(	T6_E1);
BIND	T6_NES = PLIT(	T6_NE1);


BIND		T7_E1 = UPLIT(SCAD_A SC SCADA_SC SCADA_SN DBM_SCAD NTWK);
BIND		T7_NE1 = UPLIT(SCAD_A SC SCADA_SC SCADA_SN DBM_SCAD NTWK);
BIND		T7_E2 = UPLIT(SCAD_A SC_EN SCADA_SEL_SC SCADA_SEL_SN DBM_SEL_SCAD NTWK);
BIND		T7_NE2 = UPLIT(SCAD_A SC_EN SCADA_SEL_SC SCADA_SEL_SN DBM_SEL_SCAD NTWK);

BIND	T7_ES = PLIT(	T7_E1,
			T7_E2);
BIND	T7_NES = PLIT(	T7_NE1,
			T7_NE2);


BIND		T8_E1 = UPLIT(SCAD_A SCADA_44 SC SCADA_SC SCADA_SN DBM_SCAD NTWK);
BIND		T8_NE1 = UPLIT(SCAD_A SCADA_44 SC SCADA_SC SCADA_SN DBM_SCAD NTWK);
BIND		T8_E2 = UPLIT(SCAD_A SCADA_SEL_44 SC_EN SCADA_SEL_SC SCADA_SEL_SN DBM_SEL_SCAD NTWK);
BIND		T8_NE2 = UPLIT(SCAD_A SCADA_SEL_44 SC_EN SCADA_SEL_SC SCADA_SEL_SN DBM_SEL_SCAD NTWK);

BIND	T8_ES = PLIT(	T8_E1,
			T8_E2);
BIND	T8_NES = PLIT(	T8_NE1,
			T8_NE2);


BIND		T9_E1 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE1 DBM_SCAD NTWK);
BIND		T9_NE1 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE1 DBM_SCAD NTWK);
BIND		T9_E2 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE1 DBM_SEL_SCAD NTWK);
BIND		T9_NE2 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE1 DBM_SEL_SCAD NTWK);
BIND		T9_E3 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE2 DBM_SCAD NTWK);
BIND		T9_NE3 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE2 DBM_SCAD NTWK);
BIND		T9_E4 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE2 DBM_SEL_SCAD NTWK);
BIND		T9_NE4 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE2 DBM_SEL_SCAD NTWK);
BIND		T9_E5 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE3 DBM_SCAD NTWK);
BIND		T9_NE5 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE3 DBM_SCAD NTWK);
BIND		T9_E6 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE3 DBM_SEL_SCAD NTWK);
BIND		T9_NE6 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE3 DBM_SEL_SCAD NTWK);
BIND		T9_E7 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE4 DBM_SCAD NTWK);
BIND		T9_NE7 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE4 DBM_SCAD NTWK);
BIND		T9_E8 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE4 DBM_SEL_SCAD NTWK);
BIND		T9_NE8 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE4 DBM_SEL_SCAD NTWK);
BIND		T9_E9 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE5 DBM_SCAD NTWK);
BIND		T9_NE9 = UPLIT(SCAD_A SCADA_44 SCADA_BYTE5 DBM_SCAD NTWK);
BIND		T9_E10 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE5 DBM_SEL_SCAD NTWK);
BIND		T9_NE10 = UPLIT(SCAD_A SCADA_SEL_44 SCADA_SEL_BYTE5 DBM_SEL_SCAD NTWK);

BIND	T9_ES = PLIT(	T9_E1,
			T9_E2,
			T9_E3,
			T9_E4,
			T9_E5,
			T9_E6,
			T9_E7,
			T9_E8,
			T9_E9,
			T9_E10);
BIND	T9_NES = PLIT(	T9_NE1,
			T9_NE2,
			T9_NE3,
			T9_NE4,
			T9_NE5,
			T9_NE6,
			T9_NE7,
			T9_NE8,
			T9_NE9,
			T9_NE10);


BIND		T10_E1 = UPLIT(SCAD_OR SCADB_FE SCADA_SN SCAD_A SCADA_SC SC FE DBM_SCAD NTWK);
BIND		T10_NE1 = UPLIT(SCAD_OR SCADB_FE SCADA_SN SCAD_A SCADA_SC SC FE DBM_SCAD NTWK);
BIND		T10_E2 = UPLIT(SCAD_OR SCADB_SEL_FE SCADA_SEL_SN SCAD_A SCADA_SEL_SC SC_EN FE_EN DBM_SEL_SCAD NTWK);
BIND		T10_NE2 = UPLIT(SCAD_OR SCADB_SEL_FE SCADA_SEL_SN SCAD_A SCADA_SEL_SC SC_EN FE_EN DBM_SEL_SCAD NTWK);

BIND	T10_ES = PLIT(	T10_E1,
			T10_E2);
BIND	T10_NES = PLIT(	T10_NE1,
			T10_NE2);


BIND		T11_E1 = UPLIT(SCAD_OR SCADB_SHIFT SCADA_SN DBM_SCAD NTWK);
BIND		T11_NE1 = UPLIT(SCAD_OR SCADB_SHIFT SCADA_SN DBM_SCAD NTWK);
BIND		T11_E2 = UPLIT(SCAD_OR SCADB_SEL_SHIFT SCADA_SEL_SN DBM_SEL_SCAD NTWK);
BIND		T11_NE2 = UPLIT(SCAD_OR SCADB_SEL_SHIFT SCADA_SEL_SN DBM_SEL_SCAD NTWK);

BIND	T11_ES = PLIT(	T11_E1,
			T11_E2);
BIND	T11_NES = PLIT(	T11_NE1,
			T11_NE2);


BIND		T12_E1 = UPLIT(SCAD_OR SCADB_SIZE SCADA_SN DBM_SCAD NTWK);
BIND		T12_NE1 = UPLIT(SCAD_OR SCADB_SIZE SCADA_SN DBM_SCAD NTWK);
BIND		T12_E2 = UPLIT(SCAD_OR SCADB_SEL_SIZE SCADA_SEL_SN DBM_SEL_SCAD NTWK);
BIND		T12_NE2 = UPLIT(SCAD_OR SCADB_SEL_SIZE SCADA_SEL_SN DBM_SEL_SCAD NTWK);

BIND	T12_ES = PLIT(	T12_E1,
			T12_E2);
BIND	T12_NES = PLIT(	T12_NE1,
			T12_NE2);


BIND		T13_E1 = UPLIT(SCADB_EXP SCAD_OR SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);
BIND		T13_NE1 = UPLIT(SCADB_EXP SCAD_OR SCADA_SN SCADA_SEL_SN DBM_SCAD DBM_SEL_SCAD NTWK);

BIND	T13_ES = PLIT(	T13_E1);
BIND	T13_NES = PLIT(	T13_NE1);


BIND		T14_E1 = UPLIT(DBM_BYTES SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T14_NE1 = UPLIT(DBM_BYTES SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T14_E2 = UPLIT(DBM_SEL_BYTES SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T14_NE2 = UPLIT(DBM_SEL_BYTES SCADA_SN SCADA_SEL_SN SCAD_A NTWK);

BIND	T14_ES = PLIT(	T14_E1,
			T14_E2);
BIND	T14_NES = PLIT(	T14_NE1,
			T14_NE2);


BIND		T15_E1 = UPLIT(DBM_BYTES35 SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T15_NE1 = UPLIT(DBM_BYTES35 SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T15_E2 = UPLIT(DBM_SEL_BYTES35 SCADA_SN SCADA_SEL_SN SCAD_A NTWK);
BIND		T15_NE2 = UPLIT(DBM_SEL_BYTES35 SCADA_SN SCADA_SEL_SN SCAD_A NTWK);

BIND	T15_ES = PLIT(	T15_E1,
			T15_E2);
BIND	T15_NES = PLIT(	T15_NE1,
			T15_NE2);


BIND		T16_E1 = UPLIT(SCAD_AND SCADB_FE SCADA_SN SCAD_A SCADA_SC SC FE DBM_SCAD NTWK);
BIND		T16_NE1 = UPLIT(SCAD_AND SCADB_FE SCADA_SN SCAD_A SCADA_SC SC FE DBM_SCAD NTWK);
BIND		T16_E2 = UPLIT(SCAD_AND SCADB_SEL_FE SCADA_SEL_SN SCAD_A SCADA_SEL_SC SC_EN FE_EN DBM_SEL_SCAD NTWK);
BIND		T16_NE2 = UPLIT(SCAD_AND SCADB_SEL_FE SCADA_SEL_SN SCAD_A SCADA_SEL_SC SC_EN FE_EN DBM_SEL_SCAD NTWK);

BIND	T16_ES = PLIT(	T16_E1,
			T16_E2);
BIND	T16_NES = PLIT(	T16_NE1,
			T16_NE2);


BIND		T17_E1 = UPLIT(SCAD_ADD SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);
BIND		T17_NE1 = UPLIT(SCAD_ADD SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);
BIND		T17_E2 = UPLIT(SCAD_SUB SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);
BIND		T17_NE2 = UPLIT(SCAD_SUB SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);
BIND		T17_E3 = UPLIT(SCAD_SUBB SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);
BIND		T17_NE3 = UPLIT(SCAD_SUBB SC SC_EN SCADA_SC FE FE_EN SCADB_FE DBM_SCAD DBM_SEL_SCAD SCADA_SN SCADA_SEL_SN NTWK);

BIND	T17_ES = PLIT(	T17_E1,
			T17_E2,
			T17_E3);
BIND	T17_NES = PLIT(	T17_NE1,
			T17_NE2,
			T17_NE3);


BIND		T18_NE1 = UPLIT(VMA_USER_DP VMA_FETCH_DP VMA_PHYS_DP VMA_PREV_DP VMA_CYCLE_DP VMA DBM_VMA SPEC_SWEEP NTWK);
BIND		T18_E2 = UPLIT(VMA_USER_DP DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE2 = UPLIT(VMA_USER_DP NTWK);
BIND		T18_E3 = UPLIT(VMA_FETCH_DP DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE3 = UPLIT(VMA_FETCH_DP NTWK);
BIND		T18_E4 = UPLIT(VMA_PHYS_DP DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE4 = UPLIT(VMA_PHYS_DP NTWK);
BIND		T18_E5 = UPLIT(VMA_PREV_DP DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE5 = UPLIT(VMA_PREV_DP NTWK);
BIND		T18_E6 = UPLIT(VMA_CYCLE_DP DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE6 = UPLIT(VMA_CYCLE_DP NTWK);
BIND		T18_E7 = UPLIT(VMA DBM_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T18_NE7 = UPLIT(VMA NTWK);

BIND	T18_ES = PLIT(	T18_E2,
			T18_E3,
			T18_E4,
			T18_E5,
			T18_E6,
			T18_E7);
BIND	T18_NES = PLIT(	T18_NE1,
			T18_NE2,
			T18_NE3,
			T18_NE4,
			T18_NE5,
			T18_NE6,
			T18_NE7);


BIND		T19_E1 = UPLIT(DBM_EXP DBM_SEL_EXP SCAD_A SCADA_SN NTWK);
BIND		T19_NE1 = UPLIT(DBM_EXP DBM_SEL_EXP SCAD_A SCADA_SN NTWK);

BIND	T19_ES = PLIT(	T19_E1);
BIND	T19_NES = PLIT(	T19_NE1);


BIND		T20_NE1 = UPLIT(VMA_USER_N VMA_FETCH_N VMA_PHYS_N VMA_CYCLE_N NTWK);
BIND		T20_E2 = UPLIT(VMA_USER_N DBM_VMA DBM_SEL_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T20_NE2 = UPLIT(VMA_USER_N NTWK);
BIND		T20_E3 = UPLIT(VMA_FETCH_N DBM_VMA DBM_SEL_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T20_NE3 = UPLIT(VMA_FETCH_N NTWK);
BIND		T20_E4 = UPLIT(VMA_PHYS_N DBM_VMA DBM_SEL_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T20_NE4 = UPLIT(VMA_PHYS_N NTWK);
BIND		T20_E5 = UPLIT(VMA_CYCLE_N DBM_VMA DBM_SEL_VMA SPEC_SWEEP VMA_SWEEP NTWK);
BIND		T20_NE5 = UPLIT(VMA_CYCLE_N NTWK);

BIND	T20_ES = PLIT(	T20_E2,
			T20_E3,
			T20_E4,
			T20_E5);
BIND	T20_NES = PLIT(	T20_NE1,
			T20_NE2,
			T20_NE3,
			T20_NE4,
			T20_NE5);


BIND		T21_E1 = UPLIT(MEM_WRITE_N FORCE AC_REF VMA_ALL_N STOP MEM_EN NTWK);
BIND		T21_NE1 = UPLIT(MEM_WRITE_N NTWK);
BIND		T21_E2 = UPLIT(MEM_READ_N FORCE AC_REF VMA_ALL_N STOP MEM_EN NTWK);
BIND		T21_NE2 = UPLIT(MEM_READ_N NTWK);

BIND	T21_ES = PLIT(	T21_E1,
			T21_E2);
BIND	T21_NES = PLIT(	T21_NE1,
			T21_NE2);


BIND		T22_E1 = UPLIT(BUS_ALL BUS_MUX_VMA VMA_ALL_N FORCE AC_REF STOP MEM_EN BUS_REQ MEM_READ_N MEM_WRITE_N NTWK);
BIND		T22_NE1 = UPLIT(MEM_READ_N MEM_WRITE_N BUS_REQ MEM_EN NTWK);

BIND	T22_ES = PLIT(	T22_E1);
BIND	T22_NES = PLIT(	T22_NE1);


BIND		T23_E1 = UPLIT(BUS_R DBM_MEM DBM_SEL_MEM BUS_MUX_VMA BUS_ALL VMA_ALL_N MEM_EN BUS_REQ MEM_READ_N NTWK);
BIND		T23_NE1 = UPLIT(BUS_R NTWK);

BIND	T23_ES = PLIT(	T23_E1);
BIND	T23_NES = PLIT(	T23_NE1);


BIND		T24_E1 = UPLIT(BUS_T BUS_MUX_DP BUS_MUX_VMA BUS_ALL VMA_ALL_N MEM_EN BUS_REQ MEM_WRITE_N NTWK);
BIND		T24_NE1 = UPLIT(BUS_T BUS_MUX_DP NTWK);

BIND	T24_ES = PLIT(	T24_E1);
BIND	T24_NES = PLIT(	T24_NE1);


BIND		T25_E1 = UPLIT(AC_REF FORCE BUS_T BUS_MUX_DP BUS_MUX_VMA BUS_ALL VMA_ALL_N MEM_EN BUS_REQ MEM_WRITE_N NTWK);
BIND		T25_NE1 = UPLIT( NTWK);

BIND	T25_ES = PLIT(	T25_E1);
BIND	T25_NES = PLIT(	T25_NE1);


BIND		T26_E1 = UPLIT(AC_REF FORCE BUS_T BUS_MUX_DP BUS_MUX_VMA BUS_ALL VMA_ALL_N MEM_EN BUS_REQ MEM_WRITE_N NTWK);
BIND		T26_NE1 = UPLIT( NTWK);

BIND	T26_ES = PLIT(	T26_E1);
BIND	T26_NES = PLIT(	T26_NE1);


BIND		T27_E1 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_CAC_INH_N NTWK);
BIND		T27_NE1 = UPLIT(MEM_CAC_INH_N NTWK);
BIND		T27_E2 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA NTWK);
BIND		T27_NE2 = UPLIT( NTWK);
BIND		T27_E3 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WRITE_N NTWK);
BIND		T27_NE3 = UPLIT(MEM_WRITE_N NTWK);
BIND		T27_E4 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WR_TEST_N NTWK);
BIND		T27_NE4 = UPLIT(MEM_WR_TEST_N NTWK);
BIND		T27_E5 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_READ_N NTWK);
BIND		T27_NE5 = UPLIT(MEM_READ_N NTWK);

BIND	T27_ES = PLIT(	T27_E1,
			T27_E2,
			T27_E3,
			T27_E4,
			T27_E5);
BIND	T27_NES = PLIT(	T27_NE1,
			T27_NE2,
			T27_NE3,
			T27_NE4,
			T27_NE5);


BIND		T28_E1 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_CAC_INH_DP NTWK);
BIND		T28_NE1 = UPLIT(MEM_CAC_INH_DP NTWK);
BIND		T28_E2 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA NTWK);
BIND		T28_NE2 = UPLIT( NTWK);
BIND		T28_E3 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WRITE_DP NTWK);
BIND		T28_NE3 = UPLIT(MEM_WRITE_DP NTWK);
BIND		T28_E4 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WR_TEST_DP NTWK);
BIND		T28_NE4 = UPLIT(MEM_WR_TEST_DP NTWK);
BIND		T28_E5 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_READ_DP NTWK);
BIND		T28_NE5 = UPLIT(MEM_READ_DP NTWK);

BIND	T28_ES = PLIT(	T28_E1,
			T28_E2,
			T28_E3,
			T28_E4,
			T28_E5);
BIND	T28_NES = PLIT(	T28_NE1,
			T28_NE2,
			T28_NE3,
			T28_NE4,
			T28_NE5);


BIND		T29_E1 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_CAC_INH_DRO NTWK);
BIND		T29_NE1 = UPLIT(MEM_CAC_INH_DRO NTWK);
BIND		T29_E2 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA NTWK);
BIND		T29_NE2 = UPLIT( NTWK);
BIND		T29_E3 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WRITE_DRO NTWK);
BIND		T29_NE3 = UPLIT(MEM_WRITE_DRO NTWK);
BIND		T29_E4 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_WR_TEST_DRO NTWK);
BIND		T29_NE4 = UPLIT(MEM_WR_TEST_DRO NTWK);
BIND		T29_E5 = UPLIT(DBM_VMA_MEM DBM_SEL_VMA MEM_READ_DRO NTWK);
BIND		T29_NE5 = UPLIT(MEM_READ_DRO NTWK);

BIND	T29_ES = PLIT(	T29_E1,
			T29_E2,
			T29_E3,
			T29_E4,
			T29_E5);
BIND	T29_NES = PLIT(	T29_NE1,
			T29_NE2,
			T29_NE3,
			T29_NE4,
			T29_NE5);


BIND		T30_E1 = UPLIT(N_ALL BUS_ALL BUS_MUX_VMA BUS_MUX_DP VMA_ALL_N MEM_WRITE_N MEM_CAC_INH_N FORCE AC_REF MEM_EN NTWK);
BIND		T30_NE1 = UPLIT(MEM_EN NTWK);

BIND	T30_ES = PLIT(	T30_E1);
BIND	T30_NES = PLIT(	T30_NE1);


BIND		T31_E1 = UPLIT(BUS_REQ_A BUS_ALL BUS_MUX_VMA BUS_MUX_DP VMA_ALL_N MEM_WRITE_N MEM_CAC_INH_N FORCE AC_REF MEM_EN NTWK);
BIND		T31_NE1 = UPLIT(BUS_REQ_A  NTWK);

BIND	T31_ES = PLIT(	T31_E1);
BIND	T31_NES = PLIT(	T31_NE1);


BIND		T32_E1 = UPLIT(PT_IO PT_VAL_WRT PT_USR PT_MESS N_ALL NTWK);
BIND		T32_NE1 = UPLIT(PT_IO NTWK);

BIND	T32_ES = PLIT(	T32_E1);
BIND	T32_NES = PLIT(	T32_NE1);


BIND		T33_E1 = UPLIT(PT_ADR PT_IO PT_VAL_WRT PT_USR PT_MESS N_ALL NTWK);
BIND		T33_NE1 = UPLIT(PT_ADR SPEC_PAGE NTWK);

BIND	T33_ES = PLIT(	T33_E1);
BIND	T33_NES = PLIT(	T33_NE1);


BIND		T34_E1 = UPLIT(PT_VAL_WRT PT_IO PF_WT PF_CODE PT_USR PT_MESS N_ALL NTWK);
BIND		T34_NE1 = UPLIT(PT_VAL_WRT NTWK);

BIND	T34_ES = PLIT(	T34_E1);
BIND	T34_NES = PLIT(	T34_NE1);


BIND		T35_E1 = UPLIT(VMA_USER_PREV SPEC_PREV SPEC_PXCT MEM_EN N_ALL VMA_EN DBM_VMA_MEM DBM_SEL_VMA NTWK);
BIND		T35_NE1 = UPLIT(VMA_USER_DP VMA_USER_N VMA_PREV_DP VMA_PREV_N SPEC_PXCT_OFF SPEC_PREV NTWK);

BIND	T35_ES = PLIT(	T35_E1);
BIND	T35_NES = PLIT(	T35_NE1);


BIND		T36_E1 = UPLIT(PT_USR PT_IO PT_VAL_WRT PT_USR PT_MESS N_ALL PF_CODE NTWK);
BIND		T36_NE1 = UPLIT(PT_USR NTWK);

BIND	T36_ES = PLIT(	T36_E1);
BIND	T36_NES = PLIT(	T36_NE1);


BIND		T37_E1 = UPLIT(PT_VAL_WRT PT_IO PF_WT PF_CODE PT_USR PT_MESS N_ALL NTWK);
BIND		T37_NE1 = UPLIT(PF_WT NTWK);

BIND	T37_ES = PLIT(	T37_E1);
BIND	T37_NES = PLIT(	T37_NE1);


BIND		T38_E1 = UPLIT(PT_VAL_WRT PT_IO PF_NXM SPEC_MEMCLR_NXM PF_CODE PT_USR PT_MESS N_ALL NTWK);
BIND		T38_NE1 = UPLIT(PF_NXM SPEC_MEMCLR_NXM NTWK);

BIND	T38_ES = PLIT(	T38_E1);
BIND	T38_NES = PLIT(	T38_NE1);


BIND		T39_E1 = UPLIT(PT_VAL_WRT PT_IO PF_WT PF_CODE PT_USR PT_MESS N_ALL PF_BAD SPEC_MEMCLR_BAD NTWK);
BIND		T39_NE1 = UPLIT(PF_BAD SPEC_MEMCLR_BAD NTWK);

BIND	T39_ES = PLIT(	T39_E1);
BIND	T39_NES = PLIT(	T39_NE1);


BIND		T40_E1 = UPLIT(PT_VAL_WRT PT_IO PF_WT PF_CODE PT_USR PT_MESS N_ALL PF_OK NTWK);
BIND		T40_NE1 = UPLIT(PF_OK NTWK);

BIND	T40_ES = PLIT(	T40_E1);
BIND	T40_NES = PLIT(	T40_NE1);


BIND		T41_E1 = UPLIT(VMA_SWEEP_PT VMA_SWEEP SPEC_SWEEP PT_VAL_WRT PT_IO PF_WT PF_CODE PT_USR PT_MESS N_ALL NTWK);
BIND		T41_NE1 = UPLIT(VMA_SWEEP_PT NTWK);

BIND	T41_ES = PLIT(	T41_E1);
BIND	T41_NES = PLIT(	T41_NE1);


BIND		T42_E1 = UPLIT(CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T42_NE1 = UPLIT(CD_HIT PT_CAC NTWK);

BIND	T42_ES = PLIT(	T42_E1);
BIND	T42_NES = PLIT(	T42_NE1);


BIND		T43_E1 = UPLIT(CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T43_NE1 = UPLIT(CD_IO NTWK);

BIND	T43_ES = PLIT(	T43_E1);
BIND	T43_NES = PLIT(	T43_NE1);


BIND		T44_E1 = UPLIT(CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T44_NE1 = UPLIT(CD_ADR NTWK);

BIND	T44_ES = PLIT(	T44_E1);
BIND	T44_NES = PLIT(	T44_NE1);


BIND		T45_E1 = UPLIT(VMA_SWEEP_CD VMA_SWEEP SPEC_SWEEP CD_HIT CD_ADR CD_IO CD_CMP PT_CAC PT_USR PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T45_NE1 = UPLIT(VMA_SWEEP_CD NTWK);

BIND	T45_ES = PLIT(	T45_E1);
BIND	T45_NES = PLIT(	T45_NE1);


BIND		T46_E1 = UPLIT(CD_HIT CD_ADR CD_IO CD_CMP PT_CAC PT_USR PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T46_NE1 = UPLIT( NTWK);

BIND	T46_ES = PLIT(	T46_E1);
BIND	T46_NES = PLIT(	T46_NE1);


BIND		T47_E1 = UPLIT(CD_VAL CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T47_NE1 = UPLIT(CD_VAL NTWK);

BIND	T47_ES = PLIT(	T47_E1);
BIND	T47_NES = PLIT(	T47_NE1);


BIND		T48_E1 = UPLIT(PT_RAM_PAG_USR PT_IO PT_VAL_WRT PT_USR PT_MESS NTWK);
BIND		T48_NE1 = UPLIT(PT_RAM_PAG_USR NTWK);

BIND	T48_ES = PLIT(	T48_E1);
BIND	T48_NES = PLIT(	T48_NE1);


BIND		T49_E1 = UPLIT(PT_RAM_VAL_WRT PT_IO PT_VAL_WRT PT_USR PT_MESS PF_CODE NTWK);
BIND		T49_NE1 = UPLIT(PT_RAM_VAL_WRT NTWK);

BIND	T49_ES = PLIT(	T49_E1);
BIND	T49_NES = PLIT(	T49_NE1);


BIND		T50_E1 = UPLIT(CD_RAM_PAG_USR CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T50_NE1 = UPLIT(CD_RAM_PAG_USR NTWK);

BIND	T50_ES = PLIT(	T50_E1);
BIND	T50_NES = PLIT(	T50_NE1);


BIND		T51_E1 = UPLIT(CD_RAM_VAL CD_HIT PT_CAC CD_ADR CD_IO CD_CMP PT_IO PT_ADR PT_MESS N_ALL NTWK);
BIND		T51_NE1 = UPLIT(CD_RAM_VAL NTWK);

BIND	T51_ES = PLIT(	T51_E1);
BIND	T51_NES = PLIT(	T51_NE1);


BIND		T52_E1 = UPLIT(PT_RAM_CAC CD_IO CD_CMP CD_HIT PT_IO PT_ADR PT_CAC PT_MESS N_ALL NTWK);
BIND		T52_NE1 = UPLIT(PT_RAM_CAC NTWK);

BIND	T52_ES = PLIT(	T52_E1);
BIND	T52_NES = PLIT(	T52_NE1);


BIND		T53_E1 = UPLIT(BUS_PAR BUS_ALL BUS_MUX NTWK);
BIND		T53_NE1 = UPLIT(BUS_PAR NTWK);

BIND	T53_ES = PLIT(	T53_E1);
BIND	T53_NES = PLIT(	T53_NE1);


BIND		T54_E1 = UPLIT(APR DBM_APR DBM_SEL_APR NTWK);
BIND		T54_NE1 = UPLIT(APR DBM_APR DBM_SEL_APR NTWK);

BIND	T54_ES = PLIT(	T54_E1);
BIND	T54_NES = PLIT(	T54_NE1);


BIND		T55_E1 = UPLIT(APR_EN DBM_APR_EN DBM_SEL_APR_EN APR NTWK);
BIND		T55_NE1 = UPLIT(APR_EN DBM_APR_EN DBM_SEL_APR_EN NTWK);

BIND	T55_ES = PLIT(	T55_E1);
BIND	T55_NES = PLIT(	T55_NE1);


BIND		T56_E1 = UPLIT(PT_PAR PT_PAR_GEN PAR_ERR BUS_T BUS_R BUS_PAR NTWK);
BIND		T56_NE1 = UPLIT(PT_PAR PT_PAR_GEN NTWK);

BIND	T56_ES = PLIT(	T56_E1);
BIND	T56_NES = PLIT(	T56_NE1);


BIND		T57_E1 = UPLIT(PT_RAM_PAR PT_PAR PT_PAR_GEN PAR_ERR BUS_T BUS_R BUS_PAR NTWK);
BIND		T57_NE1 = UPLIT(PT_RAM_PAR PT_PAR PT_PAR_GEN NTWK);

BIND	T57_ES = PLIT(	T57_E1);
BIND	T57_NES = PLIT(	T57_NE1);


BIND		T58_E1 = UPLIT(CD_PAR PAR_ERR N_ALL PT_IO PT_CAC CD_IO CD_CMP CD_HIT PT_MESS NTWK);
BIND		T58_NE1 = UPLIT(CD_PAR NTWK);

BIND	T58_ES = PLIT(	T58_E1);
BIND	T58_NES = PLIT(	T58_NE1);


BIND		T59_E1 = UPLIT(CD_RAM_PAR CD_PAR PAR_ERR N_ALL PT_IO PT_CAC CD_IO CD_CMP CD_HIT PT_MESS NTWK);
BIND		T59_NE1 = UPLIT(CD_RAM_PAR NTWK);

BIND	T59_ES = PLIT(	T59_E1);
BIND	T59_NES = PLIT(	T59_NE1);


BIND		T60_E1 = UPLIT(PXCT PXCT_MUX DBM_VMA DBM_SEL_VMA SPEC_PXCT_EN SPEC_PXCT_OFF NTWK);
BIND		T60_NE1 = UPLIT(PXCT PXCT_MUX DBM_VMA DBM_SEL_VMA SPEC_PXCT_EN SPEC_PXCT_OFF NTWK);

BIND	T60_ES = PLIT(	T60_E1);
BIND	T60_NES = PLIT(	T60_NE1);


BIND		T61_E1 = UPLIT(PXCT PXCT_MUX_DPE SPEC_PXCT_EN SPEC_PXCT_OFF NTWK);
BIND		T61_NE1 = UPLIT(PXCT PXCT_MUX_DPE SPEC_PXCT_EN SPEC_PXCT_OFF NTWK);

BIND	T61_ES = PLIT(	T61_E1);
BIND	T61_NES = PLIT(	T61_NE1);


BIND		T62_E1 = UPLIT(SCAD_A SC_EN SC_SIGN SCADA_SN SCADA_SEL_SN NTWK);
BIND		T62_NE1 = UPLIT(SCAD_A SC_EN SC_SIGN SCADA_SN SCADA_SEL_SN NTWK);

BIND	T62_ES = PLIT(	T62_E1);
BIND	T62_NES = PLIT(	T62_NE1);


BIND		T63_E1 = UPLIT(FE_SIGN FE_EN SCAD_A_DEC SCADA_SN SCADA_SEL_SN NTWK);
BIND		T63_NE1 = UPLIT(FE_SIGN FE_EN NTWK);

BIND	T63_ES = PLIT(	T63_E1);
BIND	T63_NES = PLIT(	T63_NE1);


BIND		T64_E1 = UPLIT(MSEC DBM_MSEC NTWK);
BIND		T64_NE1 = UPLIT(MSEC DBM_MSEC NTWK);

BIND	T64_ES = PLIT(	T64_E1);
BIND	T64_NES = PLIT(	T64_NE1);


BIND		T65_E1 = UPLIT(MSEC_FREQ DBM_MSEC NTWK);
BIND		T65_NE1 = UPLIT(MSEC_FREQ DBM_MSEC NTWK);

BIND	T65_ES = PLIT(	T65_E1);

BIND	T65_NES = PLIT(	T65_NE1);
GLOBAL BIND ES_TBL = UPLIT(  T1_ES,
		T2_ES,
		T3_ES,
		T4_ES,
		T5_ES,
		T6_ES,
		T7_ES,
		T8_ES,
		T9_ES,
		T10_ES,
		T11_ES,
		T12_ES,
		T13_ES,
		T14_ES,
		T15_ES,
		T16_ES,
		T17_ES,
		T18_ES,
		T19_ES,
		T20_ES,
		T21_ES,
		T22_ES,
		T23_ES,
		T24_ES,
		T25_ES,
		T26_ES,
		T27_ES,
		T28_ES,
		T29_ES,
		T30_ES,
		T31_ES,
		T32_ES,
		T33_ES,
		T34_ES,
		T35_ES,
		T36_ES,
		T37_ES,
		T38_ES,
		T39_ES,
		T40_ES,
		T41_ES,
		T42_ES,
		T43_ES,
		T44_ES,
		T45_ES,
		T46_ES,
		T47_ES,
		T48_ES,
		T49_ES,
		T50_ES,
		T51_ES,
		T52_ES,
		T53_ES,
		T54_ES,
		T55_ES,
		T56_ES,
		T57_ES,
		T58_ES,
		T59_ES,
		T60_ES,
		T61_ES,
		T62_ES,
		T63_ES,
		T64_ES,
		T65_ES);

GLOBAL BIND NES_TBL = UPLIT(  T1_NES,
		T2_NES,
		T3_NES,
		T4_NES,
		T5_NES,
		T6_NES,
		T7_NES,
		T8_NES,
		T9_NES,
		T10_NES,
		T11_NES,
		T12_NES,
		T13_NES,
		T14_NES,
		T15_NES,
		T16_NES,
		T17_NES,
		T18_NES,
		T19_NES,
		T20_NES,
		T21_NES,
		T22_NES,
		T23_NES,
		T24_NES,
		T25_NES,
		T26_NES,
		T27_NES,
		T28_NES,
		T29_NES,
		T30_NES,
		T31_NES,
		T32_NES,
		T33_NES,
		T34_NES,
		T35_NES,
		T36_NES,
		T37_NES,
		T38_NES,
		T39_NES,
		T40_NES,
		T41_NES,
		T42_NES,
		T43_NES,
		T44_NES,
		T45_NES,
		T46_NES,
		T47_NES,
		T48_NES,
		T49_NES,
		T50_NES,
		T51_NES,
		T52_NES,
		T53_NES,
		T54_NES,
		T55_NES,
		T56_NES,
		T57_NES,
		T58_NES,
		T59_NES,
		T60_NES,
		T61_NES,
		T62_NES,
		T63_NES,
		T64_NES,
		T65_NES);

EXTERNAL ROUTINE
	TST1,
	TST2,
	TST3,
	TST4,
	TST5,
	TST6,
	TST7,
	TST8,
	TST9,
	TST10,
	TST11,
	TST12,
	TST13,
	TST14,
	TST15,
	TST16,
	TST17,
	TST18,
	TST19,
	TST20,
	TST21,
	TST22,
	TST23,
	TST24,
	TST25,
	TST26,
	TST27,
	TST28,
	TST29,
	TST30,
	TST31,
	TST32,
	TST33,
	TST34,
	TST35,
	TST36,
	TST37,
	TST38,
	TST39,
	TST40,
	TST41,
	TST42,
	TST43,
	TST44,
	TST45,
	TST46,
	TST47,
	TST48,
	TST49,
	TST50,
	TST51,
	TST52,
	TST53,
	TST54,
	TST55,
	TST56,
	TST57,
	TST58,
	TST59,
	TST60,
	TST61,
	TST62,
	TST63,
	TST64,
	TST65;


GLOBAL BIND TEST_DISP = PLIT(   TST1,
				TST2,
				TST3,
				TST4,
				TST5,
				TST6,
				TST7,
				TST8,
				TST9,
				TST10,
				TST11,
				TST12,
				TST13,
				TST14,
				TST15,
				TST16,
				TST17,
				TST18,
				TST19,
				TST20,
				TST21,
				TST22,
				TST23,
				TST24,
				TST25,
				TST26,
				TST27,
				TST28,
				TST29,
				TST30,
				TST31,
				TST32,
				TST33,
				TST34,
				TST35,
				TST36,
				TST37,
				TST38,
				TST39,
				TST40,
				TST41,
				TST42,
				TST43,
				TST44,
				TST45,
				TST46,
				TST47,
				TST48,
				TST49,
				TST50,
				TST51,
				TST52,
				TST53,
				TST54,
				TST55,
				TST56,
				TST57,
				TST58,
				TST59,
				TST60,
				TST61,
				TST62,
				TST63,
				TST64,
				TST65);
GLOBAL LITERAL MAXTEST = 65;

GLOBAL
	TESTS_FAILED: BITVECTOR[MAXTEST];

GLOBAL
	NET_FAULTS: BITVECTOR[MAXNETS];

END
ELUDOM