/*
 * grph1_sgpack.fp
 *
 * $Id: grph1_sgpack.fp,v 1.1 2000/11/19 16:00:14 keiko Exp $
 */

/*****************************************************
 * grph1/sgpack/sgopn.f
 ****************************************************/
/* 
 *      SUBROUTINE SGOPN(IWS)
 */
      SUBROUTINE SGOPN(
          INTEGER IWS
      )

/* 
 *      ENTRY SGFRM
 */
      SUBROUTINE SGFRM(
      )

/* 
 *      ENTRY SGCLS
 */
      SUBROUTINE SGCLS(
      )

/*****************************************************
 * grph1/sgpack/sgpget.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
/*      SUBROUTINE SGPGET(
 *          CHARACTER*(*) CP
 *          INTEGER o IPARA
 *      )
 */

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

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

/*****************************************************
 * grph1/sgpack/sgpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPQNP(NCP)
 */
      SUBROUTINE SGPQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SGPQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGPQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SGPQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGPQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGPQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGPQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGPQIT(IDX, ITP)
 */
      SUBROUTINE SGPQIT(
          INTEGER IDX
          INTEGER o ITP
      )

/* 
 *      ENTRY SGPQVL(IDX, IPARA)
 */
      SUBROUTINE SGPQVL(
          INTEGER IDX
          INTEGER o IPARA
      )

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

/* 
 *      ENTRY SGPQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGPQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/sgpack/sgpwsn.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPWSN
 */
      SUBROUTINE SGPWSN(
      )

/*****************************************************
 * grph1/sgpack/sgsvpt.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSVPT(VXMIN, VXMAX, VYMIN, VYMAX)
 */
      SUBROUTINE SGSVPT(
          REAL VXMIN
          REAL VXMAX
          REAL VYMIN
          REAL VYMAX
      )

/* 
 *      ENTRY SGQVPT(VXMIN, VXMAX, VYMIN, VYMAX)
 */
      SUBROUTINE SGQVPT(
          REAL o VXMIN
          REAL o VXMAX
          REAL o VYMIN
          REAL o VYMAX
      )

/*****************************************************
 * grph1/sgpack/sgswnd.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSWND(UXMIN, UXMAX, UYMIN, UYMAX)
 */
      SUBROUTINE SGSWND(
          REAL UXMIN
          REAL UXMAX
          REAL UYMIN
          REAL UYMAX
      )

/* 
 *      ENTRY SGQWND(UXMIN, UXMAX, UYMIN, UYMAX)
 */
      SUBROUTINE SGQWND(
          REAL o UXMIN
          REAL o UXMAX
          REAL o UYMIN
          REAL o UYMAX
      )

/*****************************************************
 * grph1/sgpack/sgssim.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSSIM(SIMFAC, VXOFF, VYOFF)
 */
      SUBROUTINE SGSSIM(
          REAL SIMFAC
          REAL VXOFF
          REAL VYOFF
      )

/* 
 *      ENTRY SGQSIM(SIMFAC, VXOFF, VYOFF)
 */
      SUBROUTINE SGQSIM(
          REAL o SIMFAC
          REAL o VXOFF
          REAL o VYOFF
      )

/*****************************************************
 * grph1/sgpack/sgsmpl.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSMPL(PLX, PLY, PLROT)
 */
      SUBROUTINE SGSMPL(
          REAL PLX
          REAL PLY
          REAL PLROT
      )

/* 
 *      ENTRY SGQMPL(PLX, PLY, PLROT)
 */
      SUBROUTINE SGQMPL(
          REAL o PLX
          REAL o PLY
          REAL o PLROT
      )

/*****************************************************
 * grph1/sgpack/sgstxy.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSTXY(TXMIN, TXMAX, TYMIN, TYMAX)
 */
      SUBROUTINE SGSTXY(
          REAL TXMIN
          REAL TXMAX
          REAL TYMIN
          REAL TYMAX
      )

