/*****************************************************
 * math2/vstlib/vs1int.f
 ****************************************************/
/* 
 *      SUBROUTINE VS1INT(WZ,NW,IX)
 *      REAL      WZ(IX,2),X(IX)
 *      INTEGER   NW(IX)
 */
      SUBROUTINE VS1INT(
          REAL (IX,2) WZ
          INTEGER (IX) NW
          INTEGER IX
      )

/* 
 *      ENTRY VS1DIN(WZ,NW,IX,X)
 *      REAL      WZ(IX,2),X(IX)
 *      INTEGER   NW(IX)
 */
      SUBROUTINE VS1DIN(
          REAL (IX,2) WZ
          INTEGER (IX) NW
          INTEGER IX
          REAL X
      )

/* 
 *      ENTRY VS1OUT(WZ,NW,IX)
 *      REAL      WZ(IX,2),X(IX)
 *      INTEGER   NW(IX)
 */
      SUBROUTINE VS1OUT(
          REAL (IX,2) WZ
          INTEGER (IX) NW
          INTEGER IX
      )

/*****************************************************
 * math2/vstlib/vs2int.f
 ****************************************************/
/* 
 *      SUBROUTINE VS2INT(WZ,NW,IX,IY)
 *      REAL      WZ(IX,IY,5),X(IX),Y(IY)
 *      INTEGER   NW(IX,IY)
 */
      SUBROUTINE VS2INT(
          REAL (IX,IY,5) WZ
          INTEGER (IX,IY) NW
          INTEGER IX
          INTEGER IY
      )

/* 
 *      ENTRY VS2DIN(WZ,NW,IX,IY,X,Y)
 *      REAL      WZ(IX,IY,5),X(IX),Y(IY)
 *      INTEGER   NW(IX,IY)
 */
      SUBROUTINE VS2DIN(
          REAL (IX,IY,5) WZ
          INTEGER (IX,IY) NW
          INTEGER IX
          INTEGER IY
          REAL X
          REAL Y
      )

/* 
 *      ENTRY VS2OUT(WZ,NW,IX,IY)
 *      REAL      WZ(IX,IY,5),X(IX),Y(IY)
 *      INTEGER   NW(IX,IY)
 */
      SUBROUTINE VS2OUT(
          REAL (IX,IY,5) WZ
          INTEGER (IX,IY) NW
          INTEGER IX
          INTEGER IY
      )

