    FOREIGN MODULE java_security;

    IMPORT
        sun_security_util,
        java_lang,
        java_io,
        java_security_spec,
        java_util,
        java_net,
        java_security_cert,
        sun_misc;

    TYPE

      AccessControlContext* = POINTER TO RECORD (java_lang.Object)
                              STATIC
                                PROCEDURE Init*(IN  p0 : ARRAY OF ProtectionDomain) : AccessControlContext,CONSTRUCTOR;
                              END;

      AccessControlException* = POINTER TO EXTENSIBLE RECORD (java_lang.SecurityException)
                                STATIC
                                  PROCEDURE Init*(p0 : java_lang.String) : AccessControlException,CONSTRUCTOR;
                                  PROCEDURE Init*(p0 : java_lang.String;
                                                  p1 : Permission) : AccessControlException,CONSTRUCTOR;
                                END;

      AccessController* = POINTER TO RECORD (java_lang.Object)
                          STATIC
                            PROCEDURE checkPermission*(p0 : Permission);
                            PROCEDURE doPrivileged*(p0 : PrivilegedAction) : java_lang.Object;
                            PROCEDURE doPrivileged*(p0 : PrivilegedAction;
                                                    p1 : AccessControlContext) : java_lang.Object;
                            PROCEDURE doPrivileged*(p0 : PrivilegedExceptionAction) : java_lang.Object;
                            PROCEDURE doPrivileged*(p0 : PrivilegedExceptionAction;
                                                    p1 : AccessControlContext) : java_lang.Object;
                            PROCEDURE getContext*() : AccessControlContext;
                          END;

      AlgorithmParameterGenerator* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                                     STATIC
                                       PROCEDURE Init!(p0 : AlgorithmParameterGeneratorSpi;
                                                       p1 : Provider;
                                                       p2 : java_lang.String) : AlgorithmParameterGenerator,CONSTRUCTOR;
                                       PROCEDURE getInstance*(p0 : java_lang.String) : AlgorithmParameterGenerator;
                                       PROCEDURE getInstance*(p0 : java_lang.String;
                                                              p1 : java_lang.String) : AlgorithmParameterGenerator;
                                     END;

      AlgorithmParameterGeneratorSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                                        STATIC
                                          PROCEDURE Init*() : AlgorithmParameterGeneratorSpi,CONSTRUCTOR;
                                        END;

      AlgorithmParameters* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                             STATIC
                               PROCEDURE Init!(p0 : AlgorithmParametersSpi;
                                               p1 : Provider;
                                               p2 : java_lang.String) : AlgorithmParameters,CONSTRUCTOR;
                               PROCEDURE getInstance*(p0 : java_lang.String) : AlgorithmParameters;
                               PROCEDURE getInstance*(p0 : java_lang.String;
                                                      p1 : java_lang.String) : AlgorithmParameters;
                             END;

      AlgorithmParametersSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                                STATIC
                                  PROCEDURE Init*() : AlgorithmParametersSpi,CONSTRUCTOR;
                                END;

      AllPermission* = POINTER TO RECORD (Permission)
                       STATIC
                         PROCEDURE Init*() : AllPermission,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : java_lang.String;
                                         p1 : java_lang.String) : AllPermission,CONSTRUCTOR;
                       END;

      BasicPermission* = POINTER TO ABSTRACT RECORD (Permission + java_io.Serializable)
                         STATIC
                           PROCEDURE Init*(p0 : java_lang.String) : BasicPermission,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_lang.String;
                                           p1 : java_lang.String) : BasicPermission,CONSTRUCTOR;
                         END;

      Certificate* = POINTER TO INTERFACE RECORD (java_lang.Object)
                     END;

      CodeSource* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)
                    STATIC
                      PROCEDURE Init*(    p0 : java_net.URL;
                                      IN  p1 : ARRAY OF java_security_cert.Certificate) : CodeSource,CONSTRUCTOR;
                    END;

      DigestException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                         STATIC
                           PROCEDURE Init*() : DigestException,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_lang.String) : DigestException,CONSTRUCTOR;
                         END;

      DigestInputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterInputStream)
                             digest! : MessageDigest;
                           STATIC
                             PROCEDURE Init*(p0 : java_io.InputStream;
                                             p1 : MessageDigest) : DigestInputStream,CONSTRUCTOR;
                           END;

      DigestOutputStream* = POINTER TO EXTENSIBLE RECORD (java_io.FilterOutputStream)
                              digest! : MessageDigest;
                            STATIC
                              PROCEDURE Init*(p0 : java_io.OutputStream;
                                              p1 : MessageDigest) : DigestOutputStream,CONSTRUCTOR;
                            END;

      GeneralSecurityException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)
                                  STATIC
                                    PROCEDURE Init*() : GeneralSecurityException,CONSTRUCTOR;
                                    PROCEDURE Init*(p0 : java_lang.String) : GeneralSecurityException,CONSTRUCTOR;
                                  END;

      Guard* = POINTER TO INTERFACE RECORD (java_lang.Object)
               END;

      GuardedObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)
                       STATIC
                         PROCEDURE Init*(p0 : java_lang.Object;
                                         p1 : Guard) : GuardedObject,CONSTRUCTOR;
                       END;

      Identity* = POINTER TO ABSTRACT RECORD (java_lang.Object + Principal + java_io.Serializable)
                  STATIC
                    PROCEDURE Init!() : Identity,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String) : Identity,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String;
                                    p1 : IdentityScope) : Identity,CONSTRUCTOR;
                  END;

      IdentityScope* = POINTER TO ABSTRACT RECORD (Identity)
                       STATIC
                         PROCEDURE Init!() : IdentityScope,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : java_lang.String) : IdentityScope,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : java_lang.String;
                                         p1 : IdentityScope) : IdentityScope,CONSTRUCTOR;
                         PROCEDURE getSystemScope*() : IdentityScope;
                         PROCEDURE setSystemScope!(p0 : IdentityScope);
                       END;

      InvalidAlgorithmParameterException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                                            STATIC
                                              PROCEDURE Init*() : InvalidAlgorithmParameterException,CONSTRUCTOR;
                                              PROCEDURE Init*(p0 : java_lang.String) : InvalidAlgorithmParameterException,CONSTRUCTOR;
                                            END;

      InvalidKeyException* = POINTER TO EXTENSIBLE RECORD (KeyException)
                             STATIC
                               PROCEDURE Init*() : InvalidKeyException,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : java_lang.String) : InvalidKeyException,CONSTRUCTOR;
                             END;

      InvalidParameterException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalArgumentException)
                                   STATIC
                                     PROCEDURE Init*() : InvalidParameterException,CONSTRUCTOR;
                                     PROCEDURE Init*(p0 : java_lang.String) : InvalidParameterException,CONSTRUCTOR;
                                   END;

      Key* = POINTER TO INTERFACE RECORD (java_lang.Object + java_io.Serializable)
             STATIC
               serialVersionUID* = 6603384152749567654;
             END;

      KeyException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                      STATIC
                        PROCEDURE Init*() : KeyException,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : java_lang.String) : KeyException,CONSTRUCTOR;
                      END;

      KeyFactory* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                    STATIC
                      PROCEDURE Init!(p0 : KeyFactorySpi;
                                      p1 : Provider;
                                      p2 : java_lang.String) : KeyFactory,CONSTRUCTOR;
                      PROCEDURE getInstance*(p0 : java_lang.String) : KeyFactory;
                      PROCEDURE getInstance*(p0 : java_lang.String;
                                             p1 : java_lang.String) : KeyFactory;
                    END;

      KeyFactorySpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                       STATIC
                         PROCEDURE Init*() : KeyFactorySpi,CONSTRUCTOR;
                       END;

      KeyManagementException* = POINTER TO EXTENSIBLE RECORD (KeyException)
                                STATIC
                                  PROCEDURE Init*() : KeyManagementException,CONSTRUCTOR;
                                  PROCEDURE Init*(p0 : java_lang.String) : KeyManagementException,CONSTRUCTOR;
                                END;

      KeyPair* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)
                 STATIC
                   PROCEDURE Init*(p0 : PublicKey;
                                   p1 : PrivateKey) : KeyPair,CONSTRUCTOR;
                 END;

      KeyPairGenerator* = POINTER TO ABSTRACT RECORD (KeyPairGeneratorSpi)
                          STATIC
                            PROCEDURE Init!(p0 : java_lang.String) : KeyPairGenerator,CONSTRUCTOR;
                            PROCEDURE getInstance*(p0 : java_lang.String) : KeyPairGenerator;
                            PROCEDURE getInstance*(p0 : java_lang.String;
                                                   p1 : java_lang.String) : KeyPairGenerator;
                          END;

      KeyPairGeneratorSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                             STATIC
                               PROCEDURE Init*() : KeyPairGeneratorSpi,CONSTRUCTOR;
                             END;

      KeyStore* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                  STATIC
                    PROCEDURE Init!(p0 : KeyStoreSpi;
                                    p1 : Provider;
                                    p2 : java_lang.String) : KeyStore,CONSTRUCTOR;
                    PROCEDURE getDefaultType*() : java_lang.String;
                    PROCEDURE getInstance*(p0 : java_lang.String) : KeyStore;
                    PROCEDURE getInstance*(p0 : java_lang.String;
                                           p1 : java_lang.String) : KeyStore;
                  END;

      KeyStoreException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                           STATIC
                             PROCEDURE Init*() : KeyStoreException,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : java_lang.String) : KeyStoreException,CONSTRUCTOR;
                           END;

      KeyStoreSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                     STATIC
                       PROCEDURE Init*() : KeyStoreSpi,CONSTRUCTOR;
                     END;

      MessageDigest* = POINTER TO ABSTRACT RECORD (MessageDigestSpi)
                       STATIC
                         PROCEDURE Init!(p0 : java_lang.String) : MessageDigest,CONSTRUCTOR;
                         PROCEDURE getInstance*(p0 : java_lang.String) : MessageDigest;
                         PROCEDURE getInstance*(p0 : java_lang.String;
                                                p1 : java_lang.String) : MessageDigest;
                         PROCEDURE isEqual*(IN  p0 : ARRAY OF BYTE;
                                            IN  p1 : ARRAY OF BYTE) : BOOLEAN;
                       END;

      MessageDigestSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                          STATIC
                            PROCEDURE Init*() : MessageDigestSpi,CONSTRUCTOR;
                          END;

      NoSuchAlgorithmException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                                  STATIC
                                    PROCEDURE Init*() : NoSuchAlgorithmException,CONSTRUCTOR;
                                    PROCEDURE Init*(p0 : java_lang.String) : NoSuchAlgorithmException,CONSTRUCTOR;
                                  END;

      NoSuchProviderException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                                 STATIC
                                   PROCEDURE Init*() : NoSuchProviderException,CONSTRUCTOR;
                                   PROCEDURE Init*(p0 : java_lang.String) : NoSuchProviderException,CONSTRUCTOR;
                                 END;

      Permission* = POINTER TO ABSTRACT RECORD (java_lang.Object + Guard + java_io.Serializable)
                    STATIC
                      PROCEDURE Init*(p0 : java_lang.String) : Permission,CONSTRUCTOR;
                    END;

      PermissionCollection* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Insets)
                              STATIC
                                PROCEDURE Init*() : PermissionCollection,CONSTRUCTOR;
                              END;

      Permissions* = POINTER TO RECORD (PermissionCollection + java_awt.Insets)
                     STATIC
                       PROCEDURE Init*() : Permissions,CONSTRUCTOR;
                     END;

      Policy* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                STATIC
                  PROCEDURE Init*() : Policy,CONSTRUCTOR;
                  PROCEDURE getPolicy*() : Policy;
                  PROCEDURE setPolicy*(p0 : Policy);
                END;

      Principal* = POINTER TO INTERFACE RECORD (java_lang.Object)
                   END;

      PrivateKey* = POINTER TO INTERFACE RECORD (java_lang.Object + java_awt.Cursor)
                    STATIC
                      serialVersionUID* = 6034044314589513430;
                    END;

      PrivilegedAction* = POINTER TO INTERFACE RECORD (java_lang.Object)
                          END;

      PrivilegedActionException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)
                                   STATIC
                                     PROCEDURE Init*(p0 : java_lang.Exception) : PrivilegedActionException,CONSTRUCTOR;
                                   END;

      PrivilegedExceptionAction* = POINTER TO INTERFACE RECORD (java_lang.Object)
                                   END;

      ProtectionDomain* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                          STATIC
                            PROCEDURE Init*(p0 : CodeSource;
                                            p1 : PermissionCollection) : ProtectionDomain,CONSTRUCTOR;
                          END;

      Provider* = POINTER TO ABSTRACT RECORD (java_util.Properties)
                  STATIC
                    PROCEDURE Init!(p0 : java_lang.String;
                                    p1 : REAL;
                                    p2 : java_lang.String) : Provider,CONSTRUCTOR;
                  END;

      ProviderException* = POINTER TO EXTENSIBLE RECORD (java_lang.RuntimeException)
                           STATIC
                             PROCEDURE Init*() : ProviderException,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : java_lang.String) : ProviderException,CONSTRUCTOR;
                           END;

      PublicKey* = POINTER TO INTERFACE RECORD (java_lang.Object + java_awt.Cursor)
                   STATIC
                     serialVersionUID* = 7187392471159151072;
                   END;

      SecureClassLoader* = POINTER TO EXTENSIBLE RECORD (java_lang.ClassLoader)
                           STATIC
                             PROCEDURE Init!() : SecureClassLoader,CONSTRUCTOR;
                             PROCEDURE Init!(p0 : java_lang.ClassLoader) : SecureClassLoader,CONSTRUCTOR;
                           END;

      SecureRandom* = POINTER TO EXTENSIBLE RECORD (java_util.Random)
                      STATIC
                        PROCEDURE Init*() : SecureRandom,CONSTRUCTOR;
                        PROCEDURE Init!(p0 : SecureRandomSpi;
                                        p1 : Provider) : SecureRandom,CONSTRUCTOR;
                        PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : SecureRandom,CONSTRUCTOR;
                        PROCEDURE getInstance*(p0 : java_lang.String) : SecureRandom;
                        PROCEDURE getInstance*(p0 : java_lang.String;
                                               p1 : java_lang.String) : SecureRandom;
                        PROCEDURE getSeed*(p0 : INTEGER) : POINTER TO ARRAY OF BYTE;
                      END;

      SecureRandomSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_awt.Insets)
                         STATIC
                           PROCEDURE Init*() : SecureRandomSpi,CONSTRUCTOR;
                         END;

      Security* = POINTER TO RECORD (java_lang.Object)
                  STATIC
                    PROCEDURE addProvider*(p0 : Provider) : INTEGER;
                    PROCEDURE getAlgorithmProperty*(p0 : java_lang.String;
                                                    p1 : java_lang.String) : java_lang.String;
                    PROCEDURE getProperty*(p0 : java_lang.String) : java_lang.String;
                    PROCEDURE getProvider*(p0 : java_lang.String) : Provider;
                    PROCEDURE getProviders*() : POINTER TO ARRAY OF Provider;
                    PROCEDURE insertProviderAt*(p0 : Provider;
                                                p1 : INTEGER) : INTEGER;
                    PROCEDURE removeProvider*(p0 : java_lang.String);
                    PROCEDURE setProperty*(p0 : java_lang.String;
                                           p1 : java_lang.String);
                  END;

      SecurityPermission* = POINTER TO RECORD (BasicPermission)
                            STATIC
                              PROCEDURE Init*(p0 : java_lang.String) : SecurityPermission,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String;
                                              p1 : java_lang.String) : SecurityPermission,CONSTRUCTOR;
                            END;

      Signature* = POINTER TO ABSTRACT RECORD (SignatureSpi)
                     state! : INTEGER;
                   STATIC
                     UNINITIALIZED! = 0;
                     SIGN! = 2;
                     VERIFY! = 3;
                     PROCEDURE Init!(p0 : java_lang.String) : Signature,CONSTRUCTOR;
                     PROCEDURE getInstance*(p0 : java_lang.String) : Signature;
                     PROCEDURE getInstance*(p0 : java_lang.String;
                                            p1 : java_lang.String) : Signature;
                   END;

      SignatureException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                            STATIC
                              PROCEDURE Init*() : SignatureException,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String) : SignatureException,CONSTRUCTOR;
                            END;

      SignatureSpi* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                        appRandom! : SecureRandom;
                      STATIC
                        PROCEDURE Init*() : SignatureSpi,CONSTRUCTOR;
                      END;

      SignedObject* = POINTER TO RECORD (java_lang.Object + java_awt.Insets)
                      STATIC
                        PROCEDURE Init*(p0 : java_io.Serializable;
                                        p1 : PrivateKey;
                                        p2 : Signature) : SignedObject,CONSTRUCTOR;
                      END;

      Signer* = POINTER TO ABSTRACT RECORD (Identity)
                STATIC
                  PROCEDURE Init!() : Signer,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_lang.String) : Signer,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_lang.String;
                                  p1 : IdentityScope) : Signer,CONSTRUCTOR;
                END;

      UnrecoverableKeyException* = POINTER TO EXTENSIBLE RECORD (GeneralSecurityException)
                                   STATIC
                                     PROCEDURE Init*() : UnrecoverableKeyException,CONSTRUCTOR;
                                     PROCEDURE Init*(p0 : java_lang.String) : UnrecoverableKeyException,CONSTRUCTOR;
                                   END;

      UnresolvedPermission* = POINTER TO RECORD (Permission + java_awt.Insets)
                              STATIC
                                PROCEDURE Init*(    p0 : java_lang.String;
                                                    p1 : java_lang.String;
                                                    p2 : java_lang.String;
                                                IN  p3 : ARRAY OF java_security_cert.Certificate) : UnresolvedPermission,CONSTRUCTOR;
                              END;

    PROCEDURE (self:AccessControlContext) checkPermission*(p0 : Permission),NEW,EXTENSIBLE;

    PROCEDURE (self:AccessControlContext) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:AccessControlContext) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:AccessControlException) getPermission*() : Permission,NEW,EXTENSIBLE;

    PROCEDURE (self:AlgorithmParameterGenerator) generateParameters*() : AlgorithmParameters,NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) getAlgorithm*() : java_lang.String,NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) getProvider*() : Provider,NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : INTEGER),NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : INTEGER;
                                                       p1 : SecureRandom),NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

    PROCEDURE (self:AlgorithmParameterGenerator) init*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                       p1 : SecureRandom),NEW;

    PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineGenerateParameters!() : AlgorithmParameters,NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineInit!(p0 : INTEGER;
                                                                p1 : SecureRandom),NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParameterGeneratorSpi) engineInit!(p0 : java_security_spec.AlgorithmParameterSpec;
                                                                p1 : SecureRandom),NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParameters) getAlgorithm*() : java_lang.String,NEW;

    PROCEDURE (self:AlgorithmParameters) getEncoded*() : POINTER TO ARRAY OF BYTE,NEW;

    PROCEDURE (self:AlgorithmParameters) getEncoded*(p0 : java_lang.String) : POINTER TO ARRAY OF BYTE,NEW;

    PROCEDURE (self:AlgorithmParameters) getParameterSpec*(p0 : java_lang.Class) : java_security_spec.AlgorithmParameterSpec,NEW;

    PROCEDURE (self:AlgorithmParameters) getProvider*() : Provider,NEW;

    PROCEDURE (self:AlgorithmParameters) init*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

    PROCEDURE (self:AlgorithmParameters) init*(IN  p0 : ARRAY OF BYTE),NEW;

    PROCEDURE (self:AlgorithmParameters) init*(IN  p0 : ARRAY OF BYTE;
                                                   p1 : java_lang.String),NEW;

    PROCEDURE (self:AlgorithmParameters) toString*() : java_lang.String;

    PROCEDURE (self:AlgorithmParametersSpi) engineGetEncoded!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineGetEncoded!(p0 : java_lang.String) : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineGetParameterSpec!(p0 : java_lang.Class) : java_security_spec.AlgorithmParameterSpec,NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineInit!(p0 : java_security_spec.AlgorithmParameterSpec),NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineInit!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineInit!(IN  p0 : ARRAY OF BYTE;
                                                            p1 : java_lang.String),NEW,ABSTRACT;

    PROCEDURE (self:AlgorithmParametersSpi) engineToString!() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:AllPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:AllPermission) getActions*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:AllPermission) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:AllPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:AllPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

    PROCEDURE (self:BasicPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:BasicPermission) getActions*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:BasicPermission) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:BasicPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:BasicPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

    PROCEDURE (self:Certificate) decode*(p0 : java_io.InputStream),NEW,ABSTRACT;

    PROCEDURE (self:Certificate) encode*(p0 : java_io.OutputStream),NEW,ABSTRACT;

    PROCEDURE (self:Certificate) getFormat*() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:Certificate) getGuarantor*() : Principal,NEW,ABSTRACT;

    PROCEDURE (self:Certificate) getPrincipal*() : Principal,NEW,ABSTRACT;

    PROCEDURE (self:Certificate) getPublicKey*() : PublicKey,NEW,ABSTRACT;

    PROCEDURE (self:Certificate) toString*(p0 : BOOLEAN) : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:CodeSource) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:CodeSource) getCertificates*() : POINTER TO ARRAY OF java_security_cert.Certificate,NEW;

    PROCEDURE (self:CodeSource) getLocation*() : java_net.URL,NEW;

    PROCEDURE (self:CodeSource) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:CodeSource) implies*(p0 : CodeSource) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:CodeSource) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) getMessageDigest*() : MessageDigest,NEW,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) on*(p0 : BOOLEAN),NEW,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) read*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER) : INTEGER,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) setMessageDigest*(p0 : MessageDigest),NEW,EXTENSIBLE;

    PROCEDURE (self:DigestInputStream) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) getMessageDigest*() : MessageDigest,NEW,EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) on*(p0 : BOOLEAN),NEW,EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) setMessageDigest*(p0 : MessageDigest),NEW,EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:DigestOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                                   p1 : INTEGER;
                                                   p2 : INTEGER),EXTENSIBLE;

    PROCEDURE (self:Guard) checkGuard*(p0 : java_lang.Object),NEW,ABSTRACT;

    PROCEDURE (self:GuardedObject) getObject*() : java_lang.Object,NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) addCertificate*(p0 : Certificate),NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) certificates*() : POINTER TO ARRAY OF Certificate,NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) equals*(p0 : java_lang.Object) : BOOLEAN;

    PROCEDURE (self:Identity) getInfo*() : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) getName*() : java_lang.String,NEW;

    PROCEDURE (self:Identity) getPublicKey*() : PublicKey,NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) getScope*() : IdentityScope,NEW;

    PROCEDURE (self:Identity) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Identity) identityEquals!(p0 : Identity) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) removeCertificate*(p0 : Certificate),NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) setInfo*(p0 : java_lang.String),NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) setPublicKey*(p0 : PublicKey),NEW,EXTENSIBLE;

    PROCEDURE (self:Identity) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Identity) toString*(p0 : BOOLEAN) : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:IdentityScope) addIdentity*(p0 : Identity),NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) getIdentity*(p0 : java_lang.String) : Identity,NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) getIdentity*(p0 : Principal) : Identity,NEW,EXTENSIBLE;

    PROCEDURE (self:IdentityScope) getIdentity*(p0 : PublicKey) : Identity,NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) identities*() : java_util.Enumeration,NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) removeIdentity*(p0 : Identity),NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) size*() : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:IdentityScope) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Key) getAlgorithm*() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:Key) getEncoded*() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:Key) getFormat*() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:KeyFactory) generatePrivate*(p0 : java_security_spec.KeySpec) : PrivateKey,NEW;

    PROCEDURE (self:KeyFactory) generatePublic*(p0 : java_security_spec.KeySpec) : PublicKey,NEW;

    PROCEDURE (self:KeyFactory) getAlgorithm*() : java_lang.String,NEW;

    PROCEDURE (self:KeyFactory) getKeySpec*(p0 : Key;
                                            p1 : java_lang.Class) : java_security_spec.KeySpec,NEW;

    PROCEDURE (self:KeyFactory) getProvider*() : Provider,NEW;

    PROCEDURE (self:KeyFactory) translateKey*(p0 : Key) : Key,NEW;

    PROCEDURE (self:KeyFactorySpi) engineGeneratePrivate!(p0 : java_security_spec.KeySpec) : PrivateKey,NEW,ABSTRACT;

    PROCEDURE (self:KeyFactorySpi) engineGeneratePublic!(p0 : java_security_spec.KeySpec) : PublicKey,NEW,ABSTRACT;

    PROCEDURE (self:KeyFactorySpi) engineGetKeySpec!(p0 : Key;
                                                     p1 : java_lang.Class) : java_security_spec.KeySpec,NEW,ABSTRACT;

    PROCEDURE (self:KeyFactorySpi) engineTranslateKey!(p0 : Key) : Key,NEW,ABSTRACT;

    PROCEDURE (self:KeyPair) getPrivate*() : PrivateKey,NEW,EXTENSIBLE;

    PROCEDURE (self:KeyPair) getPublic*() : PublicKey,NEW,EXTENSIBLE;

    PROCEDURE (self:KeyPairGenerator) genKeyPair*() : KeyPair,NEW;

    PROCEDURE (self:KeyPairGenerator) getAlgorithm*() : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:KeyPairGenerator) getProvider*() : Provider,NEW;

    PROCEDURE (self:KeyPairGenerator) initialize*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:KeyPairGenerator) initialize*(p0 : INTEGER;
                                                  p1 : SecureRandom),EXTENSIBLE;

    PROCEDURE (self:KeyPairGenerator) initialize*(p0 : java_security_spec.AlgorithmParameterSpec),NEW,EXTENSIBLE;

    PROCEDURE (self:KeyPairGenerator) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                  p1 : SecureRandom),EXTENSIBLE;

    PROCEDURE (self:KeyPairGeneratorSpi) generateKeyPair*() : KeyPair,NEW,ABSTRACT;

    PROCEDURE (self:KeyPairGeneratorSpi) initialize*(p0 : INTEGER;
                                                     p1 : SecureRandom),NEW,ABSTRACT;

    PROCEDURE (self:KeyPairGeneratorSpi) initialize*(p0 : java_security_spec.AlgorithmParameterSpec;
                                                     p1 : SecureRandom),NEW,EXTENSIBLE;

    PROCEDURE (self:KeyStore) aliases*() : java_util.Enumeration,NEW;

    PROCEDURE (self:KeyStore) containsAlias*(p0 : java_lang.String) : BOOLEAN,NEW;

    PROCEDURE (self:KeyStore) deleteEntry*(p0 : java_lang.String),NEW;

    PROCEDURE (self:KeyStore) getCertificate*(p0 : java_lang.String) : java_security_cert.Certificate,NEW;

    PROCEDURE (self:KeyStore) getCertificateAlias*(p0 : java_security_cert.Certificate) : java_lang.String,NEW;

    PROCEDURE (self:KeyStore) getCertificateChain*(p0 : java_lang.String) : POINTER TO ARRAY OF java_security_cert.Certificate,NEW;

    PROCEDURE (self:KeyStore) getCreationDate*(p0 : java_lang.String) : java_util.Date,NEW;

    PROCEDURE (self:KeyStore) getKey*(    p0 : java_lang.String;
                                      IN  p1 : ARRAY OF CHAR) : Key,NEW;

    PROCEDURE (self:KeyStore) getProvider*() : Provider,NEW;

    PROCEDURE (self:KeyStore) getType*() : java_lang.String,NEW;

    PROCEDURE (self:KeyStore) isCertificateEntry*(p0 : java_lang.String) : BOOLEAN,NEW;

    PROCEDURE (self:KeyStore) isKeyEntry*(p0 : java_lang.String) : BOOLEAN,NEW;

    PROCEDURE (self:KeyStore) load*(    p0 : java_io.InputStream;
                                    IN  p1 : ARRAY OF CHAR),NEW;

    PROCEDURE (self:KeyStore) setCertificateEntry*(p0 : java_lang.String;
                                                   p1 : java_security_cert.Certificate),NEW;

    PROCEDURE (self:KeyStore) setKeyEntry*(    p0 : java_lang.String;
                                               p1 : Key;
                                           IN  p2 : ARRAY OF CHAR;
                                           IN  p3 : ARRAY OF java_security_cert.Certificate),NEW;

    PROCEDURE (self:KeyStore) setKeyEntry*(    p0 : java_lang.String;
                                           IN  p1 : ARRAY OF BYTE;
                                           IN  p2 : ARRAY OF java_security_cert.Certificate),NEW;

    PROCEDURE (self:KeyStore) size*() : INTEGER,NEW;

    PROCEDURE (self:KeyStore) store*(    p0 : java_io.OutputStream;
                                     IN  p1 : ARRAY OF CHAR),NEW;

    PROCEDURE (self:KeyStoreSpi) engineAliases*() : java_util.Enumeration,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineContainsAlias*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineDeleteEntry*(p0 : java_lang.String),NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineGetCertificate*(p0 : java_lang.String) : java_security_cert.Certificate,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineGetCertificateAlias*(p0 : java_security_cert.Certificate) : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineGetCertificateChain*(p0 : java_lang.String) : POINTER TO ARRAY OF java_security_cert.Certificate,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineGetCreationDate*(p0 : java_lang.String) : java_util.Date,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineGetKey*(    p0 : java_lang.String;
                                               IN  p1 : ARRAY OF CHAR) : Key,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineIsCertificateEntry*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineIsKeyEntry*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineLoad*(    p0 : java_io.InputStream;
                                             IN  p1 : ARRAY OF CHAR),NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineSetCertificateEntry*(p0 : java_lang.String;
                                                            p1 : java_security_cert.Certificate),NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineSetKeyEntry*(    p0 : java_lang.String;
                                                        p1 : Key;
                                                    IN  p2 : ARRAY OF CHAR;
                                                    IN  p3 : ARRAY OF java_security_cert.Certificate),NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineSetKeyEntry*(    p0 : java_lang.String;
                                                    IN  p1 : ARRAY OF BYTE;
                                                    IN  p2 : ARRAY OF java_security_cert.Certificate),NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineSize*() : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:KeyStoreSpi) engineStore*(    p0 : java_io.OutputStream;
                                              IN  p1 : ARRAY OF CHAR),NEW,ABSTRACT;

    PROCEDURE (self:MessageDigest) clone*() : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) digest*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) digest*(IN  p0 : ARRAY OF BYTE) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) digest*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) getAlgorithm*() : java_lang.String,NEW;

    PROCEDURE (self:MessageDigest) getDigestLength*() : INTEGER,NEW;

    PROCEDURE (self:MessageDigest) getProvider*() : Provider,NEW;

    PROCEDURE (self:MessageDigest) reset*(),NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) update*(p0 : BYTE),NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) update*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigest) update*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigestSpi) clone*() : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:MessageDigestSpi) engineDigest!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:MessageDigestSpi) engineDigest!(IN  p0 : ARRAY OF BYTE;
                                                        p1 : INTEGER;
                                                        p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigestSpi) engineGetDigestLength!() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:MessageDigestSpi) engineReset!(),NEW,ABSTRACT;

    PROCEDURE (self:MessageDigestSpi) engineUpdate!(p0 : BYTE),NEW,ABSTRACT;

    PROCEDURE (self:MessageDigestSpi) engineUpdate!(IN  p0 : ARRAY OF BYTE;
                                                        p1 : INTEGER;
                                                        p2 : INTEGER),NEW,ABSTRACT;

    PROCEDURE (self:Permission) checkGuard*(p0 : java_lang.Object),NEW,EXTENSIBLE;

    PROCEDURE (self:Permission) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

    PROCEDURE (self:Permission) getActions*() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:Permission) getName*() : java_lang.String,NEW;

    PROCEDURE (self:Permission) hashCode*() : INTEGER,ABSTRACT;

    PROCEDURE (self:Permission) implies*(p0 : Permission) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:Permission) newPermissionCollection*() : PermissionCollection,NEW,EXTENSIBLE;

    PROCEDURE (self:Permission) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:PermissionCollection) add*(p0 : Permission),NEW,ABSTRACT;

    PROCEDURE (self:PermissionCollection) elements*() : java_util.Enumeration,NEW,ABSTRACT;

    PROCEDURE (self:PermissionCollection) implies*(p0 : Permission) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:PermissionCollection) isReadOnly*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:PermissionCollection) setReadOnly*(),NEW,EXTENSIBLE;

    PROCEDURE (self:PermissionCollection) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Permissions) add*(p0 : Permission),EXTENSIBLE;

    PROCEDURE (self:Permissions) elements*() : java_util.Enumeration,EXTENSIBLE;

    PROCEDURE (self:Permissions) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Policy) getPermissions*(p0 : CodeSource) : PermissionCollection,NEW,ABSTRACT;

    PROCEDURE (self:Policy) refresh*(),NEW,ABSTRACT;

    PROCEDURE (self:Principal) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

    PROCEDURE (self:Principal) getName*() : java_lang.String,NEW,ABSTRACT;

    PROCEDURE (self:Principal) hashCode*() : INTEGER,ABSTRACT;

    PROCEDURE (self:Principal) toString*() : java_lang.String,ABSTRACT;

    PROCEDURE (self:PrivilegedAction) run*() : java_lang.Object,NEW,ABSTRACT;

    PROCEDURE (self:PrivilegedActionException) getException*() : java_lang.Exception,NEW,EXTENSIBLE;

    PROCEDURE (self:PrivilegedActionException) printStackTrace*(),EXTENSIBLE;

    PROCEDURE (self:PrivilegedActionException) printStackTrace*(p0 : java_io.PrintStream),EXTENSIBLE;

    PROCEDURE (self:PrivilegedActionException) printStackTrace*(p0 : java_io.PrintWriter),EXTENSIBLE;

    PROCEDURE (self:PrivilegedExceptionAction) run*() : java_lang.Object,NEW,ABSTRACT;

    PROCEDURE (self:ProtectionDomain) getCodeSource*() : CodeSource,NEW;

    PROCEDURE (self:ProtectionDomain) getPermissions*() : PermissionCollection,NEW;

    PROCEDURE (self:ProtectionDomain) implies*(p0 : Permission) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:ProtectionDomain) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Provider) clear*(),EXTENSIBLE;

    PROCEDURE (self:Provider) entrySet*() : java_util.Set,EXTENSIBLE;

    PROCEDURE (self:Provider) getInfo*() : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:Provider) getName*() : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:Provider) getVersion*() : REAL,NEW,EXTENSIBLE;

    PROCEDURE (self:Provider) keySet*() : java_util.Set,EXTENSIBLE;

    PROCEDURE (self:Provider) load*(p0 : java_io.InputStream),EXTENSIBLE;

    PROCEDURE (self:Provider) put*(p0 : java_lang.Object;
                                   p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:Provider) putAll*(p0 : java_util.Map),EXTENSIBLE;

    PROCEDURE (self:Provider) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:Provider) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Provider) values*() : java_util.Collection,EXTENSIBLE;

    PROCEDURE (self:SecureClassLoader) defineClass!(    p0 : java_lang.String;
                                                    IN  p1 : ARRAY OF BYTE;
                                                        p2 : INTEGER;
                                                        p3 : INTEGER;
                                                        p4 : CodeSource) : java_lang.Class,NEW;

    PROCEDURE (self:SecureClassLoader) getPermissions!(p0 : CodeSource) : PermissionCollection,NEW,EXTENSIBLE;

    PROCEDURE (self:SecureRandom) generateSeed*(p0 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:SecureRandom) getProvider*() : Provider,NEW;

    PROCEDURE (self:SecureRandom) next!(p0 : INTEGER) : INTEGER;

    PROCEDURE (self:SecureRandom) nextBytes*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

    PROCEDURE (self:SecureRandom) setSeed*(p0 : LONGINT),EXTENSIBLE;

    PROCEDURE (self:SecureRandom) setSeed*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

    PROCEDURE (self:SecureRandomSpi) engineGenerateSeed!(p0 : INTEGER) : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:SecureRandomSpi) engineNextBytes!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

    PROCEDURE (self:SecureRandomSpi) engineSetSeed!(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

    PROCEDURE (self:Signature) clone*() : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:Signature) getAlgorithm*() : java_lang.String,NEW;

    PROCEDURE (self:Signature) getParameter*(p0 : java_lang.String) : java_lang.Object,NEW;

    PROCEDURE (self:Signature) getProvider*() : Provider,NEW;

    PROCEDURE (self:Signature) initSign*(p0 : PrivateKey),NEW;

    PROCEDURE (self:Signature) initSign*(p0 : PrivateKey;
                                         p1 : SecureRandom),NEW;

    PROCEDURE (self:Signature) initVerify*(p0 : PublicKey),NEW;

    PROCEDURE (self:Signature) setParameter*(p0 : java_lang.String;
                                             p1 : java_lang.Object),NEW;

    PROCEDURE (self:Signature) setParameter*(p0 : java_security_spec.AlgorithmParameterSpec),NEW;

    PROCEDURE (self:Signature) sign*() : POINTER TO ARRAY OF BYTE,NEW;

    PROCEDURE (self:Signature) sign*(IN  p0 : ARRAY OF BYTE;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : INTEGER,NEW;

    PROCEDURE (self:Signature) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:Signature) update*(p0 : BYTE),NEW;

    PROCEDURE (self:Signature) update*(IN  p0 : ARRAY OF BYTE),NEW;

    PROCEDURE (self:Signature) update*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER),NEW;

    PROCEDURE (self:Signature) verify*(IN  p0 : ARRAY OF BYTE) : BOOLEAN,NEW;

    PROCEDURE (self:SignatureSpi) clone*() : java_lang.Object,EXTENSIBLE;

    PROCEDURE (self:SignatureSpi) engineGetParameter!(p0 : java_lang.String) : java_lang.Object,NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineInitSign!(p0 : PrivateKey),NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineInitSign!(p0 : PrivateKey;
                                                  p1 : SecureRandom),NEW,EXTENSIBLE;

    PROCEDURE (self:SignatureSpi) engineInitVerify!(p0 : PublicKey),NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineSetParameter!(p0 : java_lang.String;
                                                      p1 : java_lang.Object),NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineSetParameter!(p0 : java_security_spec.AlgorithmParameterSpec),NEW,EXTENSIBLE;

    PROCEDURE (self:SignatureSpi) engineSign!() : POINTER TO ARRAY OF BYTE,NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineSign!(IN  p0 : ARRAY OF BYTE;
                                                  p1 : INTEGER;
                                                  p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:SignatureSpi) engineUpdate!(p0 : BYTE),NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineUpdate!(IN  p0 : ARRAY OF BYTE;
                                                    p1 : INTEGER;
                                                    p2 : INTEGER),NEW,ABSTRACT;

    PROCEDURE (self:SignatureSpi) engineVerify!(IN  p0 : ARRAY OF BYTE) : BOOLEAN,NEW,ABSTRACT;

    PROCEDURE (self:SignedObject) getAlgorithm*() : java_lang.String,NEW,EXTENSIBLE;

    PROCEDURE (self:SignedObject) getObject*() : java_lang.Object,NEW,EXTENSIBLE;

    PROCEDURE (self:SignedObject) getSignature*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:SignedObject) verify*(p0 : PublicKey;
                                          p1 : Signature) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Signer) getPrivateKey*() : PrivateKey,NEW,EXTENSIBLE;

    PROCEDURE (self:Signer) setKeyPair*(p0 : KeyPair),NEW;

    PROCEDURE (self:Signer) toString*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) getActions*() : java_lang.String,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) hashCode*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) implies*(p0 : Permission) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) newPermissionCollection*() : PermissionCollection,EXTENSIBLE;

    PROCEDURE (self:UnresolvedPermission) toString*() : java_lang.String,EXTENSIBLE;

    END java_security.