/* 
 *      ENTRY SGQTXY(TXMIN, TXMAX, TYMIN, TYMAX)
 */
      SUBROUTINE SGQTXY(
          REAL o TXMIN
          REAL o TXMAX
          REAL o TYMIN
          REAL o TYMAX
      )

/*****************************************************
 * grph1/sgpack/sgstrn.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSTRN(ITR)
 */
      SUBROUTINE SGSTRN(
          INTEGER ITR
      )

/* 
 *      ENTRY SGQTRN(ITR)
 */
      SUBROUTINE SGQTRN(
          INTEGER o ITR
      )

/*****************************************************
 * grph1/sgpack/sgstrf.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSTRF
 */
      SUBROUTINE SGSTRF(
      )

/*****************************************************
 * grph1/sgpack/sgtrqf.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTRQF(NTX,LTR)
 *      LOGICAL   LTR
 */
      SUBROUTINE SGTRQF(
          INTEGER NTX
          LOGICAL o LTR
      )

/* 
 *      ENTRY SGTRSL(CTS,CTL)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRSL(
          CHARACTER*(*) CTS
          CHARACTER*(*) o CTL
      )

/* 
 *      ENTRY SGTRSN(CTS,NTX)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRSN(
          CHARACTER*(*) CTS
          INTEGER o NTX
      )

/* 
 *      ENTRY SGTRLS(CTL,CTS)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRLS(
          CHARACTER*(*) CTL
          CHARACTER*(*) o CTS
      )

/* 
 *      ENTRY SGTRLN(CTL,NTX)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRLN(
          CHARACTER*(*) CTL
          INTEGER o NTX
      )

/* 
 *      ENTRY SGTRNS(NTX,CTS)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRNS(
          INTEGER NTX
          CHARACTER*(*) o CTS
      )

/* 
 *      ENTRY SGTRNL(NTX,CTL)
 *      CHARACTER CTS*(*),CTL*(*)
 */
      SUBROUTINE SGTRNL(
          INTEGER NTX
          CHARACTER*(*) o CTL
      )

/*****************************************************
 * grph1/sgpack/isgtrc.f
 ****************************************************/
/* 
 *      INTEGER FUNCTION ISGTRC(CTR)
 *      CHARACTER CTR*(*)
 */
      INTEGER FUNCTION ISGTRC(
          CHARACTER*(*) CTR
      )

/*****************************************************
 * grph1/sgpack/sgplu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPLU(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPLU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
      )

/* 
 *      ENTRY SGPLV(N,VPX,VPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPLV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
      )

/* 
 *      ENTRY SGPLR(N,RPX,RPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPLR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
      )

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

/* 
 *      ENTRY SGQPLT(ITYPE)
 */
      SUBROUTINE SGQPLT(
          INTEGER o ITYPE
      )

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

/* 
 *      ENTRY SGQPLI(INDEX)
 */
      SUBROUTINE SGQPLI(
          INTEGER o INDEX
      )

/*****************************************************
 * grph1/sgpack/sgplzu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPLZU(N,UPX,UPY,ITYPE,INDEX)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE SGPLZU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgplzv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPLZV(N,VPX,VPY,ITYPE,INDEX)
 *      REAL      VPX(*),VPY(*)
 */
      SUBROUTINE SGPLZV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgplzr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPLZR(N,RPX,RPY,ITYPE,INDEX)
 *      REAL      RPX(*),RPY(*)
 */
      SUBROUTINE SGPLZR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgpmu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPMU(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPMU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
      )

/* 
 *      ENTRY SGPMV(N,VPX,VPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPMV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
      )

/* 
 *      ENTRY SGPMR(N,RPX,RPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGPMR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
      )

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

/* 
 *      ENTRY SGQPMT(ITYPE)
 */
      SUBROUTINE SGQPMT(
          INTEGER o ITYPE
      )

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

/* 
 *      ENTRY SGQPMI(INDEX)
 */
      SUBROUTINE SGQPMI(
          INTEGER o INDEX
      )

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