/*****************************************************
 * math2/fftlib/cfftb.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTB (N,C,WSAVE)
 *      DIMENSION       C(*)       ,WSAVE(*)
 */
      SUBROUTINE CFFTB(
          INTEGER N
          REAL (*) C
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cfftb1.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTB1 (N,C,CH,WA,IFAC)
 *      DIMENSION       CH(*)      ,C(*)       ,WA(*)      ,IFAC(*)
 */
      SUBROUTINE CFFTB1(
          INTEGER N
          REAL (*) C
          REAL (*) CH
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/cfftf.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTF (N,C,WSAVE)
 *      DIMENSION       C(*)       ,WSAVE(*)
 */
      SUBROUTINE CFFTF(
          INTEGER N
          REAL (*) C
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cfftf1.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTF1 (N,C,CH,WA,IFAC)
 *      DIMENSION       CH(*)      ,C(*)       ,WA(*)      ,IFAC(*)
 */
      SUBROUTINE CFFTF1(
          INTEGER N
          REAL (*) C
          REAL (*) CH
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/cffti.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE CFFTI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cffti1.f
 ****************************************************/
/* 
 *      SUBROUTINE CFFTI1 (N,WA,IFAC)
 *      DIMENSION       WA(*)      ,IFAC(*)    ,NTRYH(4)
 */
      SUBROUTINE CFFTI1(
          INTEGER N
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/cosqb.f
 ****************************************************/
/* 
 *      SUBROUTINE COSQB (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE COSQB(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cosqb1.f
 ****************************************************/
/* 
 *      SUBROUTINE COSQB1 (N,X,W,XH)
 *      DIMENSION       X(*)       ,W(*)       ,XH(*)
 */
      SUBROUTINE COSQB1(
          INTEGER N
          REAL X
          REAL (*) W
          REAL (*) XH
      )

/*****************************************************
 * math2/fftlib/cosqf.f
 ****************************************************/
/* 
 *      SUBROUTINE COSQF (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE COSQF(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cosqf1.f
 ****************************************************/
/* 
 *      SUBROUTINE COSQF1 (N,X,W,XH)
 *      DIMENSION       X(*)       ,W(*)       ,XH(*)
 */
      SUBROUTINE COSQF1(
          INTEGER N
          REAL X
          REAL (*) W
          REAL (*) XH
      )

/*****************************************************
 * math2/fftlib/cosqi.f
 ****************************************************/
/* 
 *      SUBROUTINE COSQI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE COSQI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/cost.f
 ****************************************************/
/* 
 *      SUBROUTINE COST (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE COST(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/costi.f
 ****************************************************/
/* 
 *      SUBROUTINE COSTI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE COSTI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/ezfft1.f
 ****************************************************/
/* 
 *      SUBROUTINE EZFFT1 (N,WA,IFAC)
 *      DIMENSION       WA(*)      ,IFAC(*)    ,NTRYH(4)
 */
      SUBROUTINE EZFFT1(
          INTEGER N
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/ezfftb.f
 ****************************************************/
/* 
 *      SUBROUTINE EZFFTB (N,R,AZERO,A,B,WSAVE)
 *      DIMENSION       R(*)       ,A(*)       ,B(*)       ,WSAVE(*)
 */
      SUBROUTINE EZFFTB(
          INTEGER N
          REAL (*) R
          REAL AZERO
          REAL A
          REAL (*) B
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/ezfftf.f
 ****************************************************/
/* 
 *      SUBROUTINE EZFFTF (N,R,AZERO,A,B,WSAVE)
 *      DIMENSION       R(*)       ,A(*)       ,B(*)       ,WSAVE(*)
 */
      SUBROUTINE EZFFTF(
          INTEGER N
          REAL (*) R
          REAL AZERO
          REAL A
          REAL (*) B
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/ezffti.f
 ****************************************************/
/* 
 *      SUBROUTINE EZFFTI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE EZFFTI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/passb.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSB (NAC,IDO,IP,L1,IDL1,CC,C1,C2,CH,CH2,WA)
 *      DIMENSION       CH(IDO,L1,IP)          ,CC(IDO,IP,L1)          ,
 */
      SUBROUTINE PASSB(
          INTEGER NAC
          INTEGER IDO
          INTEGER IP
          INTEGER L1
          INTEGER IDL1
          REAL (IDO,IP,L1) CC
          REAL C1
          REAL C2
          REAL (IDO,L1,IP) CH
          REAL CH2
          REAL WA
      )

/*****************************************************
 * math2/fftlib/passb2.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSB2 (IDO,L1,CC,CH,WA1)
 *      DIMENSION       CC(IDO,2,L1)           ,CH(IDO,L1,2)           ,
 */
      SUBROUTINE PASSB2(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,2,L1) CC
          REAL (IDO,L1,2) CH
          REAL WA1
      )

/*****************************************************
 * math2/fftlib/passb3.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSB3 (IDO,L1,CC,CH,WA1,WA2)
 *      DIMENSION       CC(IDO,3,L1)           ,CH(IDO,L1,3)           ,
 */
      SUBROUTINE PASSB3(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,3,L1) CC
          REAL (IDO,L1,3) CH
          REAL WA1
          REAL WA2
      )

/*****************************************************
 * math2/fftlib/passb4.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSB4 (IDO,L1,CC,CH,WA1,WA2,WA3)
 *      DIMENSION       CC(IDO,4,L1)           ,CH(IDO,L1,4)           ,
 */
      SUBROUTINE PASSB4(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,4,L1) CC
          REAL (IDO,L1,4) CH
          REAL WA1
          REAL WA2
          REAL WA3
      )

/*****************************************************
 * math2/fftlib/passb5.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSB5 (IDO,L1,CC,CH,WA1,WA2,WA3,WA4)
 *      DIMENSION       CC(IDO,5,L1)           ,CH(IDO,L1,5)           ,
 */
      SUBROUTINE PASSB5(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,5,L1) CC
          REAL (IDO,L1,5) CH
          REAL WA1
          REAL WA2
          REAL WA3
          REAL WA4
      )

/*****************************************************
 * math2/fftlib/passf.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSF (NAC,IDO,IP,L1,IDL1,CC,C1,C2,CH,CH2,WA)
 *      DIMENSION       CH(IDO,L1,IP)          ,CC(IDO,IP,L1)          ,
 */
      SUBROUTINE PASSF(
          INTEGER NAC
          INTEGER IDO
          INTEGER IP
          INTEGER L1
          INTEGER IDL1
          REAL (IDO,IP,L1) CC
          REAL C1
          REAL C2
          REAL (IDO,L1,IP) CH
          REAL CH2
          REAL WA
      )

/*****************************************************
 * math2/fftlib/passf2.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSF2 (IDO,L1,CC,CH,WA1)
 *      DIMENSION       CC(IDO,2,L1)           ,CH(IDO,L1,2)           ,
 */
      SUBROUTINE PASSF2(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,2,L1) CC
          REAL (IDO,L1,2) CH
          REAL WA1
      )

/*****************************************************
 * math2/fftlib/radb2.f
 ****************************************************/
/* 
 *      SUBROUTINE RADB2 (IDO,L1,CC,CH,WA1)
 *      DIMENSION       CC(IDO,2,L1)           ,CH(IDO,L1,2)           ,
 */
      SUBROUTINE RADB2(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,2,L1) CC
          REAL (IDO,L1,2) CH
          REAL WA1
      )

/*****************************************************
 * math2/fftlib/passf3.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSF3 (IDO,L1,CC,CH,WA1,WA2)
 *      DIMENSION       CC(IDO,3,L1)           ,CH(IDO,L1,3)           ,
 */
      SUBROUTINE PASSF3(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,3,L1) CC
          REAL (IDO,L1,3) CH
          REAL WA1
          REAL WA2
      )

/*****************************************************
 * math2/fftlib/passf4.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSF4 (IDO,L1,CC,CH,WA1,WA2,WA3)
 *      DIMENSION       CC(IDO,4,L1)           ,CH(IDO,L1,4)           ,
 */
      SUBROUTINE PASSF4(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,4,L1) CC
          REAL (IDO,L1,4) CH
          REAL WA1
          REAL WA2
          REAL WA3
      )

/*****************************************************
 * math2/fftlib/passf5.f
 ****************************************************/
/* 
 *      SUBROUTINE PASSF5 (IDO,L1,CC,CH,WA1,WA2,WA3,WA4)
 *      DIMENSION       CC(IDO,5,L1)           ,CH(IDO,L1,5)           ,
 */
      SUBROUTINE PASSF5(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,5,L1) CC
          REAL (IDO,L1,5) CH
          REAL WA1
          REAL WA2
          REAL WA3
          REAL WA4
      )

/*****************************************************
 * math2/fftlib/radb3.f
 ****************************************************/
/* 
 *      SUBROUTINE RADB3 (IDO,L1,CC,CH,WA1,WA2)
 *      DIMENSION       CC(IDO,3,L1)           ,CH(IDO,L1,3)           ,
 */
      SUBROUTINE RADB3(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,3,L1) CC
          REAL (IDO,L1,3) CH
          REAL WA1
          REAL WA2
      )

/*****************************************************
 * math2/fftlib/radb4.f
 ****************************************************/
/* 
 *      SUBROUTINE RADB4 (IDO,L1,CC,CH,WA1,WA2,WA3)
 *      DIMENSION       CC(IDO,4,L1)           ,CH(IDO,L1,4)           ,
 */
      SUBROUTINE RADB4(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,4,L1) CC
          REAL (IDO,L1,4) CH
          REAL WA1
          REAL WA2
          REAL WA3
      )

/*****************************************************
 * math2/fftlib/radb5.f
 ****************************************************/
