subroutine ssymm ( side, uplo, m, n, alpha, a, lda, b, ldb,
     $                   beta, c, ldc )
*     .. scalar arguments ..
      character*1        side, uplo
      integer            m, n, lda, ldb, ldc
      real               alpha, beta
*     .. array arguments ..
      real               a( lda, * ), b( ldb, * ), c( ldc, * )
*     ..
*
*  purpose
*  =======
*
*  ssymm  performs one of the matrix-matrix operations
*
*     c := alpha*a*b + beta*c,
*
*  or
*
*     c := alpha*b*a + beta*c,
*
*  where alpha and beta are scalars,  a is a symmetric matrix and  b and
*  c are  m by n matrices.
*
*  parameters
*  ==========
*
*  side   - character*1.
*           on entry,  side  specifies whether  the  symmetric matrix  a
*           appears on the  left or right  in the  operation as follows:
*
*              side = 'l' or 'l'   c := alpha*a*b + beta*c,
*
*              side = 'r' or 'r'   c := alpha*b*a + beta*c,
*
*           unchanged on exit.
*
*  uplo   - character*1.
*           on  entry,   uplo  specifies  whether  the  upper  or  lower
*           triangular  part  of  the  symmetric  matrix   a  is  to  be
*           referenced as follows:
*
*              uplo = 'u' or 'u'   only the upper triangular part of the
*                                  symmetric matrix is to be referenced.
*
*              uplo = 'l' or 'l'   only the lower triangular part of the
*                                  symmetric matrix is to be referenced.
*
*           unchanged on exit.
*
*  m      - integer.
*           on entry,  m  specifies the number of rows of the matrix  c.
*           m  must be at least zero.
*           unchanged on exit.
*
*  n      - integer.
*           on entry, n specifies the number of columns of the matrix c.
*           n  must be at least zero.
*           unchanged on exit.
*
*  alpha  - real            .
*           on entry, alpha specifies the scalar alpha.
*           unchanged on exit.
*
*  a      - real             array of dimension ( lda, ka ), where ka is
*           m  when  side = 'l' or 'l'  and is  n otherwise.
*           before entry  with  side = 'l' or 'l',  the  m by m  part of
*           the array  a  must contain the  symmetric matrix,  such that
*           when  uplo = 'u' or 'u', the leading m by m upper triangular
*           part of the array  a  must contain the upper triangular part
*           of the  symmetric matrix and the  strictly  lower triangular
*           part of  a  is not referenced,  and when  uplo = 'l' or 'l',
*           the leading  m by m  lower triangular part  of the  array  a
*           must  contain  the  lower triangular part  of the  symmetric
*           matrix and the  strictly upper triangular part of  a  is not
*           referenced.
*           before entry  with  side = 'r' or 'r',  the  n by n  part of
*           the array  a  must contain the  symmetric matrix,  such that
*           when  uplo = 'u' or 'u', the leading n by n upper triangular
*           part of the array  a  must contain the upper triangular part
*           of the  symmetric matrix and the  strictly  lower triangular
*           part of  a  is not referenced,  and when  uplo = 'l' or 'l',
*           the leading  n by n  lower triangular part  of the  array  a
*           must  contain  the  lower triangular part  of the  symmetric
*           matrix and the  strictly upper triangular part of  a  is not
*           referenced.
*           unchanged on exit.
*
*  lda    - integer.
*           on entry, lda specifies the first dimension of a as declared
*           in the calling (sub) program.  when  side = 'l' or 'l'  then
*           lda must be at least  max( 1, m ), otherwise  lda must be at
*           least  max( 1, n ).
*           unchanged on exit.
*
*  b      - real             array of dimension ( ldb, n ).
*           before entry, the leading  m by n part of the array  b  must
*           contain the matrix b.
*           unchanged on exit.
*
*  ldb    - integer.
*           on entry, ldb specifies the first dimension of b as declared
*           in  the  calling  (sub)  program.   ldb  must  be  at  least
*           max( 1, m ).
*           unchanged on exit.
*
*  beta   - real            .
*           on entry,  beta  specifies the scalar  beta.  when  beta  is
*           supplied as zero then c need not be set on input.
*           unchanged on exit.
*
*  c      - real             array of dimension ( ldc, n ).
*           before entry, the leading  m by n  part of the array  c must
*           contain the matrix  c,  except when  beta  is zero, in which
*           case c need not be set on entry.
*           on exit, the array  c  is overwritten by the  m by n updated
*           matrix.
*
*  ldc    - integer.
*           on entry, ldc specifies the first dimension of c as declared
*           in  the  calling  (sub)  program.   ldc  must  be  at  least
*           max( 1, m ).
*           unchanged on exit.
*
*
*  level 3 blas routine.
*
*  -- written on 8-february-1989.
*     jack dongarra, argonne national laboratory.
*     iain duff, aere harwell.
*     jeremy du croz, numerical algorithms group ltd.
*     sven hammarling, numerical algorithms group ltd.
*