/* 
 *      ENTRY SGQPMS(RSIZE)
 */
      SUBROUTINE SGQPMS(
          REAL o RSIZE
      )

/*****************************************************
 * grph1/sgpack/sgtxu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTXU(UX,UY,CHARS)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXU(
          REAL UX
          REAL UY
          CHARACTER*(*) CHARS
      )

/* 
 *      ENTRY SGTXV(VX,VY,CHARS)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXV(
          REAL VX
          REAL VY
          CHARACTER*(*) CHARS
      )

/* 
 *      ENTRY SGTXR(RX,RY,CHARS)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXR(
          REAL RX
          REAL RY
          CHARACTER*(*) CHARS
      )

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

/* 
 *      ENTRY SGQTXS(RSIZE)
 */
      SUBROUTINE SGQTXS(
          REAL o RSIZE
      )

/* 
 *      ENTRY SGSTXR(IROTA)
 */
      SUBROUTINE SGSTXR(
          INTEGER IROTA
      )

/* 
 *      ENTRY SGQTXR(IROTA)
 */
      SUBROUTINE SGQTXR(
          INTEGER o IROTA
      )

/* 
 *      ENTRY SGSTXC(ICENT)
 */
      SUBROUTINE SGSTXC(
          INTEGER ICENT
      )

/* 
 *      ENTRY SGQTXC(ICENT)
 */
      SUBROUTINE SGQTXC(
          INTEGER o ICENT
      )

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

/* 
 *      ENTRY SGQTXI(INDEX)
 */
      SUBROUTINE SGQTXI(
          INTEGER o INDEX
      )

/*****************************************************
 * grph1/sgpack/sgpmzu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPMZU(N,UPX,UPY,ITYPE,INDEX,RSIZE)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE SGPMZU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph1/sgpack/sgpmzv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPMZV(N,VPX,VPY,ITYPE,INDEX,RSIZE)
 *      REAL      VPX(*),VPY(*)
 */
      SUBROUTINE SGPMZV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph1/sgpack/sgpmzr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPMZR(N,RPX,RPY,ITYPE,INDEX,RSIZE)
 *      REAL      RPX(*),RPY(*)
 */
      SUBROUTINE SGPMZR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
          INTEGER ITYPE
          INTEGER INDEX
          REAL RSIZE
      )

/*****************************************************
 * grph1/sgpack/sgtxzu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTXZU(UX,UY,CHARS,RSIZE,IROTA,ICENT,INDEX)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXZU(
          REAL UX
          REAL UY
          CHARACTER*(*) CHARS
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgtxzv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTXZV(VX,VY,CHARS,RSIZE,IROTA,ICENT,INDEX)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXZV(
          REAL VX
          REAL VY
          CHARACTER*(*) CHARS
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgtxzr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTXZR(RX,RY,CHARS,RSIZE,IROTA,ICENT,INDEX)
 *      CHARACTER CHARS*(*)
 */
      SUBROUTINE SGTXZR(
          REAL RX
          REAL RY
          CHARACTER*(*) CHARS
          REAL RSIZE
          INTEGER IROTA
          INTEGER ICENT
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgtnu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTNU(N,UPX,UPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGTNU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
      )

/* 
 *      ENTRY SGTNV(N,VPX,VPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGTNV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
      )

/* 
 *      ENTRY SGTNR(N,RPX,RPY)
 *      REAL      UPX(*),UPY(*),VPX(*),VPY(*),RPX(*),RPY(*)
 */
      SUBROUTINE SGTNR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
      )

/* 
 *      ENTRY SGSTNP(ITPAT)
 */
      SUBROUTINE SGSTNP(
          INTEGER ITPAT
      )

/* 
 *      ENTRY SGQTNP(ITPAT)
 */
      SUBROUTINE SGQTNP(
          INTEGER o ITPAT
      )

/*****************************************************
 * grph1/sgpack/sgtnzu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTNZU(N,UPX,UPY,ITPAT)
 *      REAL      UPX(*),UPY(*)
 */
      SUBROUTINE SGTNZU(
          INTEGER N
          REAL (N) UPX
          REAL (N) UPY
          INTEGER ITPAT
      )