/* 
 *      SUBROUTINE RADB5 (IDO,L1,CC,CH,WA1,WA2,WA3,WA4)
 *      DIMENSION       CC(IDO,5,L1)           ,CH(IDO,L1,5)           ,
 */
      SUBROUTINE RADB5(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,5,L1) CC
          REAL (IDO,L1,5) CH
          REAL WA1
          REAL WA2
          REAL WA3
          REAL WA4
      )

/*****************************************************
 * math2/fftlib/radbg.f
 ****************************************************/
/* 
 *      SUBROUTINE RADBG (IDO,IP,L1,IDL1,CC,C1,C2,CH,CH2,WA)
 *      DIMENSION       CH(IDO,L1,IP)          ,CC(IDO,IP,L1)          ,
 */
      SUBROUTINE RADBG(
          INTEGER IDO
          INTEGER IP
          INTEGER L1
          INTEGER IDL1
          REAL (IDO,IP,L1) CC
          REAL C1
          REAL C2
          REAL (IDO,L1,IP) CH
          REAL CH2
          REAL WA
      )

/*****************************************************
 * math2/fftlib/radf2.f
 ****************************************************/
/* 
 *      SUBROUTINE RADF2 (IDO,L1,CC,CH,WA1)
 *      DIMENSION       CH(IDO,2,L1)           ,CC(IDO,L1,2)           ,
 */
      SUBROUTINE RADF2(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,L1,2) CC
          REAL (IDO,2,L1) CH
          REAL WA1
      )

/*****************************************************
 * math2/fftlib/radf3.f
 ****************************************************/
/* 
 *      SUBROUTINE RADF3 (IDO,L1,CC,CH,WA1,WA2)
 *      DIMENSION       CH(IDO,3,L1)           ,CC(IDO,L1,3)           ,
 */
      SUBROUTINE RADF3(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,L1,3) CC
          REAL (IDO,3,L1) CH
          REAL WA1
          REAL WA2
      )

/*****************************************************
 * math2/fftlib/radf4.f
 ****************************************************/
/* 
 *      SUBROUTINE RADF4 (IDO,L1,CC,CH,WA1,WA2,WA3)
 *      DIMENSION       CC(IDO,L1,4)           ,CH(IDO,4,L1)           ,
 */
      SUBROUTINE RADF4(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,L1,4) CC
          REAL (IDO,4,L1) CH
          REAL WA1
          REAL WA2
          REAL WA3
      )

/*****************************************************
 * math2/fftlib/radf5.f
 ****************************************************/
/* 
 *      SUBROUTINE RADF5 (IDO,L1,CC,CH,WA1,WA2,WA3,WA4)
 *      DIMENSION       CC(IDO,L1,5)           ,CH(IDO,5,L1)           ,
 */
      SUBROUTINE RADF5(
          INTEGER IDO
          INTEGER L1
          REAL (IDO,L1,5) CC
          REAL (IDO,5,L1) CH
          REAL WA1
          REAL WA2
          REAL WA3
          REAL WA4
      )

/*****************************************************
 * math2/fftlib/radfg.f
 ****************************************************/
/* 
 *      SUBROUTINE RADFG (IDO,IP,L1,IDL1,CC,C1,C2,CH,CH2,WA)
 *      DIMENSION       CH(IDO,L1,IP)          ,CC(IDO,IP,L1)          ,
 */
      SUBROUTINE RADFG(
          INTEGER IDO
          INTEGER IP
          INTEGER L1
          INTEGER IDL1
          REAL (IDO,IP,L1) CC
          REAL C1
          REAL C2
          REAL (IDO,L1,IP) CH
          REAL CH2
          REAL WA
      )

