*--------1---------2---------3---------4---------5---------6---------7--

      subroutine SPLDATA

* initialize BCS
*----------------------------------
      include './Include/bcs.inc'

* initialize DST variables
*----------------------------------
      include './Include/dstdata.inc'

* initialize NTUPLE variables
*---------------------------------- 
      include './Include/ntdata.inc'

* initialize SPACAL variables
*----------------------------------
      include './Include/spldata.inc'

* initialize user variables
*----------------------------------
      integer NSCLP, NSCLR
      integer NCOLP, NCOLR, CIND

      integer ICLTYP, NCLMAX
      real EM, XM, YM, ZM, RM, RCLCUT
      real TCUT, ZMIN, ZMAX

      parameter (NCLMAX = 1000, RCLCUT = 10.)
      parameter (TCUT = 80., ZMIN = -170., ZMAX = -150.)

      real ECL(NCLMAX), XCL(NCLMAX),
     +     YCL(NCLMAX), ZCL(NCLMAX), RCL(NCLMAX)

      integer NSIET, NWORDS, BCOPY(146)

* event processing
*----------------------------------
      NSEL = 0

      do I = 1, NSELMAX
        ESEL(I) = 0.
        XSEL(I) = 0.
        YSEL(I) = 0.
        ZSEL(I) = 0.
        RSEL(I) = 0.
      end do

      do I = 1, 25
        LIET(I) = 0
      end do

      SPLFOUND = .FALSE.

      if ((SPLFIL.eq.0).or.NONSENSE) return

* SCLP and SCLR bank access
*----------------------------------
      NSCLP = NLINK('SCLP', 0)
      NSCLR = NLINK('SCLR', 0)

      if ((NSCLP.gt.0).and.(NSCLR.gt.0)) then

        NCOLP = IW(NSCLP + 1)
        NCOLR = IW(NSCLR + 1)

        NSEL = IW(NSCLP + 2)

        if (NSEL.le.NCLCUT) then

          if (NSEL.gt.NCLMAX) NSEL = NCLMAX

* loop over all clusters
*----------------------------------
          do I = 1, NSEL

            CIND  = NCOLP*(I-1) + NSCLP + 2

            ICLTYP = IW(CIND + 1)
            RM = RW(CIND + 2)

            CIND = NCOLR*(I-1) + NSCLR + 2

            XM = RW(CIND + 1)
            YM = RW(CIND + 2)
            ZM = RW(CIND + 3)
            EM = RW(CIND + 4)

            if ((ICLTYP.eq.1).and.
     +          (RM.lt.RCLCUT).and.
     +          (abs(XM).lt.TCUT).and.
     +          (abs(YM).lt.TCUT).and.
     +          (EM.gt.ECLCUT).and.
     +          (ZM.gt.ZMIN).and.
     +          (ZM.lt.ZMAX)) then

              SPLFOUND = .TRUE.

              XCL(I) = XM
              YCL(I) = YM
              ZCL(I) = ZM
              ECL(I) = EM
	      RCL(I) = RM
            end if
          end do
        end if
      end if
 
* descending energy ordering
*----------------------------------
      do I = 1, NSEL
        do J = (I + 1), NSEL
          if (ECL(J).gt.ECL(I)) then
            EM = ECL(I)
            XM = XCL(I)
            YM = YCL(I)
            ZM = ZCL(I)
	    RM = RCL(I)

            ECL(I) = ECL(J)
            XCL(I) = XCL(J)
            YCL(I) = YCL(J)
            ZCL(I) = ZCL(J)
            RCL(I) = RCL(J)

            ECL(J) = EM
            XCL(J) = XM
            YCL(J) = YM
            ZCL(J) = ZM
	    RCL(J) = RM
          end if
        end do
      end do

* final bookkeeping
*----------------------------------
      do I = 1, NSEL
        ESEL(I) = ECL(I)
        XSEL(I) = XCL(I)
        YSEL(I) = YCL(I)
        ZSEL(I) = ZCL(I)
	RSEL(I) = RCL(I)
      end do

* SPACAL topological data
* for 2 GeV energy threshold
*----------------------------------
      NSIET = NLINK('SIET', 0)
      if (NSIET.gt.0) then

        NWORDS = IW(NSIET + 1)
	if (NWORDS.gt.73) NWORDS = 73

        do I = 1, NWORDS
	  J = 2 * I - 1
          K = 2 * I
	  BCOPY(J) = IBITS(IW(NSIET + I),  0, 16)
	  BCOPY(K) = IBITS(IW(NSIET + I), 16, 16)
	end do

* my own mapping of the LIET bits:
* 1=00, 2=01, 3=02, 4=03,  5=04
* 6=10, 7=11, 8=12, 9=13, 10=14
*
*            . . .
*
* 21=40, 22=41, 23=42, 24=43, 25=44
*----------------------------------
        LIET(1)  = BCOPY(49)
        LIET(2)  = BCOPY(50)
        LIET(3)  = BCOPY(45)
        LIET(4)  = BCOPY(46)
        LIET(5)  = BCOPY(41)
        LIET(6)  = BCOPY(42)
        LIET(7)  = BCOPY(37)
        LIET(8)  = BCOPY(38)
        LIET(9)  = BCOPY(33)
        LIET(10) = BCOPY(34)
        LIET(11) = BCOPY(27)
        LIET(12) = BCOPY(28)
        LIET(13) = BCOPY(26)
        LIET(14) = BCOPY(30)
        LIET(15) = BCOPY(29)
        LIET(16) = BCOPY(40)
        LIET(17) = BCOPY(35)
        LIET(18) = BCOPY(36)
        LIET(19) = BCOPY(31)
        LIET(20) = BCOPY(32)
        LIET(21) = BCOPY(47)
        LIET(22) = BCOPY(48)
        LIET(23) = BCOPY(43)
        LIET(24) = BCOPY(44)
        LIET(25) = BCOPY(39)

      end if

* flag for further calculations
*----------------------------------
      if ((SPLFIL.eq.1).and.(.not.SPLFOUND)) NONSENSE = .TRUE.

      return
      end