/*****************************************************
 * grph1/sgpack/sgtnzv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTNZV(N,VPX,VPY,ITPAT)
 *      REAL      VPX(*),VPY(*)
 */
      SUBROUTINE SGTNZV(
          INTEGER N
          REAL (N) VPX
          REAL (N) VPY
          INTEGER ITPAT
      )

/*****************************************************
 * grph1/sgpack/sgtnzr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGTNZR(N,RPX,RPY,ITPAT)
 *      REAL      RPX(*),RPY(*)
 */
      SUBROUTINE SGTNZR(
          INTEGER N
          REAL (N) RPX
          REAL (N) RPY
          INTEGER ITPAT
      )

/*****************************************************
 * grph1/sgpack/sglnu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLNU(UX1,UY1,UX2,UY2)
 */
      SUBROUTINE SGLNU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
      )

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

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

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

/* 
 *      ENTRY SGQLNI(INDEX)
 */
      SUBROUTINE SGQLNI(
          INTEGER o INDEX
      )

/*****************************************************
 * grph1/sgpack/sglnzu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLNZU(UX1,UY1,UX2,UY2,INDEX)
 */
      SUBROUTINE SGLNZU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sglnzv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLNZV(VX1,VY1,VX2,VY2,INDEX)
 */
      SUBROUTINE SGLNZV(
          REAL VX1
          REAL VY1
          REAL VX2
          REAL VY2
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sglnzr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLNZR(RX1,RY1,RX2,RY2,INDEX)
 */
      SUBROUTINE SGLNZR(
          REAL RX1
          REAL RY1
          REAL RX2
          REAL RY2
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sglau.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLAU(UX1,UY1,UX2,UY2)
 */
      SUBROUTINE SGLAU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
      )

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

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

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

/* 
 *      ENTRY SGQLAT(ITYPE)
 */
      SUBROUTINE SGQLAT(
          INTEGER o ITYPE
      )

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

/* 
 *      ENTRY SGQLAI(INDEX)
 */
      SUBROUTINE SGQLAI(
          INTEGER o INDEX
      )

/*****************************************************
 * grph1/sgpack/sglazu.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLAZU(UX1,UY1,UX2,UY2,ITYPE,INDEX)
 */
      SUBROUTINE SGLAZU(
          REAL UX1
          REAL UY1
          REAL UX2
          REAL UY2
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sglazv.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLAZV(VX1,VY1,VX2,VY2,ITYPE,INDEX)
 */
      SUBROUTINE SGLAZV(
          REAL VX1
          REAL VY1
          REAL VX2
          REAL VY2
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sglazr.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLAZR(RX1,RY1,RX2,RY2,ITYPE,INDEX)
 */
      SUBROUTINE SGLAZR(
          REAL RX1
          REAL RY1
          REAL RX2
          REAL RY2
          INTEGER ITYPE
          INTEGER INDEX
      )

/*****************************************************
 * grph1/sgpack/sgsplc.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSPLC(CHARX)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE SGSPLC(
          CHARACTER*(*) CHARX
      )

/* 
 *      ENTRY SGQPLC(CHARX)
 *      CHARACTER CHARX*(*)
 */
      SUBROUTINE SGQPLC(
          CHARACTER*(*) o CHARX
      )

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

/* 
 *      ENTRY SGQPLS(RSIZE)
 */
      SUBROUTINE SGQPLS(
          REAL o RSIZE
      )

/* 
 *      ENTRY SGNPLC
 */
      SUBROUTINE SGNPLC(
      )

/*****************************************************
 * grph1/sgpack/sgiget.f
 ****************************************************/
/* 
 *      SUBROUTINE SGIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGIGET(
          CHARACTER*(*) CP
          INTEGER o IPARA
      )

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

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

/*****************************************************
 * grph1/sgpack/sgiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SGIQNP(NCP)
 */
      SUBROUTINE SGIQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SGIQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGIQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SGIQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGIQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGIQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGIQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGIQVL(IDX, IPARA)
 */
      SUBROUTINE SGIQVL(
          INTEGER IDX
          INTEGER o IPARA
      )

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

/* 
 *      ENTRY SGIQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGIQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/sgpack/sglget.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SGLGET(
          CHARACTER*(*) CP
          LOGICAL o LPARA
      )

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

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

/*****************************************************
 * grph1/sgpack/sglqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SGLQNP(NCP)
 */
      SUBROUTINE SGLQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SGLQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGLQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SGLQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGLQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGLQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGLQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGLQVL(IDX, LPARA)
 *      LOGICAL   LPARA
 */
      SUBROUTINE SGLQVL(
          INTEGER IDX
          LOGICAL o LPARA
      )

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

/* 
 *      ENTRY SGLQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGLQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/sgpack/sgoopn.f
 ****************************************************/
/* 
 *      SUBROUTINE SGOOPN(CPRC, COM)
 *      CHARACTER CPRC*(*), COM*(*)
 */
      SUBROUTINE SGOOPN(
          CHARACTER*(*) CPRC
          CHARACTER*(*) COM
      )

/* 
 *      ENTRY SGOCLS(CPRC)
 *      CHARACTER CPRC*(*), COM*(*)
 */
      SUBROUTINE SGOCLS(
          CHARACTER*(*) CPRC
      )

/*****************************************************
 * grph1/sgpack/sgrget.f
 ****************************************************/
/* 
 *      SUBROUTINE SGRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGRGET(
          CHARACTER*(*) CP
          REAL o RPARA
      )

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

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

/*****************************************************
 * grph1/sgpack/sgrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE SGRQNP(NCP)
 */
      SUBROUTINE SGRQNP(
          INTEGER o NCP
      )

/* 
 *      ENTRY SGRQID(CP, IDX)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGRQID(
          CHARACTER*(*) CP
          INTEGER o IDX
      )

/* 
 *      ENTRY SGRQCP(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGRQCP(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGRQCL(IDX, CP)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGRQCL(
          INTEGER IDX
          CHARACTER*(*) o CP
      )

/* 
 *      ENTRY SGRQVL(IDX, RPARA)
 */
      SUBROUTINE SGRQVL(
          INTEGER IDX
          REAL o RPARA
      )

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

/* 
 *      ENTRY SGRQIN(CP, IN)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE SGRQIN(
          CHARACTER*(*) CP
          INTEGER o IN
      )

/*****************************************************
 * grph1/sgpack/sgpcmd.f
 ****************************************************/
/* 
 *      SUBROUTINE SGPCMD
 */
#if DCLVER >= 53
      SUBROUTINE SGPCMD(
      )
#endif

/*****************************************************
 * grph1/sgpack/sgscmn.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSCMN(NC)
 */
#if DCLVER >= 53
      SUBROUTINE SGSCMN(
          INTEGER NC
      )
#endif

/* 
 *      ENTRY SGQCMN(NMAX)
 */
#if DCLVER >= 53
      SUBROUTINE SGQCMN(
          INTEGER o NMAX
      )
#endif

/*****************************************************
 * grph1/sgpack/sgscwd.f
 ****************************************************/
/* 
 *      SUBROUTINE SGSCWD(CXMIN,CXMAX,CYMIN,CYMAX)
 */
#if DCLVER >= 53
      SUBROUTINE SGSCWD(
          REAL CXMIN
          REAL CXMAX
          REAL CYMIN
          REAL CYMAX
      )
#endif

/* 
 *      ENTRY SGQCWD(CXMIN,CXMAX,CYMIN,CYMAX)
 */
#if DCLVER >= 53
      SUBROUTINE SGQCWD(
          REAL o CXMIN
          REAL o CXMAX
          REAL o CYMIN
          REAL o CYMAX
      )
#endif