/*****************************************************
 * grph2/udpack/udcntr.f
 ****************************************************/
/* 
 *      SUBROUTINE UDCNTR(Z,MX,NX,NY)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UDCNTR(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/udpack/udcntz.f
 ****************************************************/
/* 
 *      SUBROUTINE UDCNTZ(Z,MX,NX,NY,IBR,NBR2)
 *      REAL      Z(MX,*)
 *      INTEGER   IBR(NBR2)
 */
      SUBROUTINE UDCNTZ(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
          INTEGER (NBR2) IBR
          INTEGER NBR2
      )

/*****************************************************
 * grph2/udpack/udgcla.f
 ****************************************************/
/* 
 *      SUBROUTINE UDGCLA(XMIN,XMAX,DX)
 */
      SUBROUTINE UDGCLA(
          REAL XMIN
          REAL XMAX
          REAL DX
      )

/*****************************************************
 * grph2/udpack/udgclb.f
 ****************************************************/
/* 
 *      SUBROUTINE UDGCLB(Z,MX,NX,NY,DX)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UDGCLB(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
          REAL DX
      )

/*****************************************************
 * grph2/udpack/udiclv.f
 ****************************************************/
/* 
 *      SUBROUTINE UDICLV
 */
      SUBROUTINE UDICLV(
      )

/* 
 *      ENTRY UDSCLV(ZLEV,INDX,ITYP,CLV,HL)
 *      CHARACTER CLV*(*)
 */
      SUBROUTINE UDSCLV(
          REAL ZLEV
          INTEGER INDX
          INTEGER ITYP
          CHARACTER*(*) CLV
          REAL HL
      )

/* 
 *      ENTRY UDQCLV(ZLEV,INDX,ITYP,CLV,HL,NLEV)
 *      CHARACTER CLV*(*)
 */
      SUBROUTINE UDQCLV(
          REAL ZLEV
          INTEGER INDX
          INTEGER ITYP
          CHARACTER*(*) CLV
          REAL HL
          INTEGER NLEV
      )

/* 
 *      ENTRY UDQCLN(NLEV)
 */
      SUBROUTINE UDQCLN(
          INTEGER NLEV
      )

/* 
 *      ENTRY UDDCLV(ZLEV)
 */
      SUBROUTINE UDDCLV(
          REAL ZLEV
      )

/* 
 *      ENTRY UDSCLZ(LSET)
 *      LOGICAL   LSET
 */
      SUBROUTINE UDSCLZ(
          LOGICAL LSET
      )

/* 
 *      ENTRY UDQCLZ(LSET)
 *      LOGICAL   LSET
 */
      SUBROUTINE UDQCLZ(
          LOGICAL LSET
      )

/*****************************************************
 * grph2/udpack/rudlev.f
 ****************************************************/
/* 
 *      REAL FUNCTION RUDLEV(NLEV)
 */
      REAL FUNCTION RUDLEV(
          INTEGER NLEV
      )

/*****************************************************
 * grph2/udpack/udline.f
 ****************************************************/
/* 
 *      SUBROUTINE UDLINE(Z,MX,KX,KY,KK,CX,LOPEN,IBR)
 *      REAL      Z(MX,*)
 *      LOGICAL   LOPEN
 *      INTEGER   IBR(*)
 */
      SUBROUTINE UDLINE(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER KX
          INTEGER KY
          INTEGER KK
          REAL CX
          LOGICAL LOPEN
          INTEGER (*) IBR
      )

/*****************************************************
 * grph2/udpack/uduxuy.f
 ****************************************************/
/* 
 *      SUBROUTINE UDUXUY(Z,MX,IX,IY,K,CX,UX,UY)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UDUXUY(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER IX
          INTEGER IY
          INTEGER K
          REAL CX
          REAL UX
          REAL UY
      )

/*****************************************************
 * grph2/udpack/udgrdn.f
 ****************************************************/
/* 
 *      SUBROUTINE UDGRDN(MODE,IX,IY,K,JX,JY,JK)
 *      INTEGER JX(0:3),JY(0:3),JK(0:3)
 */
      SUBROUTINE UDGRDN(
          INTEGER MODE
          INTEGER IX
          INTEGER IY
          INTEGER K
          INTEGER (0:3) JX
          INTEGER (0:3) JY
          INTEGER (0:3) JK
      )

/*****************************************************
 * grph2/udpack/rudval.f
 ****************************************************/
/* 
 *      REAL FUNCTION RUDVAL(ZZ,CZ)
 */
      REAL FUNCTION RUDVAL(
          REAL ZZ
          REAL CZ
      )

/*****************************************************
 * grph2/udpack/udbset.f
 ****************************************************/
/* 
 *      SUBROUTINE UDBSET(I,J,K,L,IBR)
 *      INTEGER   IBR(NBR,0:*)
 */
      SUBROUTINE UDBSET(
          INTEGER I
          INTEGER J
          INTEGER K
          INTEGER L
          INTEGER (NBR,0:*) IBR
      )

/*****************************************************
 * grph2/udpack/udbclr.f
 ****************************************************/
/* 
 *      SUBROUTINE UDBCLR(I,J,K,L,IBR)
 *      INTEGER   IBR(NBR,0:*)
 */
      SUBROUTINE UDBCLR(
          INTEGER I
          INTEGER J
          INTEGER K
          INTEGER L
          INTEGER (NBR,0:*) IBR
      )

/*****************************************************
 * grph2/udpack/ludchk.f
 ****************************************************/
/* 
 *      LOGICAL FUNCTION LUDCHK(I,J,K,L,IBR)
 *      INTEGER   IBR(NBR,0:*)
 */
      LOGICAL FUNCTION LUDCHK(
          INTEGER I
          INTEGER J
          INTEGER K
          INTEGER L
          INTEGER (NBR,0:*) IBR
      )

/*****************************************************
 * grph2/udpack/udiclr.f
 ****************************************************/
/* 
 *      SUBROUTINE UDICLR(IX,N)
 *      INTEGER   IX(*)
 */
      SUBROUTINE UDICLR(
          INTEGER (*) IX
          INTEGER N
      )

/*****************************************************
 * grph2/udpack/udlabl.f
 ****************************************************/