/*****************************************************
 * math2/fftlib/rfftb.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTB (N,R,WSAVE)
 *      DIMENSION       R(*)       ,WSAVE(*)
 */
      SUBROUTINE RFFTB(
          INTEGER N
          REAL (*) R
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/rfftb1.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTB1 (N,C,CH,WA,IFAC)
 *      DIMENSION       CH(*)      ,C(*)       ,WA(*)      ,IFAC(*)
 */
      SUBROUTINE RFFTB1(
          INTEGER N
          REAL (*) C
          REAL (*) CH
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/rfftf.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTF (N,R,WSAVE)
 *      DIMENSION       R(*)       ,WSAVE(*)
 */
      SUBROUTINE RFFTF(
          INTEGER N
          REAL (*) R
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/rfftf1.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTF1 (N,C,CH,WA,IFAC)
 *      DIMENSION       CH(*)      ,C(*)       ,WA(*)      ,IFAC(*)
 */
      SUBROUTINE RFFTF1(
          INTEGER N
          REAL (*) C
          REAL (*) CH
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/rffti.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE RFFTI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/rffti1.f
 ****************************************************/
/* 
 *      SUBROUTINE RFFTI1 (N,WA,IFAC)
 *      DIMENSION       WA(*)      ,IFAC(*)    ,NTRYH(4)
 */
      SUBROUTINE RFFTI1(
          INTEGER N
          REAL (*) WA
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/sinqb.f
 ****************************************************/
/* 
 *      SUBROUTINE SINQB (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE SINQB(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/sinqf.f
 ****************************************************/
/* 
 *      SUBROUTINE SINQF (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE SINQF(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/sinqi.f
 ****************************************************/
/* 
 *      SUBROUTINE SINQI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE SINQI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/sint.f
 ****************************************************/
/* 
 *      SUBROUTINE SINT (N,X,WSAVE)
 *      DIMENSION       X(*)       ,WSAVE(*)
 */
      SUBROUTINE SINT(
          INTEGER N
          REAL (*) X
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/fftlib/sint1.f
 ****************************************************/
/* 
 *      SUBROUTINE SINT1(N,WAR,WAS,XH,X,IFAC)
 *      DIMENSION WAR(*),WAS(*),X(*),XH(*),IFAC(*)
 */
      SUBROUTINE SINT1(
          INTEGER N
          REAL (*) WAR
          REAL (*) WAS
          REAL (*) XH
          REAL X
          INTEGER (*) IFAC
      )

/*****************************************************
 * math2/fftlib/sinti.f
 ****************************************************/
/* 
 *      SUBROUTINE SINTI (N,WSAVE)
 *      DIMENSION       WSAVE(*)
 */
      SUBROUTINE SINTI(
          INTEGER N
          REAL (*) WSAVE
      )

/*****************************************************
 * math2/intrlib/vrintr.f
 ****************************************************/
/* 
 *      SUBROUTINE VRINTR(RX,N,JX)
 *      REAL    RX(*)
 */
      SUBROUTINE VRINTR(
          REAL (*) RX
          INTEGER N
          INTEGER JX
      )

/*****************************************************
 * math2/intrlib/vcintr.f
 ****************************************************/
/* 
 *      SUBROUTINE VCINTR(CX,N,JX)
 *      COMPLEX CX(*),CMISS,CD,C1
 */
      SUBROUTINE VCINTR(
          COMPLEX (*) CX
          INTEGER N
          INTEGER JX
      )

/*****************************************************
 * math2/rnmlib/vrrnm.f
 ****************************************************/
/* 
 *      SUBROUTINE VRRNM(RX,RY,N,JX,JY,NB)
 *      REAL      RX(*),RY(*)
 */
      SUBROUTINE VRRNM(
          REAL (*) RX
          REAL (*) RY
          INTEGER N
          INTEGER JX
          INTEGER JY
          INTEGER NB
      )

/*****************************************************
 * math2/rnmlib/vrrnm0.f
 ****************************************************/
/* 
 *      SUBROUTINE VRRNM0(RX,RY,N,JX,JY,NB)
 *      REAL      RX(*),RY(*)
 */
      SUBROUTINE VRRNM0(
          REAL (*) RX
          REAL (*) RY
          INTEGER N
          INTEGER JX
          INTEGER JY
          INTEGER NB
      )

/*****************************************************
 * math2/rnmlib/vrrnm1.f
 ****************************************************/
/* 
 *      SUBROUTINE VRRNM1(RX,RY,N,JX,JY,NB)
 *      REAL      RX(*),RY(*)
 */
      SUBROUTINE VRRNM1(
          REAL (*) RX
          REAL (*) RY
          INTEGER N
          INTEGER JX
          INTEGER JY
          INTEGER NB
      )

/*****************************************************
 * math2/shtlib/shtlib.f
 ****************************************************/
/* 
 *      SUBROUTINE SHTLIB
 */
      SUBROUTINE SHTLIB(
      )

/* 
 *      ENTRY SHTINT(MM,JM,IM,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTINT(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL (*) Q
      )

/* 
 *      ENTRY SHTLAP(MM,IND,A,B)
 *      REAL WJ(*),GJ(*),A(*),B(*)
 */
      SUBROUTINE SHTLAP(
          INTEGER MM
          INTEGER IND
          REAL (*) A
          REAL (*) B
      )

/* 
 *      ENTRY SHTNML(MM,N,M,LR,LI)
 */
      SUBROUTINE SHTNML(
          INTEGER MM
          INTEGER N
          INTEGER M
          INTEGER LR
          INTEGER LI
      )

/* 
 *      ENTRY SHTFUN(MM,JM,M,FUN,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTFUN(
          INTEGER MM
          INTEGER JM
          INTEGER M
          REAL (*) FUN
          REAL (*) Q
      )

/* 
 *      ENTRY SHTLFW(MM,JM,M,ISW,WM,SM,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTLFW(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (*) WM
          REAL (*) SM
          REAL (*) Q
      )

/* 
 *      ENTRY SHTLBW(MM,JM,M,ISW,SM,WM,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTLBW(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (*) SM
          REAL (*) WM
          REAL (*) Q
      )

/* 
 *      ENTRY SHTS2W(MM,JM,ISW,S,W,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTS2W(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL S
          REAL W
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSWA(MM,JM,ISW,M1,M2,S,W,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSWA(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER M1
          INTEGER M2
          REAL S
          REAL W
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSWZ(MM,JM,ISW,S,WZ,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSWZ(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL S
          REAL (*) WZ
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSWM(MM,JM,M,ISW,S,WR,WI,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSWM(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL S
          REAL (*) WR
          REAL (*) WI
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSWJ(MM,JM,ISW,J,M1,M2,S,WJ,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 *      REAL WJ(*),GJ(*),A(*),B(*)
 */
      SUBROUTINE SHTSWJ(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER J
          INTEGER M1
          INTEGER M2
          REAL S
          REAL (*) WJ
          REAL (*) Q
      )

/* 
 *      ENTRY SHTW2S(MM,JM,ISW,S,W,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTW2S(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL S
          REAL W
          REAL (*) Q
      )

/* 
 *      ENTRY SHTW2G(MM,JM,IM,W,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTW2G(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL W
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTWGA(MM,JM,IM,M1,M2,W,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTWGA(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER M1
          INTEGER M2
          REAL W
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTWGM(MM,JM,IM,M,WR,WI,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTWGM(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER M
          REAL (*) WR
          REAL (*) WI
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTWGZ(JM,IM,WZ,G)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTWGZ(
          INTEGER JM
          INTEGER IM
          REAL (*) WZ
          REAL (*) G
      )

/* 
 *      ENTRY SHTWGJ(MM,IM,M1,M2,WJ,GJ,Q)
 *      REAL WJ(*),GJ(*),A(*),B(*)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTWGJ(
          INTEGER MM
          INTEGER IM
          INTEGER M1
          INTEGER M2
          REAL (*) WJ
          REAL (*) GJ
          REAL (*) Q
      )

/* 
 *      ENTRY SHTG2W(MM,JM,IM,G,W,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTG2W(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL (*) G
          REAL W
          REAL (*) Q
      )

/* 
 *      ENTRY SHTS2G(MM,JM,IM,ISW,S,W,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTS2G(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER ISW
          REAL S
          REAL W
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSGA(MM,JM,IM,ISW,M1,M2,S,W,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSGA(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER ISW
          INTEGER M1
          INTEGER M2
          REAL S
          REAL W
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSGZ(MM,JM,IM,ISW,S,WZ,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSGZ(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER ISW
          REAL S
          REAL (*) WZ
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSGM(MM,JM,IM,M,ISW,S,WR,WI,G,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTSGM(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER M
          INTEGER ISW
          REAL S
          REAL (*) WR
          REAL (*) WI
          REAL (*) G
          REAL (*) Q
      )

/* 
 *      ENTRY SHTSGJ(MM,JM,IM,ISW,J,M1,M2,S,WJ,GJ,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 *      REAL WJ(*),GJ(*),A(*),B(*)
 */
      SUBROUTINE SHTSGJ(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER ISW
          INTEGER J
          INTEGER M1
          INTEGER M2
          REAL S
          REAL (*) WJ
          REAL (*) GJ
          REAL (*) Q
      )

/* 
 *      ENTRY SHTG2S(MM,JM,IM,ISW,G,W,S,Q)
 *      REAL Q(*),FUN(*),S(*),W(*),G(*),SM(*),WM(*),WZ(*),WR(*),WI(*)
 */
      SUBROUTINE SHTG2S(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER ISW
          REAL (*) G
          REAL W
          REAL S
          REAL (*) Q
      )

/*****************************************************
 * math2/shtlib/shinit.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIT(MM,JM,IM,Y,YS,YC,X,XS,XC,XW,Z,PY,PX,R,WFFT)
 *      REAL Y(0:JM),YS(0:JM),YC(0:JM)
 *      REAL X(0:JM),XS(0:JM),XC(0:JM),XW(0:JM)
 *      REAL Z(JM,0:JM,4)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL PX(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 *      REAL WFFT(*)
 */
      SUBROUTINE SHINIT(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL Y
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL X
          REAL (0:JM) XS
          REAL (0:JM) XC
          REAL (0:JM) XW
          REAL (JM,0:JM,4) Z
          REAL (2,0:JM,0:MM) PY
          REAL (2,0:JM,0:MM) PX
          REAL ((MM+1)*(MM+1)) R
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shinix.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIX(JM,X,XS,XC,XW)
 *      IMPLICIT REAL*8(A-H,O-Z)
 *      REAL X(0:JM),XS(0:JM),XC(0:JM),XW(0:JM)
 */
      SUBROUTINE SHINIX(
          INTEGER JM
          REAL X
          REAL (0:JM) XS
          REAL (0:JM) XC
          REAL (0:JM) XW
      )

/*****************************************************
 * math2/shtlib/shiniy.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIY(JM,Y,YS,YC)
 *      REAL Y(0:JM),YS(0:JM),YC(0:JM)
 */
      SUBROUTINE SHINIY(
          INTEGER JM
          REAL Y
          REAL (0:JM) YS
          REAL (0:JM) YC
      )

/*****************************************************
 * math2/shtlib/shiniz.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIZ(JM,X,Y,Z)
 *      REAL X(0:JM),Y(0:JM)
 *      REAL Z(JM,0:JM,4)
 */
      SUBROUTINE SHINIZ(
          INTEGER JM
          REAL (0:JM) X
          REAL (0:JM) Y
          REAL (JM,0:JM,4) Z
      )

/*****************************************************
 * math2/shtlib/shinip.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIP(MM,JM,YS,YC,PY)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 */
      SUBROUTINE SHINIP(
          INTEGER MM
          INTEGER JM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
      )

/*****************************************************
 * math2/shtlib/shinic.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIC(MM,JM,XW,PX)
 *      REAL XW(0:JM),PX(2,0:JM,0:MM)
 */
      SUBROUTINE SHINIC(
          INTEGER MM
          INTEGER JM
          REAL (0:JM) XW
          REAL (2,0:JM,0:MM) PX
      )

/*****************************************************
 * math2/shtlib/shinir.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIR(MM,R)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHINIR(
          INTEGER MM
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shinif.f
 ****************************************************/
/* 
 *      SUBROUTINE SHINIF(NFFT,WFFT) 
 *      REAL WFFT(*)
 */
      SUBROUTINE SHINIF(
          INTEGER NFFT
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shnm2l.f
 ****************************************************/
/* 
 *      SUBROUTINE SHNM2L(MM,N,M,LR,LI)
 */
      SUBROUTINE SHNM2L(
          INTEGER MM
          INTEGER N
          INTEGER M
          INTEGER LR
          INTEGER LI
      )

/*****************************************************
 * math2/shtlib/sholap.f
 ****************************************************/
/* 
 *      SUBROUTINE SHOLAP(MM,IND,A,B)
 *      REAL A((MM+1)*(MM+1)),B((MM+1)*(MM+1))
 */
      SUBROUTINE SHOLAP(
          INTEGER MM
          INTEGER IND
          REAL ((MM+1)*(MM+1)) A
          REAL ((MM+1)*(MM+1)) B
      )

/*****************************************************
 * math2/shtlib/shfw2g.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFW2G(MM,JM,IM,W,G,H,WFFT)
 *      REAL W(-JM:JM,-MM:MM),G(-IM:IM,-JM:JM)
 *      REAL H(0:2*IM-1)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFW2G(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL (-JM:JM,-MM:MM) W
          REAL (-IM:IM,-JM:JM) G
          REAL (0:2*IM-1) H
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfwga.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFWGA(MM,JM,IM,M1,M2,W,G,H,WFFT)
 *      REAL W(-JM:JM,-MM:MM),G(-IM:IM,-JM:JM)
 *      REAL H(0:2*IM-1)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFWGA(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          INTEGER M1
          INTEGER M2
          REAL (-JM:JM,-MM:MM) W
          REAL (-IM:IM,-JM:JM) G
          REAL (0:2*IM-1) H
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfwgm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFWGM(JM,IM,M,WR,WI,G,H,WFFT)
 *      REAL WR(-JM:JM),WI(-JM:JM),G(-IM:IM,-JM:JM)
 *      REAL H(0:2*IM-1)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFWGM(
          INTEGER JM
          INTEGER IM
          INTEGER M
          REAL (-JM:JM) WR
          REAL (-JM:JM) WI
          REAL (-IM:IM,-JM:JM) G
          REAL (0:2*IM-1) H
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfwgz.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFWGZ(JM,IM,WZ,G)
 *      REAL WZ(-JM:JM),G(-IM:IM,-JM:JM)
 */
      SUBROUTINE SHFWGZ(
          INTEGER JM
          INTEGER IM
          REAL (-JM:JM) WZ
          REAL (-IM:IM,-JM:JM) G
      )

/*****************************************************
 * math2/shtlib/shfwgj.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFWGJ(MM,IM,M1,M2,WJ,GJ,H,WFFT)
 *      REAL WJ(-MM:MM),GJ(-IM:IM)
 *      REAL H(0:2*IM-1)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFWGJ(
          INTEGER MM
          INTEGER IM
          INTEGER M1
          INTEGER M2
          REAL (-MM:MM) WJ
          REAL (-IM:IM) GJ
          REAL (0:2*IM-1) H
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfg2w.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFG2W(MM,JM,IM,G,W,H,WFFT)
 *      REAL G(-IM:IM,-JM:JM),W(-JM:JM,-MM:MM)
 *      REAL H(0:2*IM-1)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFG2W(
          INTEGER MM
          INTEGER JM
          INTEGER IM
          REAL (-IM:IM,-JM:JM) G
          REAL (-JM:JM,-MM:MM) W
          REAL (0:2*IM-1) H
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfftf.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFFTF(NFFT,XFFT,WFFT)
 *      REAL XFFT(NFFT)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFFTF(
          INTEGER NFFT
          REAL (NFFT) XFFT
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shfftb.f
 ****************************************************/
/* 
 *      SUBROUTINE SHFFTB(NFFT,XFFT,WFFT)
 *      REAL XFFT(NFFT)
 *      REAL WFFT(*)
 */
      SUBROUTINE SHFFTB(
          INTEGER NFFT
          REAL (NFFT) XFFT
          REAL (*) WFFT
      )

/*****************************************************
 * math2/shtlib/shms2w.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMS2W(MM,JM,ISW,S,W,SD,PM,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),W(-JM:JM,-MM:MM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMS2W(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL ((MM+1)*(MM+1)) S
          REAL (-JM:JM,-MM:MM) W
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmswa.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMSWA(MM,JM,ISW,M1,M2,S,W,SD,PM,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),W(-JM:JM,-MM:MM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMSWA(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER M1
          INTEGER M2
          REAL ((MM+1)*(MM+1)) S
          REAL (-JM:JM,-MM:MM) W
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmswz.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMSWZ(MM,JM,ISW,S,WZ,SD,PM,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),WZ(-JM:JM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMSWZ(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL ((MM+1)*(MM+1)) S
          REAL (-JM:JM) WZ
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmswm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMSWM(MM,JM,M,ISW,S,WR,WI,SD,PM,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),WR(-JM:JM),WI(-JM:JM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMSWM(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL ((MM+1)*(MM+1)) S
          REAL (-JM:JM) WR
          REAL (-JM:JM) WI
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmdxm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMDXM(JM,WR,WI)
 *      REAL WR(-JM:JM),WI(-JM:JM)
 */
      SUBROUTINE SHMDXM(
          INTEGER JM
          REAL (-JM:JM) WR
          REAL (-JM:JM) WI
      )

/*****************************************************
 * math2/shtlib/shmswj.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMSWJ(MM,JM,ISW,J,M1,M2,S,WJ,SD,PMJ,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),WJ(-MM:MM)
 *      REAL SD(0:MM+1),PMJ(0:MM+1)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMSWJ(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER J
          INTEGER M1
          INTEGER M2
          REAL ((MM+1)*(MM+1)) S
          REAL (-MM:MM) WJ
          REAL (0:MM+1) SD
          REAL (0:MM+1) PMJ
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmwjz.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMWJZ(MM,JM,ISW,J,S,WJD,SD,PMJ,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),WJD
 *      REAL SD(0:MM+1),PMJ(0:MM+1)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMWJZ(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER J
          REAL ((MM+1)*(MM+1)) S
          REAL WJD
          REAL (0:MM+1) SD
          REAL (0:MM+1) PMJ
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmwjm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMWJM(MM,JM,ISW,J,M,S,WJR,WJI,SD,PMJ,YS,YC,PY,R)
 *      REAL S((MM+1)*(MM+1)),WJR,WJI
 *      REAL SD(0:MM+1),PMJ(0:MM+1)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHMWJM(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          INTEGER J
          INTEGER M
          REAL ((MM+1)*(MM+1)) S
          REAL WJR
          REAL WJI
          REAL (0:MM+1) SD
          REAL (0:MM+1) PMJ
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shmdxj.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMDXJ(WRD,WID)
 *      REAL WRD,WID
 */
      SUBROUTINE SHMDXJ(
          REAL WRD
          REAL WID
      )

/*****************************************************
 * math2/shtlib/shmw2s.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMW2S(MM,JM,ISW,W,S,SD,PM,XS,XC,PX,WY,WX,R,Z)
 *      REAL W(-JM:JM,-MM:MM),S((MM+1)*(MM+1))
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL XS(0:JM),XC(0:JM)
 *      REAL PX(2,0:JM,0:MM)
 *      REAL WY(0:JM,2),WX(0:JM,2)
 *      REAL R((MM+1)*(MM+1)),Z(JM,0:JM,4)
 */
      SUBROUTINE SHMW2S(
          INTEGER MM
          INTEGER JM
          INTEGER ISW
          REAL (-JM:JM,-MM:MM) W
          REAL ((MM+1)*(MM+1)) S
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) XS
          REAL (0:JM) XC
          REAL (2,0:JM,0:MM) PX
          REAL (0:JM,2) WY
          REAL (0:JM,2) WX
          REAL ((MM+1)*(MM+1)) R
          REAL (JM,0:JM,4) Z
      )

/*****************************************************
 * math2/shtlib/shmsri.f
 ****************************************************/
/* 
 *      SUBROUTINE SHMSRI(MM,M,SR,SI)
 *      REAL SR(M:MM),SI(M:MM)
 */
      SUBROUTINE SHMSRI(
          INTEGER MM
          INTEGER M
          REAL (M:MM) SR
          REAL (M:MM) SI
      )

/*****************************************************
 * math2/shtlib/shlfwu.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLFWU(MM,JM,M,ISW,WM,SM,SD,XS,XC,PM,WY,WX,PX,R,Z)
 *      REAL SM(M:MM),WM(-JM:JM)
 *      REAL SD(0:MM+1)
 *      REAL XS(0:JM),XC(0:JM)
 *      REAL PM(0:MM+1,0:JM)
 *      REAL WY(0:JM,2),WX(0:JM,2)
 *      REAL PX(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1)),Z(JM,0:JM,4)
 */
      SUBROUTINE SHLFWU(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (-JM:JM) WM
          REAL (M:MM) SM
          REAL (0:MM+1) SD
          REAL (0:JM) XS
          REAL (0:JM) XC
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM,2) WY
          REAL (0:JM,2) WX
          REAL (2,0:JM,0:MM) PX
          REAL ((MM+1)*(MM+1)) R
          REAL (JM,0:JM,4) Z
      )

/*****************************************************
 * math2/shtlib/shlfwm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLFWM(MM,JM,M,ISW,WM,SM,SD,XC,PM,WY,WX,R,Z)
 *      REAL SM(M:MM),WM(-JM:JM)
 *      REAL SD(0:MM+1)
 *      REAL XC(0:JM)
 *      REAL PM(0:MM+1,0:JM)
 *      REAL WY(0:JM,2),WX(0:JM,2)
 *      REAL R((MM+1)*(MM+1)),Z(JM,0:JM,4)
 */
      SUBROUTINE SHLFWM(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (-JM:JM) WM
          REAL (M:MM) SM
          REAL (0:MM+1) SD
          REAL (0:JM) XC
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM,2) WY
          REAL (0:JM,2) WX
          REAL ((MM+1)*(MM+1)) R
          REAL (JM,0:JM,4) Z
      )

/*****************************************************
 * math2/shtlib/shlfwl.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLFWL(MM,JM,N,M,WX,SD,PM)
 *      REAL WX(0:JM,2)
 *      REAL SD,PM(0:MM+1,0:JM)
 */
      SUBROUTINE SHLFWL(
          INTEGER MM
          INTEGER JM
          INTEGER N
          INTEGER M
          REAL (0:JM,2) WX
          REAL SD
          REAL (0:MM+1,0:JM) PM
      )

/*****************************************************
 * math2/shtlib/shly2x.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLY2X(JM,M,ISW,WM,WX,WY,Z)
 *      REAL WM(-JM:JM)
 *      REAL WY(0:JM,2),WX(0:JM,2)
 *      REAL Z(JM,0:JM,4)
 */
      SUBROUTINE SHLY2X(
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (-JM:JM) WM
          REAL (0:JM,2) WX
          REAL (0:JM,2) WY
          REAL (JM,0:JM,4) Z
      )

/*****************************************************
 * math2/shtlib/shlbwu.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLBWU(MM,JM,M,ISW,SM,WM,SD,PM,YS,YC,PY,R)
 *      REAL SM(M:MM)
 *      REAL WM(-JM:JM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM)
 *      REAL PY(2,0:JM,0:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHLBWU(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (M:MM) SM
          REAL (-JM:JM) WM
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shlbwm.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLBWM(MM,JM,M,ISW,SM,WM,SD,PM,YC,R)
 *      REAL SM(M:MM)
 *      REAL WM(-JM:JM)
 *      REAL SD(0:MM+1),PM(0:MM+1,0:JM)
 *      REAL YC(0:JM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHLBWM(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER ISW
          REAL (M:MM) SM
          REAL (-JM:JM) WM
          REAL (0:MM+1) SD
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YC
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shlbwj.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLBWJ(MM,JM,M,J,ISW,SM,WMJ,SD,PMJ,YC,R)
 *      REAL SM(M:MM),WMJ
 *      REAL SD(0:MM+1),PMJ(0:MM+1)
 *      REAL YC(0:JM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHLBWJ(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER J
          INTEGER ISW
          REAL (M:MM) SM
          REAL WMJ
          REAL (0:MM+1) SD
          REAL (0:MM+1) PMJ
          REAL (0:JM) YC
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shlbwl.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLBWL(MM,M,SD,WS,WA,PMJ)
 *      REAL SD(0:MM+1)
 *      REAL WS,WA
 *      REAL PMJ(0:MM+1)
 */
      SUBROUTINE SHLBWL(
          INTEGER MM
          INTEGER M
          REAL (0:MM+1) SD
          REAL WS
          REAL WA
          REAL (0:MM+1) PMJ
      )

/*****************************************************
 * math2/shtlib/shlssd.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLSSD(MM,M,ISW,SM,SD,R)
 *      REAL SM(M:MM)
 *      REAL SD(0:MM+1)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHLSSD(
          INTEGER MM
          INTEGER M
          INTEGER ISW
          REAL (M:MM) SM
          REAL (0:MM+1) SD
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shlsds.f
 ****************************************************/
/* 
 *      SUBROUTINE SHLSDS(MM,M,ISW,SD,SM,R)
 *      REAL SD(0:MM+1)
 *      REAL SM(M:MM)
 *      REAL R((MM+1)*(MM+1))
 */
      SUBROUTINE SHLSDS(
          INTEGER MM
          INTEGER M
          INTEGER ISW
          REAL (0:MM+1) SD
          REAL (M:MM) SM
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shpfun.f
 ****************************************************/
/* 
 *      SUBROUTINE SHPFUN(MM,JM,M,FUN,PM,YS,YC,PY,R)
 *      REAL FUN(-JM:JM,M:MM)
 *      REAL PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),YC(0:JM),PY(2,0:JM,0:MM),R((MM+1)*(MM+1))
 */
      SUBROUTINE SHPFUN(
          INTEGER MM
          INTEGER JM
          INTEGER M
          REAL (-JM:JM,M:MM) FUN
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (0:JM) YC
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shppma.f
 ****************************************************/
/* 
 *      SUBROUTINE SHPPMA(MM,JM,M,PM,YS,PY,R)
 *      REAL PM(0:MM+1,0:JM)
 *      REAL YS(0:JM),PY(2,0:JM,0:MM),R((MM+1)*(MM+1))
 */
      SUBROUTINE SHPPMA(
          INTEGER MM
          INTEGER JM
          INTEGER M
          REAL (0:MM+1,0:JM) PM
          REAL (0:JM) YS
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/shtlib/shppmj.f
 ****************************************************/
/* 
 *      SUBROUTINE SHPPMJ(MM,JM,M,J,PMJ,YS,PY,R)
 *      REAL PMJ(0:MM+1)
 *      REAL YS(0:JM),PY(2,0:JM,0:MM),R((MM+1)*(MM+1))
 */
      SUBROUTINE SHPPMJ(
          INTEGER MM
          INTEGER JM
          INTEGER M
          INTEGER J
          REAL (0:MM+1) PMJ
          REAL (0:JM) YS
          REAL (2,0:JM,0:MM) PY
          REAL ((MM+1)*(MM+1)) R
      )

/*****************************************************
 * math2/odelib/odrk1.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRK1(N, FCN, T, DT, X, DX, XOUT, WORK)
 *      DIMENSION  X(N), XOUT(N), DX(N)
 */
      SUBROUTINE ODRK1(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL (N) X
          REAL (N) DX
          REAL (N) XOUT
          REAL WORK
      )

/*****************************************************
 * math2/odelib/odrk2.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRK2(N, FCN, T, DT, X, DX, XOUT, WORK)
 *      DIMENSION  X(N), XOUT(N), DX(N), WORK(N)
 */
      SUBROUTINE ODRK2(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL (N) X
          REAL (N) DX
          REAL (N) XOUT
          REAL (N) WORK
      )

/*****************************************************
 * math2/odelib/odrk4.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRK4(N, FCN, T, DT, X, DX, XOUT, WORK)
 *      DIMENSION  X(N), XOUT(N), DX(N), WORK(N,3)
 */
      SUBROUTINE ODRK4(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL (N) X
          REAL (N) DX
          REAL (N) XOUT
          REAL (N,3) WORK
      )

/*****************************************************
 * math2/odelib/odrk4r.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRK4R(N, FCN, T, DT, EPSL, X, WORK)
 *      DIMENSION X(N), WORK(N,7)
 */
      SUBROUTINE ODRK4R(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL EPSL
          REAL (N) X
          REAL (N,7) WORK
      )

/*****************************************************
 * math2/odelib/odrk4s.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRK4S(N, FCN, T, DT, EPSL, X, WORK)
 *      DIMENSION X(N), WORK(N,5)
 */
      SUBROUTINE ODRK4S(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL EPSL
          REAL (N) X
          REAL (N,5) WORK
      )

/*****************************************************
 * math2/odelib/odrkdu.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRKDU(N, ALGR, FCN, T, TEND, ISTEP, X, WORK)
 *      DIMENSION  X(N), WORK(N,*)
 */
      SUBROUTINE ODRKDU(
          INTEGER N
          REAL ALGR
          REAL FCN
          REAL T
          REAL TEND
          INTEGER ISTEP
          REAL (N) X
          REAL (N,*) WORK
      )

/*****************************************************
 * math2/odelib/odrkdv.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRKDV(N, STEPER, FCN, T, TEND, DT, X, WORK)
 *      DIMENSION X(N), WORK(N,*)
 */
      SUBROUTINE ODRKDV(
          INTEGER N
          REAL STEPER
          REAL FCN
          REAL T
          REAL TEND
          REAL DT
          REAL (N) X
          REAL (N,*) WORK
      )

/*****************************************************
 * math2/odelib/odrkg.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRKG(N, FCN, T, DT, X, DX, XOUT, WORK)
 *      DIMENSION  X(N), DX(N), XOUT(N), WORK(N)
 */
      SUBROUTINE ODRKG(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL X
          REAL (N) DX
          REAL (N) XOUT
          REAL (N) WORK
      )

/*****************************************************
 * math2/odelib/odrkgr.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRKGR(N, FCN, T, DT, EPSL, X, WORK)
 *      DIMENSION X(N), WORK(N,5)
 */
      SUBROUTINE ODRKGR(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL EPSL
          REAL (N) X
          REAL (N,5) WORK
      )

/*****************************************************
 * math2/odelib/odrkgs.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRKGS(N, FCN, T, DT, EPSL, X, WORK)
 *      DIMENSION X(N), WORK(N,3)
 */
      SUBROUTINE ODRKGS(
          INTEGER N
          REAL FCN
          REAL T
          REAL DT
          REAL EPSL
          REAL (N) X
          REAL (N,3) WORK
      )

/*****************************************************
 * math2/odelib/odiget.f
 ****************************************************/
/* 
 *      SUBROUTINE ODIGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ODIGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

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

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

/*****************************************************
 * math2/odelib/odiqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ODIQNP(NCP)
 */
      SUBROUTINE ODIQNP(
          INTEGER NCP
      )

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

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

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

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

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

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

/*****************************************************
 * math2/odelib/odlget.f
 ****************************************************/
/* 
 *      SUBROUTINE ODLGET(CP, LPARA)
 *      CHARACTER CP*(*)
 *      LOGICAL   LPARA
 */
      SUBROUTINE ODLGET(
          CHARACTER*(*) CP
          LOGICAL LPARA
      )

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

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

/*****************************************************
 * math2/odelib/odlqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ODLQNP(NCP)
 */
      SUBROUTINE ODLQNP(
          INTEGER NCP
      )

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

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

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

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

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

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

/*****************************************************
 * math2/odelib/odpget.f
 ****************************************************/
/* 
 *      SUBROUTINE ODPGET(CP, IPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ODPGET(
          CHARACTER*(*) CP
          INTEGER IPARA
      )

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

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

/*****************************************************
 * math2/odelib/odpqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ODPQNP(NCP)
 */
      SUBROUTINE ODPQNP(
          INTEGER NCP
      )

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

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

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

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

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

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

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

/*****************************************************
 * math2/odelib/odrget.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRGET(CP, RPARA)
 *      CHARACTER CP*(*)
 */
      SUBROUTINE ODRGET(
          CHARACTER*(*) CP
          REAL RPARA
      )

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

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

/*****************************************************
 * math2/odelib/odrqnp.f
 ****************************************************/
/* 
 *      SUBROUTINE ODRQNP(NCP)
 */
      SUBROUTINE ODRQNP(
          INTEGER NCP
      )

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

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

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

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

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

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