/* 
 *      SUBROUTINE UDLABL(VAL,CVAL)
 *      CHARACTER CVAL*(*),CFMT*(*)
 */
      SUBROUTINE UDLABL(
          REAL VAL
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY UDSFMT(CFMT)
 *      CHARACTER CVAL*(*),CFMT*(*)
 */
      SUBROUTINE UDSFMT(
          CHARACTER*(*) CFMT
      )

/* 
 *      ENTRY UDQFMT(CFMT)
 *      CHARACTER CVAL*(*),CFMT*(*)
 */
      SUBROUTINE UDQFMT(
          CHARACTER*(*) CFMT
      )

/*****************************************************
 * grph2/udpack/udpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UDPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UDPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UDPSTX(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/udpack/udpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UDPQNP(NCP)
 */
      SUBROUTINE UDPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UDPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UDPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDPQIT(IDX, ITP)
 */
      SUBROUTINE UDPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UDPQVL(IDX, IPARA)
 */
      SUBROUTINE UDPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UDPSVL(IDX, IPARA)
 */
      SUBROUTINE UDPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UDPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/udpack/udiget.f
 ****************************************************/
/* 
 *      SUBROUTINE UDIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UDISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UDISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/udpack/udiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UDIQNP(NCP)
 */
      SUBROUTINE UDIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UDIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UDIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDIQVL(IDX, IPARA)
 */
      SUBROUTINE UDIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UDISVL(IDX, IPARA)
 */
      SUBROUTINE UDISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UDIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/udpack/udlget.f
 ****************************************************/
/* 
 *      SUBROUTINE UDLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA, LP
 */
      SUBROUTINE UDLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UDLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA, LP
 */
      SUBROUTINE UDLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UDLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA, LP
 */
      SUBROUTINE UDLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/udpack/udlqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UDLQNP(NCP)
 *      INTEGER   NCP
 */
      SUBROUTINE UDLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UDLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UDLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UDLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UDLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UDLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UDLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/udpack/udrget.f
 ****************************************************/
/* 
 *      SUBROUTINE UDRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UDRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UDRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/udpack/udrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UDRQNP(NCP)
 */
      SUBROUTINE UDRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UDRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UDRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UDRQVL(IDX, RPARA)
 */
      SUBROUTINE UDRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UDRSVL(IDX, RPARA)
 */
      SUBROUTINE UDRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UDRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UDRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ugpack/ugvect.f
 ****************************************************/
/* 
 *      SUBROUTINE UGVECT(U,MU,V,MV,NX,NY)
 */
      SUBROUTINE UGVECT(
          REAL U
          INTEGER MU
          REAL V
          INTEGER MV
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/ugpack/ugunit.f
 ****************************************************/
/* 
 *      SUBROUTINE UGUNIT
 */
      SUBROUTINE UGUNIT(
      )

/*****************************************************
 * grph2/ugpack/ugsut.f
 ****************************************************/
/* 
 *      SUBROUTINE UGSUT(CSIDE,CTTL)
 *      CHARACTER CSIDE*(*),CTTL*(*)
 */
      SUBROUTINE UGSUT(
          CHARACTER*(*) CSIDE
          CHARACTER*(*) CTTL
      )

/* 
 *      ENTRY UGDUT
 */
      SUBROUTINE UGDUT(
      )

/*****************************************************
 * grph2/ugpack/ugpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UGPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UGPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UGPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ugpack/ugpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UGPQNP(NCP)
 */
      SUBROUTINE UGPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UGPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UGPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGPQIT(IDX, ITP)
 */
      SUBROUTINE UGPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UGPQVL(IDX, IPARA)
 */
      SUBROUTINE UGPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UGPSVL(IDX, IPARA)
 */
      SUBROUTINE UGPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UGPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ugpack/ugiget.f
 ****************************************************/
/* 
 *      SUBROUTINE UGIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UGISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UGISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ugpack/ugiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UGIQNP(NCP)
 */
      SUBROUTINE UGIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UGIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UGIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGIQVL(IDX, IPARA)
 */
      SUBROUTINE UGIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UGISVL(IDX, IPARA)
 */
      SUBROUTINE UGISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UGIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ugpack/uglget.f
 ****************************************************/
/* 
 *      SUBROUTINE UGLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UGLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UGLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UGLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UGLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UGLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/ugpack/uglqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UGLQNP(NCP)
 */
      SUBROUTINE UGLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UGLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UGLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UGLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UGLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UGLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UGLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ugpack/ugrget.f
 ****************************************************/
/* 
 *      SUBROUTINE UGRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UGRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UGRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/ugpack/ugrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UGRQNP(NCP)
 */
      SUBROUTINE UGRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UGRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UGRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UGRQVL(IDX, RPARA)
 */
      SUBROUTINE UGRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UGRSVL(IDX, RPARA)
 */
      SUBROUTINE UGRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UGRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UGRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uwpack/uwsgxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UWSGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UWSGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UWQGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UWQGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UWSGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UWSGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UWQGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UWQGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UWSGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UWSGXZ(
          LOGICAL LSETX
      )

/* 
 *      ENTRY UWQGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UWQGXZ(
          LOGICAL LSETX
      )

/*****************************************************
 * grph2/uwpack/uwsgya.f
 ****************************************************/
/* 
 *      SUBROUTINE UWSGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UWSGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UWQGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UWQGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UWSGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UWSGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UWQGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UWQGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UWSGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UWSGYZ(
          LOGICAL LSETY
      )

/* 
 *      ENTRY UWQGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UWQGYZ(
          LOGICAL LSETY
      )

/*****************************************************
 * grph2/uwpack/uwqgxi.f
 ****************************************************/
/* 
 *      SUBROUTINE UWQGXI(UX,IUX,FRAC)
 */
      SUBROUTINE UWQGXI(
          REAL UX
          INTEGER IUX
          REAL FRAC
      )

/* 
 *      ENTRY UWIGXI
 */
      SUBROUTINE UWIGXI(
      )

/*****************************************************
 * grph2/uwpack/uwqgyi.f
 ****************************************************/
/* 
 *      SUBROUTINE UWQGYI(UY,IUY,FRAC)
 */
      SUBROUTINE UWQGYI(
          REAL UY
          INTEGER IUY
          REAL FRAC
      )

/* 
 *      ENTRY UWIGYI
 */
      SUBROUTINE UWIGYI(
      )

/*****************************************************
 * grph2/uwpack/ruwgx.f
 ****************************************************/
/* 
 *      REAL FUNCTION RUWGX(IX)
 */
      REAL FUNCTION RUWGX(
          INTEGER IX
      )

/*****************************************************
 * grph2/uwpack/ruwgy.f
 ****************************************************/
/* 
 *      REAL FUNCTION RUWGY(IY)
 */
      REAL FUNCTION RUWGY(
          INTEGER IY
      )

/*****************************************************
 * grph2/uwpack/iuwgx.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION IUWGX(UX)
 */
      INTEGER FUNCTION IUWGX(
          REAL UX
      )

/*****************************************************
 * grph2/uwpack/iuwgy.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION IUWGY(UY)
 */
      INTEGER FUNCTION IUWGY(
          REAL UY
      )

/*****************************************************
 * grph2/uwpack/uwdflt.f
 ****************************************************/
/* 
 *      SUBROUTINE UWDFLT(NX,NY)
 */
      SUBROUTINE UWDFLT(
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/uxpack/uxptmz.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPTMZ(UX,N,UPY,ROFFX,RTICK,INDEX)
 *      REAL      UX(*)
 */
      SUBROUTINE UXPTMZ(
          REAL (*) UX
          INTEGER N
          REAL UPY
          REAL ROFFX
          REAL RTICK
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uxpack/uxplba.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPLBA(UX,CH,NC,N,UPY,ROFFX,RSIZE,IROTA,ICENT,INDEX)
 *      REAL      UX(*)
 *      CHARACTER CH(*)*(*)
 */
      SUBROUTINE UXPLBA(
          REAL (*) UX
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
          REAL UPY
          REAL ROFFX
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uxpack/uxplbb.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPLBB(UX,CH,NC,N,UPY,ROFFX,RSIZE,IROTA,ICENT,INDEX,
 *     +                  RBTWN,LBOUND,LBMSG)
 *      REAL      UX(*)
 *      CHARACTER CH(*)*(*)
 *      LOGICAL   LBOUND,LBMSG
 */
      SUBROUTINE UXPLBB(
          REAL (*) UX
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
          REAL UPY
          REAL ROFFX
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
          REAL RBTWN
          LOGICAL LBOUND
          LOGICAL LBMSG
      )

/*****************************************************
 * grph2/uxpack/uxsaxz.f
 ****************************************************/
/* 
 *      SUBROUTINE UXSAXZ(CSIDE,ROFFX)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UXSAXZ(
          CHARACTER*1 CSIDE
          REAL ROFFX
      )

/*****************************************************
 * grph2/uxpack/uxsaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE UXSAXS(CSIDE)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UXSAXS(
          CHARACTER*1 CSIDE
      )

/*****************************************************
 * grph2/uxpack/uxsoff.f
 ****************************************************/
/* 
 *      SUBROUTINE UXSOFF
 */
      SUBROUTINE UXSOFF(
      )

/* 
 *      ENTRY UXROFF
 */
      SUBROUTINE UXROFF(
      )

/*****************************************************
 * grph2/uxpack/uxpaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPAXS(CSIDE,ISLCT)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UXPAXS(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
      )

/*****************************************************
 * grph2/uxpack/uxptmk.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPTMK(CSIDE,ISLCT,UX,N)
 *      CHARACTER CSIDE*1
 *      REAL      UX(*)
 */
      SUBROUTINE UXPTMK(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UX
          INTEGER N
      )

/*****************************************************
 * grph2/uxpack/uxplbl.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPLBL(CSIDE,ISLCT,UX,CH,NC,N)
 *      CHARACTER CSIDE*1,CH(*)*(*)
 *      REAL      UX(*)
 */
      SUBROUTINE UXPLBL(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UX
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
      )

/*****************************************************
 * grph2/uxpack/uxpnum.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPNUM(CSIDE,ISLCT,UX,N)
 *      CHARACTER CSIDE*1
 *      REAL      UX(*)
 */
      SUBROUTINE UXPNUM(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UX
          INTEGER N
      )

/*****************************************************
 * grph2/uxpack/uxpttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UXPTTL(CSIDE,ISLCT,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UXPTTL(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uxpack/uxaxlb.f
 ****************************************************/
/* 
 *      SUBROUTINE UXAXLB(CSIDE,UX1,N1,UX2,CH,NC,N2)
 *      CHARACTER CSIDE*1,CH(*)*(*)
 *      REAL      UX1(*),UX2(*)
 */
      SUBROUTINE UXAXLB(
          CHARACTER*1 CSIDE
          REAL (*) UX1
          INTEGER N1
          REAL (*) UX2
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N2
      )

/*****************************************************
 * grph2/uxpack/uxaxnm.f
 ****************************************************/
/* 
 *      SUBROUTINE UXAXNM(CSIDE,UX1,N1,UX2,N2)
 *      CHARACTER CSIDE*1
 *      REAL      UX1(*),UX2(*)
 */
      SUBROUTINE UXAXNM(
          CHARACTER*1 CSIDE
          REAL (*) UX1
          INTEGER N1
          REAL (*) UX2
          INTEGER N2
      )

/*****************************************************
 * grph2/uxpack/uxaxdv.f
 ****************************************************/
/* 
 *      SUBROUTINE UXAXDV(CSIDE,DX1,DX2)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UXAXDV(
          CHARACTER*1 CSIDE
          REAL DX1
          REAL DX2
      )

/*****************************************************
 * grph2/uxpack/uxmttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UXMTTL(CSIDE,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UXMTTL(
          CHARACTER*1 CSIDE
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uxpack/uxsttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UXSTTL(CSIDE,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UXSTTL(
          CHARACTER*1 CSIDE
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uxpack/luxchk.f
 ****************************************************/
/* 
 *      LOGICAL FUNCTION LUXCHK(CSIDE)
 *      CHARACTER CSIDE*(*)
 */
      LOGICAL FUNCTION LUXCHK(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uxpack/uxsfmt.f
 ****************************************************/
/* 
 *      SUBROUTINE UXSFMT(CFMT)
 *      CHARACTER CFMT*(*)
 */
      SUBROUTINE UXSFMT(
          CHARACTER*(*) CFMT
      )

/* 
 *      ENTRY UXQFMT(CFMT)
 *      CHARACTER CFMT*(*)
 */
      SUBROUTINE UXQFMT(
          CHARACTER*(*) CFMT
      )

/*****************************************************
 * grph2/uypack/uyptmz.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPTMZ(UY,N,UPX,ROFFY,RTICK,INDEX)
 *      REAL      UY(*)
 */
      SUBROUTINE UYPTMZ(
          REAL (*) UY
          INTEGER N
          REAL UPX
          REAL ROFFY
          REAL RTICK
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uypack/uyplba.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPLBA(UY,CH,NC,N,UPX,ROFFY,RSIZE,IROTA,ICENT,INDEX)
 *      REAL      UY(*)
 *      CHARACTER CH(*)*(*)
 */
      SUBROUTINE UYPLBA(
          REAL (*) UY
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
          REAL UPX
          REAL ROFFY
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uypack/uyplbb.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPLBB(UY,CH,NC,N,UPX,ROFFY,RSIZE,IROTA,ICENT,INDEX,
 *     +                  RBTWN,LBOUND,LBMSG)
 *      REAL      UY(*)
 *      CHARACTER CH(*)*(*)
 *      LOGICAL   LBOUND,LBMSG
 */
      SUBROUTINE UYPLBB(
          REAL (*) UY
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
          REAL UPX
          REAL ROFFY
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
          REAL RBTWN
          LOGICAL LBOUND
          LOGICAL LBMSG
      )

/*****************************************************
 * grph2/uypack/uysaxz.f
 ****************************************************/
/* 
 *      SUBROUTINE UYSAXZ(CSIDE,ROFFY)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UYSAXZ(
          CHARACTER*1 CSIDE
          REAL ROFFY
      )

/*****************************************************
 * grph2/uypack/uysaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE UYSAXS(CSIDE)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UYSAXS(
          CHARACTER*1 CSIDE
      )

/*****************************************************
 * grph2/uypack/uysoff.f
 ****************************************************/
/* 
 *      SUBROUTINE UYSOFF
 */
      SUBROUTINE UYSOFF(
      )

/* 
 *      ENTRY UYROFF
 */
      SUBROUTINE UYROFF(
      )

/*****************************************************
 * grph2/uypack/uypaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPAXS(CSIDE,ISLCT)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UYPAXS(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
      )

/*****************************************************
 * grph2/uypack/uyptmk.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPTMK(CSIDE,ISLCT,UY,N)
 *      CHARACTER CSIDE*1
 *      REAL      UY(*)
 */
      SUBROUTINE UYPTMK(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UY
          INTEGER N
      )

/*****************************************************
 * grph2/uypack/uyplbl.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPLBL(CSIDE,ISLCT,UY,CH,NC,N)
 *      CHARACTER CSIDE*1,CH(*)*(*)
 *      REAL      UY(*)
 */
      SUBROUTINE UYPLBL(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UY
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
      )

/*****************************************************
 * grph2/uypack/uypnum.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPNUM(CSIDE,ISLCT,UY,N)
 *      CHARACTER CSIDE*1
 *      REAL      UY(*)
 */
      SUBROUTINE UYPNUM(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          REAL (*) UY
          INTEGER N
      )

/*****************************************************
 * grph2/uypack/uypttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UYPTTL(CSIDE,ISLCT,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UYPTTL(
          CHARACTER*1 CSIDE
          INTEGER ISLCT
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uypack/uyaxlb.f
 ****************************************************/
/* 
 *      SUBROUTINE UYAXLB(CSIDE,UY1,N1,UY2,CH,NC,N2)
 *      CHARACTER CSIDE*1,CH(*)*(*)
 *      REAL      UY1(*),UY2(*)
 */
      SUBROUTINE UYAXLB(
          CHARACTER*1 CSIDE
          REAL (*) UY1
          INTEGER N1
          REAL (*) UY2
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N2
      )

/*****************************************************
 * grph2/uypack/uyaxnm.f
 ****************************************************/
/* 
 *      SUBROUTINE UYAXNM(CSIDE,UY1,N1,UY2,N2)
 *      CHARACTER CSIDE*1
 *      REAL      UY1(*),UY2(*)
 */
      SUBROUTINE UYAXNM(
          CHARACTER*1 CSIDE
          REAL (*) UY1
          INTEGER N1
          REAL (*) UY2
          INTEGER N2
      )

/*****************************************************
 * grph2/uypack/uyaxdv.f
 ****************************************************/
/* 
 *      SUBROUTINE UYAXDV(CSIDE,DY1,DY2)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UYAXDV(
          CHARACTER*1 CSIDE
          REAL DY1
          REAL DY2
      )

/*****************************************************
 * grph2/uypack/uymttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UYMTTL(CSIDE,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UYMTTL(
          CHARACTER*1 CSIDE
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uypack/uysttl.f
 ****************************************************/
/* 
 *      SUBROUTINE UYSTTL(CSIDE,CTTL,PX)
 *      CHARACTER CSIDE*1,CTTL*(*)
 */
      SUBROUTINE UYSTTL(
          CHARACTER*1 CSIDE
          CHARACTER*(*) CTTL
          REAL PX
      )

/*****************************************************
 * grph2/uypack/luychk.f
 ****************************************************/
/* 
 *      LOGICAL FUNCTION LUYCHK(CSIDE)
 *      CHARACTER CSIDE*(*)
 */
      LOGICAL FUNCTION LUYCHK(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uypack/uysfmt.f
 ****************************************************/
/* 
 *      SUBROUTINE UYSFMT(CFMT)
 *      CHARACTER CFMT*(*)
 */
      SUBROUTINE UYSFMT(
          CHARACTER*(*) CFMT
      )

/* 
 *      ENTRY UYQFMT(CFMT)
 *      CHARACTER CFMT*(*)
 */
      SUBROUTINE UYQFMT(
          CHARACTER*(*) CFMT
      )

/*****************************************************
 * grph2/uzpack/uzpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UZPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UZPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UZPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uzpack/uzpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UZPQNP(NCP)
 */
      SUBROUTINE UZPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UZPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UZPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZPQIT(IDX, ITP)
 */
      SUBROUTINE UZPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UZPQVL(IDX, IPARA)
 */
      SUBROUTINE UZPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UZPSVL(IDX, IPARA)
 */
      SUBROUTINE UZPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UZPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uzpack/uzinit.f
 ****************************************************/
/* 
 *      SUBROUTINE UZINIT
 */
      SUBROUTINE UZINIT(
      )

/*****************************************************
 * grph2/uzpack/uzfact.f
 ****************************************************/
/* 
 *      SUBROUTINE UZFACT(RFACT)
 */
      SUBROUTINE UZFACT(
          REAL RFACT
      )

/*****************************************************
 * grph2/uzpack/uzcget.f
 ****************************************************/
/* 
 *      SUBROUTINE UZCGET(CP,CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE UZCGET(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/* 
 *      ENTRY UZCSET(CP,CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE UZCSET(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/* 
 *      ENTRY UZCSTX(CP, CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE UZCSTX(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/*****************************************************
 * grph2/uzpack/uzcqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UZCQNP(NCP)
 */
      SUBROUTINE UZCQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UZCQID(CP, IDX)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UZCQCP(IDX,CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZCQCL(IDX,CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZCQVL(IDX,CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCQVL(
          INTEGER IDX
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY UZCSVL(IDX,CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCSVL(
          INTEGER IDX
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY UZCQIN(CP, IN)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE UZCQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/* 
 *      ENTRY UZCSAV(IU)
 */
      SUBROUTINE UZCSAV(
          INTEGER IU
      )

/* 
 *      ENTRY UZCRST(IU)
 */
      SUBROUTINE UZCRST(
          INTEGER IU
      )

/*****************************************************
 * grph2/uzpack/uziget.f
 ****************************************************/
/* 
 *      SUBROUTINE UZIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UZISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UZISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uzpack/uziqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UZIQNP(NCP)
 */
      SUBROUTINE UZIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UZIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UZIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZIQVL(IDX, IPARA)
 */
      SUBROUTINE UZIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UZISVL(IDX, IPARA)
 */
      SUBROUTINE UZISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UZIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/* 
 *      ENTRY UZISAV(IU)
 */
      SUBROUTINE UZISAV(
          INTEGER IU
      )

/* 
 *      ENTRY UZIRST(IU)
 */
      SUBROUTINE UZIRST(
          INTEGER IU
      )

/*****************************************************
 * grph2/uzpack/uzlget.f
 ****************************************************/
/* 
 *      SUBROUTINE UZLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UZLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UZLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UZLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UZLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UZLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/uzpack/uzlqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UZLQNP(NCP)
 */
      SUBROUTINE UZLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UZLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UZLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UZLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UZLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UZLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UZLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/* 
 *      ENTRY UZLSAV(IU)
 */
      SUBROUTINE UZLSAV(
          INTEGER IU
      )

/* 
 *      ENTRY UZLRST(IU)
 */
      SUBROUTINE UZLRST(
          INTEGER IU
      )

/*****************************************************
 * grph2/uzpack/uzrget.f
 ****************************************************/
/* 
 *      SUBROUTINE UZRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UZRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UZRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/uzpack/uzrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UZRQNP(NCP)
 */
      SUBROUTINE UZRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UZRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UZRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UZRQVL(IDX, RPARA)
 */
      SUBROUTINE UZRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UZRSVL(IDX, RPARA)
 */
      SUBROUTINE UZRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UZRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UZRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/* 
 *      ENTRY UZRSAV(IU)
 */
      SUBROUTINE UZRSAV(
          INTEGER IU
      )

/* 
 *      ENTRY UZRRST(IU)
 */
      SUBROUTINE UZRRST(
          INTEGER IU
      )

/*****************************************************
 * grph2/uzpack/uzpsav.f
 ****************************************************/
/* 
 *      SUBROUTINE UZPSAV
 */
      SUBROUTINE UZPSAV(
      )

/* 
 *      ENTRY UZPRST
 */
      SUBROUTINE UZPRST(
      )

/*****************************************************
 * grph2/ulpack/ulxlog.f
 ****************************************************/
/* 
 *      SUBROUTINE ULXLOG ( CSIDE, NLBL, NTICKS )
 *      CHARACTER CH(MAXL)*16,CHR*8,CFMT*16,CSGI,CSIDE
 */
      SUBROUTINE ULXLOG(
          CHARACTER*(*) CSIDE
          INTEGER NLBL
          INTEGER NTICKS
      )

/*****************************************************
 * grph2/ulpack/ulylog.f
 ****************************************************/
/* 
 *      SUBROUTINE ULYLOG ( CSIDE, NLBL, NTICKS )
 *      CHARACTER CH(MAXL)*16,CHR*8,CFMT*16,CSGI,CSIDE
 */
      SUBROUTINE ULYLOG(
          CHARACTER*(*) CSIDE
          INTEGER NLBL
          INTEGER NTICKS
      )

/*****************************************************
 * grph2/ulpack/ulxlbl.f
 ****************************************************/
/* 
 *      SUBROUTINE ULXLBL ( BL, NBL, INUM )
 *      DIMENSION XBL(10,4),NXBL(4),BL(*)
 */
      SUBROUTINE ULXLBL(
          REAL (*) BL
          INTEGER NBL
          INTEGER INUM
      )

/* 
 *      ENTRY ULSXBL ( BL, NBL )
 *      DIMENSION XBL(10,4),NXBL(4),BL(*)
 */
      SUBROUTINE ULSXBL(
          REAL (*) BL
          INTEGER NBL
      )

/* 
 *      ENTRY ULQXBL ( BL, NBL )
 *      DIMENSION XBL(10,4),NXBL(4),BL(*)
 */
      SUBROUTINE ULQXBL(
          REAL (*) BL
          INTEGER NBL
      )

/*****************************************************
 * grph2/ulpack/ulylbl.f
 ****************************************************/
/* 
 *      SUBROUTINE ULYLBL ( BL, NBL, INUM )
 *      DIMENSION YBL(10,4),NYBL(4),BL(*)
 */
      SUBROUTINE ULYLBL(
          REAL (*) BL
          INTEGER NBL
          INTEGER INUM
      )

/* 
 *      ENTRY ULSYBL ( BL, NBL )
 *      DIMENSION YBL(10,4),NYBL(4),BL(*)
 */
      SUBROUTINE ULSYBL(
          REAL (*) BL
          INTEGER NBL
      )

/* 
 *      ENTRY ULQYBL ( BL, NBL )
 *      DIMENSION YBL(10,4),NYBL(4),BL(*)
 */
      SUBROUTINE ULQYBL(
          REAL (*) BL
          INTEGER NBL
      )

/*****************************************************
 * grph2/ulpack/ulpget.f
 ****************************************************/
/* 
 *      SUBROUTINE ULPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY ULPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY ULPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ulpack/ulpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ULPQNP(NCP)
 */
      SUBROUTINE ULPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY ULPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY ULPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULPQIT(IDX, ITP)
 */
      SUBROUTINE ULPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY ULPQVL(IDX, IPARA)
 */
      SUBROUTINE ULPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY ULPSVL(IDX, IPARA)
 */
      SUBROUTINE ULPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY ULPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ulpack/uliget.f
 ****************************************************/
/* 
 *      SUBROUTINE ULIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY ULISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY ULISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ulpack/uliqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ULIQNP(NCP)
 */
      SUBROUTINE ULIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY ULIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY ULIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULIQVL(IDX, IPARA)
 */
      SUBROUTINE ULIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY ULISVL(IDX, IPARA)
 */
      SUBROUTINE ULISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY ULIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ulpack/ullget.f
 ****************************************************/
/* 
 *      SUBROUTINE ULLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ULLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY ULLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ULLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY ULLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ULLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/ulpack/ullqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ULLQNP(NCP)
 */
      SUBROUTINE ULLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY ULLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY ULLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ULLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY ULLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ULLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY ULLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ulpack/ulrget.f
 ****************************************************/
/* 
 *      SUBROUTINE ULRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY ULRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY ULRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/ulpack/ulrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ULRQNP(NCP)
 */
      SUBROUTINE ULRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY ULRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY ULRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY ULRQVL(IDX, RPARA)
 */
      SUBROUTINE ULRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY ULRSVL(IDX, RPARA)
 */
      SUBROUTINE ULRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY ULRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ULRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ulpack/ulxsfm.f
 ****************************************************/
/* 
 *      SUBROUTINE ULXSFM ( CXFMT )
 *      CHARACTER CXFMT*(*)
 */
      SUBROUTINE ULXSFM(
          CHARACTER*(*) CXFMT
      )

/* 
 *      ENTRY ULXQFM ( CXFMT )
 *      CHARACTER CXFMT*(*)
 */
      SUBROUTINE ULXQFM(
          CHARACTER*(*) CXFMT
      )

/*****************************************************
 * grph2/ulpack/ulysfm.f
 ****************************************************/
/* 
 *      SUBROUTINE ULYSFM ( CYFMT )
 *      CHARACTER CYFMT*(*)
 */
      SUBROUTINE ULYSFM(
          CHARACTER*(*) CYFMT
      )

/* 
 *      ENTRY ULYQFM ( CYFMT )
 *      CHARACTER CYFMT*(*)
 */
      SUBROUTINE ULYQFM(
          CHARACTER*(*) CYFMT
      )

/*****************************************************
 * grph2/ucpack/nucchr.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION NUCCHR(CS,ND)
 *      CHARACTER CS*(*)
 */
      INTEGER FUNCTION NUCCHR(
          CHARACTER*(*) CS
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/nucday.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION NUCDAY(CS,ND)
 *      CHARACTER CS*(*)
 */
      INTEGER FUNCTION NUCDAY(
          CHARACTER*(*) CS
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UCPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UCPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UCPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ucpack/ucpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UCPQNP(NCP)
 */
      SUBROUTINE UCPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UCPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UCPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCPQIT(IDX, ITP)
 */
      SUBROUTINE UCPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UCPQVL(IDX, IPARA)
 */
      SUBROUTINE UCPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UCPSVL(IDX, IPARA)
 */
      SUBROUTINE UCPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UCPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ucpack/ucxacl.f
 ****************************************************/
/* 
 *      SUBROUTINE UCXACL(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCXACL(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucxady.f
 ****************************************************/
/* 
 *      SUBROUTINE UCXADY(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCXADY(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucxamn.f
 ****************************************************/
/* 
 *      SUBROUTINE UCXAMN(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCXAMN(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucxayr.f
 ****************************************************/
/* 
 *      SUBROUTINE UCXAYR(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCXAYR(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucyacl.f
 ****************************************************/
/* 
 *      SUBROUTINE UCYACL(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCYACL(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucyady.f
 ****************************************************/
/* 
 *      SUBROUTINE UCYADY(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCYADY(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucyamn.f
 ****************************************************/
/* 
 *      SUBROUTINE UCYAMN(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCYAMN(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/ucyayr.f
 ****************************************************/
/* 
 *      SUBROUTINE UCYAYR(CSIDE,JD0,ND)
 *      CHARACTER CSIDE*1
 */
      SUBROUTINE UCYAYR(
          CHARACTER*1 CSIDE
          INTEGER JD0
          INTEGER ND
      )

/*****************************************************
 * grph2/ucpack/uciget.f
 ****************************************************/
/* 
 *      SUBROUTINE UCIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UCISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UCISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/ucpack/uciqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UCIQNP(NCP)
 */
      SUBROUTINE UCIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UCIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UCIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCIQVL(IDX, IPARA)
 */
      SUBROUTINE UCIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UCISVL(IDX, IPARA)
 */
      SUBROUTINE UCISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UCIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ucpack/uclget.f
 ****************************************************/
/* 
 *      SUBROUTINE UCLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UCLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UCLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UCLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UCLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UCLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/ucpack/uclqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UCLQNP(NCP)
 */
      SUBROUTINE UCLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UCLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UCLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UCLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UCLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UCLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UCLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/ucpack/ucrget.f
 ****************************************************/
/* 
 *      SUBROUTINE UCRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UCRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UCRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/ucpack/ucrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UCRQNP(NCP)
 */
      SUBROUTINE UCRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UCRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UCRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UCRQVL(IDX, RPARA)
 */
      SUBROUTINE UCRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UCRSVL(IDX, RPARA)
 */
      SUBROUTINE UCRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UCRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UCRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uepack/uetone.f
 ****************************************************/
/* 
 *      SUBROUTINE UETONE(Z,MX,NX,NY)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UETONE(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/uepack/uetonf.f
 ****************************************************/
/* 
 *      SUBROUTINE UETONF (Z,MX,NX,NY)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UETONF(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/uepack/uetonc.f
 ****************************************************/
/* 
 *      SUBROUTINE UETONC (Z,MX,NX,NY)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UETONC(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
      )

/*****************************************************
 * grph2/uepack/uezchk.f
 ****************************************************/
/* 
 *      SUBROUTINE UEZCHK(Z,MX,NX,NY,CNAME,ISTAT)
 *      REAL      Z(MX,*)
 *      CHARACTER CNAME*(*)
 */
      SUBROUTINE UEZCHK(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
          CHARACTER*(*) CNAME
          INTEGER ISTAT
      )

/*****************************************************
 * grph2/uepack/uegtla.f
 ****************************************************/
/* 
 *      SUBROUTINE UEGTLA(XMIN,XMAX,DX)
 */
      SUBROUTINE UEGTLA(
          REAL XMIN
          REAL XMAX
          REAL DX
      )

/*****************************************************
 * grph2/uepack/uegtlb.f
 ****************************************************/
/* 
 *      SUBROUTINE UEGTLB(Z,MX,NX,NY,DX)
 *      REAL      Z(MX,*)
 */
      SUBROUTINE UEGTLB(
          REAL (MX,*) Z
          INTEGER MX
          INTEGER NX
          INTEGER NY
          REAL DX
      )

/*****************************************************
 * grph2/uepack/ueitlv.f
 ****************************************************/
/* 
 *      SUBROUTINE UEITLV
 */
      SUBROUTINE UEITLV(
      )

/* 
 *      ENTRY UESTLV(TLEV1,TLEV2,IPAT)
 */
      SUBROUTINE UESTLV(
          REAL TLEV1
          REAL TLEV2
          INTEGER IPAT
      )

/* 
 *      ENTRY UEQTLV(TLEV1,TLEV2,IPAT,ITON)
 */
      SUBROUTINE UEQTLV(
          REAL TLEV1
          REAL TLEV2
          INTEGER IPAT
          INTEGER ITON
      )

/* 
 *      ENTRY UEQNTL(NTON)
 */
      SUBROUTINE UEQNTL(
          INTEGER NTON
      )

/* 
 *      ENTRY UESTLZ(LSET)
 *      LOGICAL   LSET
 */
      SUBROUTINE UESTLZ(
          LOGICAL LSET
      )

/* 
 *      ENTRY UEQTLZ(LSET)
 *      LOGICAL   LSET
 */
      SUBROUTINE UEQTLZ(
          LOGICAL LSET
      )

/*****************************************************
 * grph2/uepack/uestln.f
 ****************************************************/
/* 
 *      SUBROUTINE UESTLN(TLEVN,IPATN,NTON)
 *      REAL      TLEVN(*)
 *      INTEGER   IPATN(*)
 */
      SUBROUTINE UESTLN(
          REAL (*) TLEVN
          INTEGER (*) IPATN
          INTEGER NTON
      )

/*****************************************************
 * grph2/uepack/iueton.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION IUETON(ZLEV)
 */
      INTEGER FUNCTION IUETON(
          REAL ZLEV
      )

/*****************************************************
 * grph2/uepack/uearea.f
 ****************************************************/
/* 
 *      SUBROUTINE UEAREA(XP,YP,ZP,VLVM,AX,AY,NP,NI,NG)
 *      REAL     XP(4),YP(4),ZP(4),VLVM(2),AX(*),AY(*)
 *      INTEGER  NP(2),NI(2)
 */
      SUBROUTINE UEAREA(
          REAL (4) XP
          REAL (4) YP
          REAL (4) ZP
          REAL (2) VLVM
          REAL (*) AX
          REAL (*) AY
          INTEGER (2) NP
          INTEGER (2) NI
          INTEGER NG
      )

/* 
 *      ENTRY UEAINT
 */
      SUBROUTINE UEAINT(
      )

/*****************************************************
 * grph2/uepack/uepget.f
 ****************************************************/
/* 
 *      SUBROUTINE UEPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UEPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UEPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uepack/uepqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UEPQNP(NCP)
 */
      SUBROUTINE UEPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UEPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UEPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UEPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UEPQIT(IDX, ITP)
 */
      SUBROUTINE UEPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UEPQVL(IDX, IPARA)
 */
      SUBROUTINE UEPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UEPSVL(IDX, IPARA)
 */
      SUBROUTINE UEPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UEPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uepack/ueiget.f
 ****************************************************/
/* 
 *      SUBROUTINE UEIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UEISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UEISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uepack/ueiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UEIQNP(NCP)
 */
      SUBROUTINE UEIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UEIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UEIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UEIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UEIQVL(IDX, IPARA)
 */
      SUBROUTINE UEIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UEISVL(IDX, IPARA)
 */
      SUBROUTINE UEISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UEIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UEIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uepack/uelget.f
 ****************************************************/
/* 
 *      SUBROUTINE UELGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UELGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UELSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UELSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UELSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UELSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/uepack/uelqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UELQNP(NCP)
 */
      SUBROUTINE UELQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UELQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UELQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UELQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UELQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UELQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UELQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UELQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UELQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UELSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UELSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UELQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UELQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uepack/uerget.f
 ****************************************************/
/* 
 *      SUBROUTINE UERGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UERSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UERSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/uepack/uerqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UERQNP(NCP)
 */
      SUBROUTINE UERQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UERQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UERQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UERQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UERQVL(IDX, RPARA)
 */
      SUBROUTINE UERQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UERSVL(IDX, RPARA)
 */
      SUBROUTINE UERSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UERQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UERQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/usgrph.f
 ****************************************************/
/* 
 *      SUBROUTINE USGRPH(N, X, Y)
 *      REAL      X(*), Y(*)
 */
      SUBROUTINE USGRPH(
          INTEGER N
          REAL (*) X
          REAL (*) Y
      )

/*****************************************************
 * grph2/uspack/ussttl.f
 ****************************************************/
/* 
 *      SUBROUTINE USSTTL(CXTTL, CXUNIT, CYTTL, CYUNIT)
 *      CHARACTER*(*) CXTTL, CXUNIT, CYTTL, CYUNIT
 */
      SUBROUTINE USSTTL(
          CHARACTER*(*) CXTTL
          CHARACTER*(*) CXUNIT
          CHARACTER*(*) CYTTL
          CHARACTER*(*) CYUNIT
      )

/*****************************************************
 * grph2/uspack/usspnt.f
 ****************************************************/
/* 
 *      SUBROUTINE USSPNT(N, X, Y)
 *      REAL  X(*), Y(*)
 */
      SUBROUTINE USSPNT(
          INTEGER N
          REAL (*) X
          REAL (*) Y
      )

/*****************************************************
 * grph2/uspack/uspfit.f
 ****************************************************/
/* 
 *      SUBROUTINE USPFIT
 */
      SUBROUTINE USPFIT(
      )

/*****************************************************
 * grph2/uspack/usdaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE USDAXS
 */
      SUBROUTINE USDAXS(
      )

/*****************************************************
 * grph2/uspack/usinit.f
 ****************************************************/
/* 
 *      SUBROUTINE USINIT
 */
      SUBROUTINE USINIT(
      )

/*****************************************************
 * grph2/uspack/uspget.f
 ****************************************************/
/* 
 *      SUBROUTINE USPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uspack/uspqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE USPQNP(NCP)
 */
      SUBROUTINE USPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY USPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY USPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USPQIT(IDX, ITP)
 */
      SUBROUTINE USPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY USPQVL(IDX, IPARA)
 */
      SUBROUTINE USPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY USPSVL(IDX, IPARA)
 */
      SUBROUTINE USPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY USPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/uscget.f
 ****************************************************/
/* 
 *      SUBROUTINE USCGET(CP,CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE USCGET(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/* 
 *      ENTRY USCSET(CP,CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE USCSET(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/* 
 *      ENTRY USCSTX(CP, CPARA)
 *      CHARACTER CP*(*), CPARA*(*)
 */
      SUBROUTINE USCSTX(
          CHARACTER*(*) CP
          CHARACTER*(*) CPARA
      )

/*****************************************************
 * grph2/uspack/uscqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE USCQNP(NCP)
 */
      SUBROUTINE USCQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY USCQID(CP, IDX)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY USCQCP(IDX,CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USCQCL(IDX,CP)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USCQVL(IDX,CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCQVL(
          INTEGER IDX
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY USCSVL(IDX,CVAL)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCSVL(
          INTEGER IDX
          CHARACTER*(*) CVAL
      )

/* 
 *      ENTRY USCQIN(CP, IN)
 *      CHARACTER CP*(*), CVAL*(*)
 */
      SUBROUTINE USCQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/usurdl.f
 ****************************************************/
/* 
 *      SUBROUTINE USURDL(UMIN, UMAX, VMIN, VMAX)
 */
      SUBROUTINE USURDL(
          REAL UMIN
          REAL UMAX
          REAL VMIN
          REAL VMAX
      )

/*****************************************************
 * grph2/uspack/usxaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE USXAXS(CSIDE)
 *      CHARACTER  CSIDE*(*), CS*1
 */
      SUBROUTINE USXAXS(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uspack/usyaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE USYAXS(CSIDE)
 *      CHARACTER  CSIDE*(*), CS*1
 */
      SUBROUTINE USYAXS(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uspack/ususcu.f
 ****************************************************/
/* 
 *      SUBROUTINE USUSCU(CAXIS, UMIN,  UMAX,  VMIN,  VMAX,  MODE)
 *      CHARACTER   CAXIS*1,  CFMT*8
 */
      SUBROUTINE USUSCU(
          CHARACTER*1 CAXIS
          REAL UMIN
          REAL UMAX
          REAL VMIN
          REAL VMAX
          INTEGER MODE
      )

/*****************************************************
 * grph2/uspack/ususcl.f
 ****************************************************/
/* 
 *      SUBROUTINE USUSCL(CAXIS, UMIN,  UMAX,  VMIN,  VMAX)
 *      CHARACTER   CAXIS*1, CP*8
 */
      SUBROUTINE USUSCL(
          CHARACTER*1 CAXIS
          REAL UMIN
          REAL UMAX
          REAL VMIN
          REAL VMAX
      )

/*****************************************************
 * grph2/uspack/usxaxu.f
 ****************************************************/
/* 
 *      SUBROUTINE USXAXU(CXS)
 *      CHARACTER CXS*(*), CXFMT*8, CXUNIT*32
 */
      SUBROUTINE USXAXU(
          CHARACTER*(*) CXS
      )

/*****************************************************
 * grph2/uspack/usxaxl.f
 ****************************************************/
/* 
 *      SUBROUTINE USXAXL(CXS)
 *      CHARACTER CXS*(*), CUNIT*32, CXSUB*32, CSBLBL*32, CPOS*1, CP*8
 */
      SUBROUTINE USXAXL(
          CHARACTER*(*) CXS
      )

/*****************************************************
 * grph2/uspack/usyaxu.f
 ****************************************************/
/* 
 *      SUBROUTINE USYAXU(CYS)
 *      CHARACTER CYS*(*), CYFMT*8, CYUNIT*32
 */
      SUBROUTINE USYAXU(
          CHARACTER*(*) CYS
      )

/*****************************************************
 * grph2/uspack/usyaxl.f
 ****************************************************/
/* 
 *      SUBROUTINE USYAXL(CYS)
 *      CHARACTER CYS*(*), CUNIT*32, CYSUB*32, CSBLBL*32, CPOS*1, CP*8
 */
      SUBROUTINE USYAXL(
          CHARACTER*(*) CYS
      )

/*****************************************************
 * grph2/uspack/usxsub.f
 ****************************************************/
/* 
 *      SUBROUTINE USXSUB(CXA, CYA, CLABEL, RLBL)
 *      CHARACTER CLABEL*(*), CXS*1, CYS*1, CXA*1, CYA*1, CP*8
 */
      SUBROUTINE USXSUB(
          CHARACTER*1 CXA
          CHARACTER*1 CYA
          CHARACTER*(*) CLABEL
          REAL RLBL
      )

/*****************************************************
 * grph2/uspack/usysub.f
 ****************************************************/
/* 
 *      SUBROUTINE USYSUB(CYA, CXA, CLABEL, RLBL)
 *      CHARACTER CLABEL*(*), CXS*1, CYS*1, CXA*1, CYA*1, CP*8
 */
      SUBROUTINE USYSUB(
          CHARACTER*1 CYA
          CHARACTER*1 CXA
          CHARACTER*(*) CLABEL
          REAL RLBL
      )

/*****************************************************
 * grph2/uspack/csblbl.f
 ****************************************************/
/* 
 *      FUNCTION CSBLBL(UFAC, UOFF, CUNIT)
 *      CHARACTER CSBLBL*(*), CUNIT*(*), CSUB*32, CBLKT*2,
 */
      nil CSBLBL(
          REAL UFAC
          REAL UOFF
          CHARACTER*(*) CUNIT
      )

/*****************************************************
 * grph2/uspack/uschvl.f
 ****************************************************/
/* 
 *      SUBROUTINE USCHVL(X, CHX)
 *      REAL X
 *      CHARACTER CHX*(*), CFMT*16, CVAL*16, CEXP*8, CEXP2*8, CSGI*1
 */
      SUBROUTINE USCHVL(
          REAL X
          CHARACTER*(*) CHX
      )

/*****************************************************
 * grph2/uspack/usxoff.f
 ****************************************************/
/* 
 *      SUBROUTINE USXOFF(CXS)
 *      CHARACTER*1 CXS, CP*8
 */
      SUBROUTINE USXOFF(
          CHARACTER*1 CXS
      )

/*****************************************************
 * grph2/uspack/usyoff.f
 ****************************************************/
/* 
 *      SUBROUTINE USYOFF(CYS)
 *      CHARACTER*1 CYS, CP*8
 */
      SUBROUTINE USYOFF(
          CHARACTER*1 CYS
      )

/*****************************************************
 * grph2/uspack/uszdgt.f
 ****************************************************/
/* 
 *      SUBROUTINE USZDGT(UMIN,  UMAX,  DUL,   MAXDGT,
 *     #                  UOFF,  UFACT, NDGT,  LDGT)
 */
      SUBROUTINE USZDGT(
          REAL UMIN
          REAL UMAX
          REAL DUL
          INTEGER MAXDGT
          REAL UOFF
          REAL UFACT
          INTEGER NDGT
          INTEGER LDGT
      )

/*****************************************************
 * grph2/uspack/uswapz.f
 ****************************************************/
/* 
 *      SUBROUTINE USWAPZ(X1, X2, N)
 *      REAL X1(N), X2(N)
 */
      SUBROUTINE USWAPZ(
          REAL (N) X1
          REAL (N) X2
          INTEGER N
      )

/*****************************************************
 * grph2/uspack/usurdt.f
 ****************************************************/
/* 
 *      SUBROUTINE USURDT(UMIN, UMAX, VMIN, VMAX, DUT)
 */
      SUBROUTINE USURDT(
          REAL UMIN
          REAL UMAX
          REAL VMIN
          REAL VMAX
          REAL DUT
      )

/*****************************************************
 * grph2/uspack/usaxcl.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXCL(CSIDE, JD0, CTYPE, ND)
 *      CHARACTER  CSIDE*(*), CTYPE*(*), CS, CT
 */
      SUBROUTINE USAXCL(
          CHARACTER*(*) CSIDE
          INTEGER JD0
          CHARACTER*(*) CTYPE
          INTEGER ND
      )

/*****************************************************
 * grph2/uspack/usaxdv.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXDV(CSIDE, DTICK, DLBL)
 *      CHARACTER  CSIDE*(*), CS
 */
      SUBROUTINE USAXDV(
          CHARACTER*(*) CSIDE
          REAL DTICK
          REAL DLBL
      )

/*****************************************************
 * grph2/uspack/usaxlb.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXLB(CSIDE, DTICK, N1, DLABEL, CH, NC, N2)
 *      CHARACTER  CSIDE*(*), CS, CH(*)*(*)
 *      REAL       DTICK(N1), DLABEL(N2), DTZ(N0),DLZ(N0)
 */
      SUBROUTINE USAXLB(
          CHARACTER*(*) CSIDE
          REAL (N1) DTICK
          INTEGER N1
          REAL (N2) DLABEL
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N2
      )

/*****************************************************
 * grph2/uspack/usaxlg.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXLG(CSIDE, NLBL, NTICKS)
 *      CHARACTER  CSIDE*(*), CS
 */
      SUBROUTINE USAXLG(
          CHARACTER*(*) CSIDE
          INTEGER NLBL
          INTEGER NTICKS
      )

/*****************************************************
 * grph2/uspack/usaxnm.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXNM(CSIDE, DTICK, N1, DLABEL, N2)
 *      CHARACTER  CSIDE*(*), CS
 *      REAL       DTICK(N1), DLABEL(N2), DTZ(N0),DLZ(N0)
 */
      SUBROUTINE USAXNM(
          CHARACTER*(*) CSIDE
          REAL (N1) DTICK
          INTEGER N1
          REAL (N2) DLABEL
          INTEGER N2
      )

/*****************************************************
 * grph2/uspack/usaxsc.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXSC(CSIDE)
 *      CHARACTER  CSIDE*(*), CS, CP*8
 */
      SUBROUTINE USAXSC(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uspack/usiget.f
 ****************************************************/
/* 
 *      SUBROUTINE USIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uspack/usiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE USIQNP(NCP)
 */
      SUBROUTINE USIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY USIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY USIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USIQVL(IDX, IPARA)
 */
      SUBROUTINE USIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY USISVL(IDX, IPARA)
 */
      SUBROUTINE USISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY USIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/uslget.f
 ****************************************************/
/* 
 *      SUBROUTINE USLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE USLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY USLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE USLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY USLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE USLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/uspack/uslqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE USLQNP(NCP)
 */
      SUBROUTINE USLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY USLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY USLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE USLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY USLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE USLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY USLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/uspaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE USPAXS(CSIDE, ISLCT)
 *      CHARACTER  CSIDE*(*), CS
 */
      SUBROUTINE USPAXS(
          CHARACTER*(*) CSIDE
          INTEGER ISLCT
      )

/*****************************************************
 * grph2/uspack/usplbl.f
 ****************************************************/
/* 
 *      SUBROUTINE USPLBL(CSIDE, ISLCT, POS, CH, NC, N)
 *      CHARACTER  CSIDE*(*), CH(*)*(*), CS
 *      REAL       POS(N)
 */
      SUBROUTINE USPLBL(
          CHARACTER*(*) CSIDE
          INTEGER ISLCT
          REAL (N) POS
          CHARACTER*(*) (*) CH
          INTEGER NC
          INTEGER N
      )

/*****************************************************
 * grph2/uspack/uspnum.f
 ****************************************************/
/* 
 *      SUBROUTINE USPNUM(CSIDE, ISLCT, POS, N)
 *      CHARACTER  CSIDE*(*), CS
 *      REAL       POS(N)
 */
      SUBROUTINE USPNUM(
          CHARACTER*(*) CSIDE
          INTEGER ISLCT
          REAL (N) POS
          INTEGER N
      )

/*****************************************************
 * grph2/uspack/usptmk.f
 ****************************************************/
/* 
 *      SUBROUTINE USPTMK(CSIDE, ISLCT, POS, N)
 *      CHARACTER  CSIDE*(*), CS
 *      REAL       POS(N)
 */
      SUBROUTINE USPTMK(
          CHARACTER*(*) CSIDE
          INTEGER ISLCT
          REAL (N) POS
          INTEGER N
      )

/*****************************************************
 * grph2/uspack/uspttl.f
 ****************************************************/
/* 
 *      SUBROUTINE USPTTL(CSIDE, ISLCT, CTTL, POS)
 *      CHARACTER  CSIDE*(*), CTTL*(*), CS
 */
      SUBROUTINE USPTTL(
          CHARACTER*(*) CSIDE
          INTEGER ISLCT
          CHARACTER*(*) CTTL
          REAL POS
      )

/*****************************************************
 * grph2/uspack/usrget.f
 ****************************************************/
/* 
 *      SUBROUTINE USRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY USRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY USRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/uspack/usrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE USRQNP(NCP)
 */
      SUBROUTINE USRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY USRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY USRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY USRQVL(IDX, RPARA)
 */
      SUBROUTINE USRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY USRSVL(IDX, RPARA)
 */
      SUBROUTINE USRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY USRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uspack/ussaxs.f
 ****************************************************/
/* 
 *      SUBROUTINE USSAXS(CSIDE)
 *      CHARACTER  CSIDE*(*), CS
 */
      SUBROUTINE USSAXS(
          CHARACTER*(*) CSIDE
      )

/*****************************************************
 * grph2/uspack/usxinz.f
 ****************************************************/
/* 
 *      SUBROUTINE USXINZ(CSA, FACA, OFFA)
 *      CHARACTER CSA, CS, CPOS
 */
      SUBROUTINE USXINZ(
          CHARACTER*(*) CSA
          REAL FACA
          REAL OFFA
      )

/* 
 *      ENTRY USXTLZ
 */
      SUBROUTINE USXTLZ(
      )

/*****************************************************
 * grph2/uspack/usyinz.f
 ****************************************************/
/* 
 *      SUBROUTINE USYINZ(CSA, FACA, OFFA)
 *      CHARACTER CSA, CS, CPOS
 */
      SUBROUTINE USYINZ(
          CHARACTER*(*) CSA
          REAL FACA
          REAL OFFA
      )

/* 
 *      ENTRY USYTLZ
 */
      SUBROUTINE USYTLZ(
      )

/*****************************************************
 * grph2/grpack/gropn.f
 ****************************************************/
/* 
 *      SUBROUTINE GROPN(IWS)
 */
      SUBROUTINE GROPN(
          INTEGER IWS
      )

/* 
 *      ENTRY GRFRM
 */
      SUBROUTINE GRFRM(
      )

/* 
 *      ENTRY GRFIG
 */
      SUBROUTINE GRFIG(
      )

/* 
 *      ENTRY GRCLS
 */
      SUBROUTINE GRCLS(
      )

/*****************************************************
 * grph2/grpack/grinit.f
 ****************************************************/
/* 
 *      SUBROUTINE GRINIT
 */
      SUBROUTINE GRINIT(
      )

/*****************************************************
 * grph2/grpack/grsvpt.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSVPT(VXMIN, VXMAX, VYMIN, VYMAX)
 */
      SUBROUTINE GRSVPT(
          REAL VXMIN
          REAL VXMAX
          REAL VYMIN
          REAL VYMAX
      )

/*****************************************************
 * grph2/grpack/grswnd.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSWND(UXMIN, UXMAX, UYMIN, UYMAX)
 */
      SUBROUTINE GRSWND(
          REAL UXMIN
          REAL UXMAX
          REAL UYMIN
          REAL UYMAX
      )

/*****************************************************
 * grph2/grpack/grssim.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSSIM(SIMFAC, VXOFF, VYOFF)
 */
      SUBROUTINE GRSSIM(
          REAL SIMFAC
          REAL VXOFF
          REAL VYOFF
      )

/*****************************************************
 * grph2/grpack/grsmpl.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSMPL(PLX, PLY, PLROT)
 */
      SUBROUTINE GRSMPL(
          REAL PLX
          REAL PLY
          REAL PLROT
      )

/*****************************************************
 * grph2/grpack/grstxy.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSTXY(TXMIN, TXMAX, TYMIN, TYMAX)
 */
      SUBROUTINE GRSTXY(
          REAL TXMIN
          REAL TXMAX
          REAL TYMIN
          REAL TYMAX
      )

/*****************************************************
 * grph2/grpack/grstrn.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSTRN(ITR)
 */
      SUBROUTINE GRSTRN(
          INTEGER ITR
      )

/*****************************************************
 * grph2/grpack/grstrf.f
 ****************************************************/
/* 
 *      SUBROUTINE GRSTRF
 */
      SUBROUTINE GRSTRF(
      )

/*****************************************************
 * grph2/umpack/umpmap.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPMAP(CDSN)
 *      CHARACTER CDSN*(*)
 */
      SUBROUTINE UMPMAP(
          CHARACTER*(*) CDSN
      )

/*****************************************************
 * grph2/umpack/umqfnm.f
 ****************************************************/
/* 
 *      SUBROUTINE UMQFNM(CPARA,CFNAME)
 *      CHARACTER CPARA*(*),CFNAME*(*)
 */
      SUBROUTINE UMQFNM(
          CHARACTER*(*) CPARA
          CHARACTER*(*) CFNAME
      )

/*****************************************************
 * grph2/umpack/umpglb.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPGLB
 */
      SUBROUTINE UMPGLB(
      )

/*****************************************************
 * grph2/umpack/umpgrd.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPGRD
 */
      SUBROUTINE UMPGRD(
      )

/*****************************************************
 * grph2/umpack/umplim.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPLIM
 */
      SUBROUTINE UMPLIM(
      )

/*****************************************************
 * grph2/umpack/uminit.f
 ****************************************************/
/* 
 *      SUBROUTINE UMINIT
 */
      SUBROUTINE UMINIT(
      )

/*****************************************************
 * grph2/umpack/umscnt.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSCNT(XCNT, YCNT, ROT)
 */
      SUBROUTINE UMSCNT(
          REAL XCNT
          REAL YCNT
          REAL ROT
      )

/* 
 *      ENTRY UMQCNT(XCNT, YCNT, ROT)
 */
      SUBROUTINE UMQCNT(
          REAL XCNT
          REAL YCNT
          REAL ROT
      )

/*****************************************************
 * grph2/umpack/umscwd.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSCWD(XCNTR, YCNTR, R)
 */
      SUBROUTINE UMSCWD(
          REAL XCNTR
          REAL YCNTR
          REAL R
      )

/* 
 *      ENTRY UMQCWD(XCNTR, YCNTR, R)
 */
      SUBROUTINE UMQCWD(
          REAL XCNTR
          REAL YCNTR
          REAL R
      )

/*****************************************************
 * grph2/umpack/umspnt.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPNT(N, UX, UY)
 *      REAL      UX(*), UY(*)
 */
      SUBROUTINE UMSPNT(
          INTEGER N
          REAL (*) UX
          REAL (*) UY
      )

/* 
 *      ENTRY UMQPNT(N, UXA, UYA)
 */
      SUBROUTINE UMQPNT(
          INTEGER N
          REAL UXA
          REAL UYA
      )

/* 
 *      ENTRY UMQPTN(N)
 */
      SUBROUTINE UMQPTN(
          INTEGER N
      )

/* 
 *      ENTRY UMRPNT
 */
      SUBROUTINE UMRPNT(
      )

/*****************************************************
 * grph2/umpack/umpfit.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPFIT
 */
      SUBROUTINE UMPFIT(
      )

/*****************************************************
 * grph2/umpack/umpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UMPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UMPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/umpack/umpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPQNP(NCP)
 */
      SUBROUTINE UMPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UMPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UMPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMPQIT(IDX, ITP)
 */
      SUBROUTINE UMPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UMPQVL(IDX, IPARA)
 */
      SUBROUTINE UMPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UMPSVL(IDX, IPARA)
 */
      SUBROUTINE UMPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UMPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/umpack/umspct.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPCT
 */
      SUBROUTINE UMSPCT(
      )

/*****************************************************
 * grph2/umpack/umspcw.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPCW
 */
      SUBROUTINE UMSPCW(
      )

/*****************************************************
 * grph2/umpack/umspwd.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPWD
 */
      SUBROUTINE UMSPWD(
      )

/*****************************************************
 * grph2/umpack/umsppt.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPPT
 */
      SUBROUTINE UMSPPT(
      )

/*****************************************************
 * grph2/umpack/umspdf.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSPDF
 */
      SUBROUTINE UMSPDF(
      )

/*****************************************************
 * grph2/umpack/umbndc.f
 ****************************************************/
/* 
 *      SUBROUTINE UMBNDC(XMIN, XMAX, YMIN, YMAX)
 */
      SUBROUTINE UMBNDC(
          REAL XMIN
          REAL XMAX
          REAL YMIN
          REAL YMAX
      )

/*****************************************************
 * grph2/umpack/umbndp.f
 ****************************************************/
/* 
 *      SUBROUTINE UMBNDP(VXMIN, VXMAX, VYMIN, VYMAX)
 */
      SUBROUTINE UMBNDP(
          REAL VXMIN
          REAL VXMAX
          REAL VYMIN
          REAL VYMAX
      )

/*****************************************************
 * grph2/umpack/umbndr.f
 ****************************************************/
/* 
 *      SUBROUTINE UMBNDR(FUNC, FTR,
 *     +                  XMIN,  XMAX,  YMIN,  YMAX )
 */
      SUBROUTINE UMBNDR(
          REAL FUNC
          REAL FTR
          REAL XMIN
          REAL XMAX
          REAL YMIN
          REAL YMAX
      )

/*****************************************************
 * grph2/umpack/umqtxy.f
 ****************************************************/
/* 
 *      SUBROUTINE UMQTXY(TXMINZ, TXMAXZ, TYMINZ, TYMAXZ)
 */
      SUBROUTINE UMQTXY(
          REAL TXMINZ
          REAL TXMAXZ
          REAL TYMINZ
          REAL TYMAXZ
      )

/*****************************************************
 * grph2/umpack/umstvz.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSTVZ
 */
      SUBROUTINE UMSTVZ(
      )

/*****************************************************
 * grph2/umpack/umsgrd.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSGRD
 */
      SUBROUTINE UMSGRD(
      )

/*****************************************************
 * grph2/umpack/umscom.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSCOM
 */
      SUBROUTINE UMSCOM(
      )

/*****************************************************
 * grph2/umpack/umiget.f
 ****************************************************/
/* 
 *      SUBROUTINE UMIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UMISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UMISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/umpack/umiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UMIQNP(NCP)
 */
      SUBROUTINE UMIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UMIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UMIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMIQVL(IDX, IPARA)
 */
      SUBROUTINE UMIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UMISVL(IDX, IPARA)
 */
      SUBROUTINE UMISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UMIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/umpack/umlget.f
 ****************************************************/
/* 
 *      SUBROUTINE UMLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UMLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UMLSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UMLSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UMLSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UMLSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/umpack/umlqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UMLQNP(NCP)
 */
      SUBROUTINE UMLQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UMLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMLQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UMLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMLQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMLQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UMLQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UMLSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UMLSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UMLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMLQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/umpack/umrget.f
 ****************************************************/
/* 
 *      SUBROUTINE UMRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UMRSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UMRSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/umpack/umrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UMRQNP(NCP)
 */
      SUBROUTINE UMRQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UMRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UMRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UMRQVL(IDX, RPARA)
 */
      SUBROUTINE UMRQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UMRSVL(IDX, RPARA)
 */
      SUBROUTINE UMRSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UMRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UMRQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/oldsrc/ubpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UBPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UBPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UBPSET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UBPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/oldsrc/ubplu.f
 ****************************************************/
/* 
 *      SUBROUTINE UBPLU(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*)
 */
      SUBROUTINE UBPLU(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/* 
 *      ENTRY UBPLV(N,VPX,VPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*)
 */
      SUBROUTINE UBPLV(
          INTEGER N
          REAL (*) VPX
          REAL (*) VPY
      )

/* 
 *      ENTRY UBSPLT(ITYPE)
 */
      SUBROUTINE UBSPLT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UBQPLT(ITYPE)
 */
      SUBROUTINE UBQPLT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UBSPLI(INDEX)
 */
      SUBROUTINE UBSPLI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UBQPLI(INDEX)
 */
      SUBROUTINE UBQPLI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UBSPLC(CHARX)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE UBSPLC(
          CHARACTER*(*) CHARX
      )

/* 
 *      ENTRY UBQPLC(CHARX)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE UBQPLC(
          CHARACTER*(*) CHARX
      )

/* 
 *      ENTRY UBSPLS(RSIZE)
 */
      SUBROUTINE UBSPLS(
          REAL RSIZE
      )

/* 
 *      ENTRY UBQPLS(RSIZE)
 */
      SUBROUTINE UBQPLS(
          REAL RSIZE
      )

/*****************************************************
 * grph2/oldsrc/ubplzu.f
 ****************************************************/
/* 
 *      SUBROUTINE UBPLZU(N,UPX,UPY,ITYPE,INDEX,CHARX,RSIZE)
 *      REAL      UPX(*),UPY(*)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE UBPLZU(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          CHARACTER*(*) CHARX
          REAL RSIZE
      )

/*****************************************************
 * grph2/oldsrc/ubplzv.f
 ****************************************************/
/* 
 *      SUBROUTINE UBPLZV(N,VPX,VPY,ITYPE,INDEX,CHARX,RSIZE)
 *      REAL      VPX(*),VPY(*)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE UBPLZV(
          INTEGER N
          REAL (*) VPX
          REAL (*) VPY
          INTEGER ITYPE
          INTEGER INDEX
          CHARACTER*(*) CHARX
          REAL RSIZE
      )

/*****************************************************
 * grph2/oldsrc/udsgxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UDSGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UDSGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UDQGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UDQGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UDSGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UDSGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UDQGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UDQGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UDSGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UDSGXZ(
          LOGICAL LSETX
      )

/* 
 *      ENTRY UDQGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UDQGXZ(
          LOGICAL LSETX
      )

/*****************************************************
 * grph2/oldsrc/udsgya.f
 ****************************************************/
/* 
 *      SUBROUTINE UDSGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UDSGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UDQGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UDQGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UDSGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UDSGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UDQGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UDQGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UDSGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UDSGYZ(
          LOGICAL LSETY
      )

/* 
 *      ENTRY UDQGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UDQGYZ(
          LOGICAL LSETY
      )

/*****************************************************
 * grph2/oldsrc/uesgxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UESGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UESGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UEQGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UEQGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UESGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UESGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UEQGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UEQGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UESGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UESGXZ(
          LOGICAL LSETX
      )

/* 
 *      ENTRY UEQGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UEQGXZ(
          LOGICAL LSETX
      )

/*****************************************************
 * grph2/oldsrc/uesgya.f
 ****************************************************/
/* 
 *      SUBROUTINE UESGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UESGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UEQGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UEQGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UESGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UESGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UEQGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UEQGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UESGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UESGYZ(
          LOGICAL LSETY
      )

/* 
 *      ENTRY UEQGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UEQGYZ(
          LOGICAL LSETY
      )

/*****************************************************
 * grph2/oldsrc/uflnu.f
 ****************************************************/
/* 
 *      SUBROUTINE UFLNU(UX1,UY1,UX2,UY2)
 */
      SUBROUTINE UFLNU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
      )

/* 
 *      ENTRY UFLNV(VX1,VY1,VX2,VY2)
 */
      SUBROUTINE UFLNV(
          REAL VX1
          REAL VY1
          REAL VX2
          REAL VY2
      )

/* 
 *      ENTRY UFLNR(RX1,RY1,RX2,RY2)
 */
      SUBROUTINE UFLNR(
          REAL RX1
          REAL RY1
          REAL RX2
          REAL RY2
      )

/* 
 *      ENTRY UFSLNI(INDEX)
 */
      SUBROUTINE UFSLNI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UFQLNI(INDEX)
 */
      SUBROUTINE UFQLNI(
          INTEGER INDEX
      )

/*****************************************************
 * grph2/oldsrc/uflnzr.f
 ****************************************************/
/* 
 *      SUBROUTINE UFLNZR(RX1,RY1,RX2,RY2,INDEX)
 */
      SUBROUTINE UFLNZR(
          REAL RX1
          REAL RY1
          REAL RX2
          REAL RY2
          INTEGER INDEX
      )

/*****************************************************
 * grph2/oldsrc/uflnzu.f
 ****************************************************/
/* 
 *      SUBROUTINE UFLNZU(UX1,UY1,UX2,UY2,INDEX)
 */
      SUBROUTINE UFLNZU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
          INTEGER INDEX
      )

/*****************************************************
 * grph2/oldsrc/uflnzv.f
 ****************************************************/
/* 
 *      SUBROUTINE UFLNZV(VX1,VY1,VX2,VY2,INDEX)
 */
      SUBROUTINE UFLNZV(
          REAL VX1
          REAL VY1
          REAL VX2
          REAL VY2
          INTEGER INDEX
      )

/*****************************************************
 * grph2/oldsrc/ufpget.f
 ****************************************************/
/* 
 *      SUBROUTINE UFPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UFPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UFPSET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UFPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/oldsrc/ugsgxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UGSGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UGSGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UGQGXA(XP,NX)
 *      REAL      XP(*)
 */
      SUBROUTINE UGQGXA(
          REAL (*) XP
          INTEGER NX
      )

/* 
 *      ENTRY UGSGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UGSGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UGQGXB(UXMIN,UXMAX,NX)
 */
      SUBROUTINE UGQGXB(
          REAL UXMIN
          REAL UXMAX
          INTEGER NX
      )

/* 
 *      ENTRY UGSGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UGSGXZ(
          LOGICAL LSETX
      )

/* 
 *      ENTRY UGQGXZ(LSETX)
 *      LOGICAL   LSETX
 */
      SUBROUTINE UGQGXZ(
          LOGICAL LSETX
      )

/*****************************************************
 * grph2/oldsrc/ugsgya.f
 ****************************************************/
/* 
 *      SUBROUTINE UGSGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UGSGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UGQGYA(YP,NY)
 *      REAL      YP(*)
 */
      SUBROUTINE UGQGYA(
          REAL (*) YP
          INTEGER NY
      )

/* 
 *      ENTRY UGSGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UGSGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UGQGYB(UYMIN,UYMAX,NY)
 */
      SUBROUTINE UGQGYB(
          REAL UYMIN
          REAL UYMAX
          INTEGER NY
      )

/* 
 *      ENTRY UGSGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UGSGYZ(
          LOGICAL LSETY
      )

/* 
 *      ENTRY UGQGYZ(LSETY)
 *      LOGICAL   LSETY
 */
      SUBROUTINE UGQGYZ(
          LOGICAL LSETY
      )

/*****************************************************
 * grph2/oldsrc/umpout.f
 ****************************************************/
/* 
 *      SUBROUTINE UMPOUT
 */
      SUBROUTINE UMPOUT(
      )

/*****************************************************
 * grph2/oldsrc/umstrf.f
 ****************************************************/
/* 
 *      SUBROUTINE UMSTRF
 */
      SUBROUTINE UMSTRF(
      )

/*****************************************************
 * grph2/oldsrc/ussntr.f
 ****************************************************/
/* 
 *      SUBROUTINE USSNTR
 */
      SUBROUTINE USSNTR(
      )

/*****************************************************
 * grph2/oldsrc/ussvpt.f
 ****************************************************/
/* 
 *      SUBROUTINE USSVPT(VXMIN, VXMAX, VYMIN, VYMAX)
 */
      SUBROUTINE USSVPT(
          REAL VXMIN
          REAL VXMAX
          REAL VYMIN
          REAL VYMAX
      )

/*****************************************************
 * grph2/oldsrc/usswnd.f
 ****************************************************/
/* 
 *      SUBROUTINE USSWND(XMIN, XMAX, YMIN, YMAX)
 */
      SUBROUTINE USSWND(
          REAL XMIN
          REAL XMAX
          REAL YMIN
          REAL YMAX
      )

/*****************************************************
 * grph2/oldsrc/uspget.f
 ****************************************************/
/* 
 *      SUBROUTINE USPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USPSET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USISET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USRSET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USLSET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USPSTX(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USISTX(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USRSTX(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USRSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY USLSTX(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE USLSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/oldsrc/usgrpx.f
 ****************************************************/
/* 
 *      SUBROUTINE USGRPX(N, X, YMIN, YMAX)
 *      REAL      X(*)
 */
      SUBROUTINE USGRPX(
          INTEGER N
          REAL (*) X
          REAL YMIN
          REAL YMAX
      )

/*****************************************************
 * grph2/oldsrc/usgrpy.f
 ****************************************************/
/* 
 *      SUBROUTINE USGRPY(N, Y, XMIN, XMAX)
 *      REAL      Y(*)
 */
      SUBROUTINE USGRPY(
          INTEGER N
          REAL (*) Y
          REAL XMIN
          REAL XMAX
      )

/*****************************************************
 * grph2/oldsrc/ussxex.f
 ****************************************************/
/* 
 *      SUBROUTINE USSXEX(N, X)
 *      REAL      X(*)
 */
      SUBROUTINE USSXEX(
          INTEGER N
          REAL (*) X
      )

/* 
 *      ENTRY USQXEX(XMINQ, XMAXQ)
 */
      SUBROUTINE USQXEX(
          REAL XMINQ
          REAL XMAXQ
      )

/*****************************************************
 * grph2/oldsrc/ussyex.f
 ****************************************************/
/* 
 *      SUBROUTINE USSYEX(N, Y)
 *      REAL      Y(*)
 */
      SUBROUTINE USSYEX(
          INTEGER N
          REAL (*) Y
      )

/* 
 *      ENTRY USQYEX(YMINQ, YMAXQ)
 */
      SUBROUTINE USQYEX(
          REAL YMINQ
          REAL YMAXQ
      )

/*****************************************************
 * grph2/oldsrc/usaxis.f
 ****************************************************/
/* 
 *      SUBROUTINE USAXIS
 */
      SUBROUTINE USAXIS(
      )

/*****************************************************
 * grph2/oldsrc/usstrf.f
 ****************************************************/
/* 
 *      SUBROUTINE USSTRF
 */
      SUBROUTINE USSTRF(
      )

/*****************************************************
 * grph2/oldsrc/usurdu.f
 ****************************************************/
/* 
 *      SUBROUTINE USURDU(UMIN, UMAX, VMIN, VMAX)
 */
      SUBROUTINE USURDU(
          REAL UMIN
          REAL UMAX
          REAL VMIN
          REAL VMAX
      )

/* 
 *      ENTRY USQDUT(DUTQ)
 */
      SUBROUTINE USQDUT(
          REAL DUTQ
      )

/*****************************************************
 * grph2/uupack/uulin.f
 ****************************************************/
/* 
 *      SUBROUTINE UULIN(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UULIN(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uupack/uulinz.f
 ****************************************************/
/* 
 *      SUBROUTINE UULINZ(N,UPX,UPY,ITYPE,INDEX)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UULINZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uupack/uumrk.f
 ****************************************************/
/* 
 *      SUBROUTINE UUMRK(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UUMRK(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uupack/uumrkz.f
 ****************************************************/
/* 
 *      SUBROUTINE UUMRKZ(N,UPX,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UUMRKZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uupack/uupget.f
 ****************************************************/
/* 
 *      SUBROUTINE UUPGET(CP,IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UUPSET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPSET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UUPSTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPSTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uupack/uupqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UUPQNP(NCP)
 */
      SUBROUTINE UUPQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UUPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UUPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UUPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UUPQIT(IDX, ITP)
 */
      SUBROUTINE UUPQIT(
          INTEGER IDX
          INTEGER ITP
      )

/* 
 *      ENTRY UUPQVL(IDX, IPARA)
 */
      SUBROUTINE UUPQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UUPSVL(IDX, IPARA)
 */
      SUBROUTINE UUPSVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UUPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUPQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uupack/uuinit.f
 ****************************************************/
/* 
 *      SUBROUTINE UUINIT
 */
      SUBROUTINE UUINIT(
      )

/*****************************************************
 * grph2/uupack/uuslnt.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSLNT(ITYPE)
 */
      SUBROUTINE UUSLNT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUQLNT(ITYPE)
 */
      SUBROUTINE UUQLNT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUSLNI(INDEX)
 */
      SUBROUTINE UUSLNI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUQLNI(INDEX)
 */
      SUBROUTINE UUQLNI(
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uupack/uusmkt.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSMKT(ITYPE)
 */
      SUBROUTINE UUSMKT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUQMKT(ITYPE)
 */
      SUBROUTINE UUQMKT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUSMKI(INDEX)
 */
      SUBROUTINE UUSMKI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUQMKI(INDEX)
 */
      SUBROUTINE UUQMKI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUSMKS(RSIZE)
 */
      SUBROUTINE UUSMKS(
          REAL RSIZE
      )

/* 
 *      ENTRY UUQMKS(RSIZE)
 */
      SUBROUTINE UUQMKS(
          REAL RSIZE
      )

/*****************************************************
 * grph2/uupack/uusebt.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSEBT(ITYPE)
 */
      SUBROUTINE UUSEBT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUQEBT(ITYPE)
 */
      SUBROUTINE UUQEBT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUSEBI(INDEX)
 */
      SUBROUTINE UUSEBI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUQEBI(INDEX)
 */
      SUBROUTINE UUQEBI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUSEBS(RSIZE)
 */
      SUBROUTINE UUSEBS(
          REAL RSIZE
      )

/* 
 *      ENTRY UUQEBS(RSIZE)
 */
      SUBROUTINE UUQEBS(
          REAL RSIZE
      )

/*****************************************************
 * grph2/uupack/uusbrs.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSBRS(RSIZE)
 */
      SUBROUTINE UUSBRS(
          REAL RSIZE
      )

/* 
 *      ENTRY UUQBRS(RSIZE)
 */
      SUBROUTINE UUQBRS(
          REAL RSIZE
      )

/*****************************************************
 * grph2/uupack/uusfrt.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSFRT(ITYPE)
 */
      SUBROUTINE UUSFRT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUQFRT(ITYPE)
 */
      SUBROUTINE UUQFRT(
          INTEGER ITYPE
      )

/* 
 *      ENTRY UUSFRI(INDEX)
 */
      SUBROUTINE UUSFRI(
          INTEGER INDEX
      )

/* 
 *      ENTRY UUQFRI(INDEX)
 */
      SUBROUTINE UUQFRI(
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uupack/uusarp.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSARP(ITPT1,ITPT2)
 */
      SUBROUTINE UUSARP(
          INTEGER ITPT1
          INTEGER ITPT2
      )

/* 
 *      ENTRY UUQARP(ITPT1,ITPT2)
 */
      SUBROUTINE UUQARP(
          INTEGER ITPT1
          INTEGER ITPT2
      )

/*****************************************************
 * grph2/uupack/uusidv.f
 ****************************************************/
/* 
 *      SUBROUTINE UUSIDV(UMIN, UMAX)
 */
      SUBROUTINE UUSIDV(
          REAL UMIN
          REAL UMAX
      )

/* 
 *      ENTRY UUQIDV(UMIN, UMAX)
 */
      SUBROUTINE UUQIDV(
          REAL UMIN
          REAL UMAX
      )

/*****************************************************
 * grph2/uupack/uuiget.f
 ****************************************************/
/* 
 *      SUBROUTINE UUIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UUISET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUISET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/* 
 *      ENTRY UUISTX(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUISTX(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

/*****************************************************
 * grph2/uupack/uuiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UUIQNP(NCP)
 */
      SUBROUTINE UUIQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UUIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUIQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UUIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUIQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UUIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUIQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UUIQVL(IDX, IPARA)
 */
      SUBROUTINE UUIQVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UUISVL(IDX, IPARA)
 */
      SUBROUTINE UUISVL(
          INTEGER IDX
          INTEGER IPARA
      )

/* 
 *      ENTRY UUIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UUIQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uupack/uulget.f
 ****************************************************/
/* 
 *      SUBROUTINE UULGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UULGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UULSET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UULSET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/* 
 *      ENTRY UULSTX(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UULSTX(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

/*****************************************************
 * grph2/uupack/uulqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UULQNP(NCP)
 */
      SUBROUTINE UULQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UULQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UULQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UULQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UULQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UULQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UULQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UULQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UULQVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UULSVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE UULSVL(
          INTEGER IDX
          LOGICAL LPARA
      )

/* 
 *      ENTRY UULQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UULQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uupack/uurget.f
 ****************************************************/
/* 
 *      SUBROUTINE UURGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UURSET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURSET(
          CHARACTER*(*) CP
          REAL RPARA
      )

/* 
 *      ENTRY UURSTX(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURSTX(
          CHARACTER*(*) CP
          REAL RPARA
      )

/*****************************************************
 * grph2/uupack/uurqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE UURQNP(NCP)
 */
      SUBROUTINE UURQNP(
          INTEGER NCP
      )

/* 
 *      ENTRY UURQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURQID(
          CHARACTER*(*) CP
          INTEGER IDX
      )

/* 
 *      ENTRY UURQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURQCP(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UURQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURQCL(
          INTEGER IDX
          CHARACTER*(*) CP
      )

/* 
 *      ENTRY UURQVL(IDX, RPARA)
 */
      SUBROUTINE UURQVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UURSVL(IDX, RPARA)
 */
      SUBROUTINE UURSVL(
          INTEGER IDX
          REAL RPARA
      )

/* 
 *      ENTRY UURQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE UURQIN(
          CHARACTER*(*) CP
          INTEGER IN
      )

/*****************************************************
 * grph2/uvpack/uverb.f
 ****************************************************/
/* 
 *      SUBROUTINE UVERB(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVERB(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uverbz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVERBZ(N,UPX,UPY1,UPY2,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVERBZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uvpack/uvdif.f
 ****************************************************/
/* 
 *      SUBROUTINE UVDIF(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVDIF(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uvdifz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVDIFZ(N,UPX,UPY1,UPY2,ITPAT1,ITPAT2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVDIFZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITPAT1
          INTEGER ITPAT2
      )

/*****************************************************
 * grph2/uvpack/uvbrf.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRF(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBRF(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uvbrfz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRFZ(N,UPX,UPY1,UPY2,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBRFZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uvpack/uvbra.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRA(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBRA(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uvbraz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRAZ(N,UPX,UPY1,UPY2,ITPAT1,ITPAT2,RSIZE)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBRAZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITPAT1
          INTEGER ITPAT2
          REAL RSIZE
      )

/*****************************************************
 * grph2/uvpack/uvbrl.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRL(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UVBRL(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uvpack/uvbrlz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBRLZ(N,UPX,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UVBRLZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uvpack/uvbxf.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXF(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBXF(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uvbxfz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXFZ(N,UPX,UPY1,UPY2,ITYPE,INDEX)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBXFZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uvpack/uvbxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXA(N,UPX,UPY1,UPY2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBXA(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
      )

/*****************************************************
 * grph2/uvpack/uvbxaz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXAZ(N,UPX,UPY1,UPY2,ITPAT1,ITPAT2)
 *      REAL      UPX(*),UPY1(*),UPY2(*)
 */
      SUBROUTINE UVBXAZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY1
          REAL (*) UPY2
          INTEGER ITPAT1
          INTEGER ITPAT2
      )

/*****************************************************
 * grph2/uvpack/uvbxl.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXL(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UVBXL(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uvpack/uvbxlz.f
 ****************************************************/
/* 
 *      SUBROUTINE UVBXLZ(N,UPX,UPY,ITYPE,INDEX)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UVBXLZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uhpack/uherb.f
 ****************************************************/
/* 
 *      SUBROUTINE UHERB(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHERB(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uherbz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHERBZ(N,UPX1,UPX2,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHERBZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uhpack/uhdif.f
 ****************************************************/
/* 
 *      SUBROUTINE UHDIF(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHDIF(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhdifz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHDIFZ(N,UPX1,UPX2,UPY,ITPAT1,ITPAT2)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHDIFZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITPAT1
          INTEGER ITPAT2
      )

/*****************************************************
 * grph2/uhpack/uhbrf.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRF(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBRF(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbrfz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRFZ(N,UPX1,UPX2,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBRFZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uhpack/uhbra.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRA(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBRA(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbraz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRAZ(N,UPX1,UPX2,UPY,ITPAT1,ITPAT2,RSIZE)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBRAZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITPAT1
          INTEGER ITPAT2
          REAL RSIZE
      )

/*****************************************************
 * grph2/uhpack/uhbrl.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRL(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UHBRL(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbrlz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBRLZ(N,UPX,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UHBRLZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph2/uhpack/uhbxf.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXF(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBXF(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbxfz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXFZ(N,UPX1,UPX2,UPY,ITYPE,INDEX)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBXFZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph2/uhpack/uhbxa.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXA(N,UPX1,UPX2,UPY)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBXA(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbxl.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXL(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UHBXL(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
      )

/*****************************************************
 * grph2/uhpack/uhbxaz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXAZ(N,UPX1,UPX2,UPY,ITPAT1,ITPAT2)
 *      REAL      UPX1(*),UPX2(*),UPY(*)
 */
      SUBROUTINE UHBXAZ(
          INTEGER N
          REAL (*) UPX1
          REAL (*) UPX2
          REAL (*) UPY
          INTEGER ITPAT1
          INTEGER ITPAT2
      )

/*****************************************************
 * grph2/uhpack/uhbxlz.f
 ****************************************************/
/* 
 *      SUBROUTINE UHBXLZ(N,UPX,UPY,ITYPE,INDEX)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE UHBXLZ(
          INTEGER N
          REAL (*) UPX
          REAL (*) UPY
          INTEGER ITYPE
          INTEGER INDEX
      )