Net2/usr/src/contrib/isode/dsap/x500as/llib-lx500as

/* llib-lx500as - lint library for QUIPU x500 abstract syntax */

/* 
 * $Header: /f/osi/dsap/x500as/RCS/llib-lx500as,v 7.1 91/02/22 09:22:01 mrose Interim $
 *
 *
 * $Log:	llib-lx500as,v $
 * Revision 7.1  91/02/22  09:22:01  mrose
 * Interim 6.8
 * 
 * Revision 7.0  90/12/06  07:34:47  mrose
 * *** empty log message ***
 * 
 * Revision 7.0  89/11/23  21:50:43  mrose
 * Release 6.0
 * 
 */

/*
 *				  NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/AF-types.h"
#include "quipu/DO-types.h"
#include "quipu/IF-types.h"
#include "quipu/Quipu-types.h"
#include "quipu/Thorn-types.h"
#include "quipu/DAS-types.h"
#include "quipu/DSE-types.h"
#include "quipu/NRS-types.h"
#include "quipu/SA-types.h"


#undef encode_AF_Version
int	encode_AF_Version(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_Version *parm;
{
  return (enc_f(_ZVersionAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_Version
int	decode_AF_Version(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_Version **parm;
{
  return (dec_f(_ZVersionAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_Version
/* ARGSUSED */
int	print_AF_Version(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZVersionAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificateSerialNumber
int	encode_AF_CertificateSerialNumber(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificateSerialNumber *parm;
{
  return (enc_f(_ZCertificateSerialNumberAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificateSerialNumber
int	decode_AF_CertificateSerialNumber(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificateSerialNumber **parm;
{
  return (dec_f(_ZCertificateSerialNumberAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificateSerialNumber
/* ARGSUSED */
int	print_AF_CertificateSerialNumber(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificateSerialNumberAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_Validity
int	encode_AF_Validity(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_Validity *parm;
{
  return (enc_f(_ZValidityAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_Validity
int	decode_AF_Validity(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_Validity **parm;
{
  return (dec_f(_ZValidityAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_Validity
/* ARGSUSED */
int	print_AF_Validity(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZValidityAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_AlgorithmIdentifier
int	encode_AF_AlgorithmIdentifier(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_AlgorithmIdentifier *parm;
{
  return (enc_f(_ZAlgorithmIdentifierAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_AlgorithmIdentifier
int	decode_AF_AlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_AlgorithmIdentifier **parm;
{
  return (dec_f(_ZAlgorithmIdentifierAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_AlgorithmIdentifier
/* ARGSUSED */
int	print_AF_AlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAlgorithmIdentifierAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_SubjectPublicKeyInfo
int	encode_AF_SubjectPublicKeyInfo(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_SubjectPublicKeyInfo *parm;
{
  return (enc_f(_ZSubjectPublicKeyInfoAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_SubjectPublicKeyInfo
int	decode_AF_SubjectPublicKeyInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_SubjectPublicKeyInfo **parm;
{
  return (dec_f(_ZSubjectPublicKeyInfoAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_SubjectPublicKeyInfo
/* ARGSUSED */
int	print_AF_SubjectPublicKeyInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSubjectPublicKeyInfoAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificateToSign
int	encode_AF_CertificateToSign(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificateToSign *parm;
{
  return (enc_f(_ZCertificateToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificateToSign
int	decode_AF_CertificateToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificateToSign **parm;
{
  return (dec_f(_ZCertificateToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificateToSign
/* ARGSUSED */
int	print_AF_CertificateToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificateToSignAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_Certificate
int	encode_AF_Certificate(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_Certificate *parm;
{
  return (enc_f(_ZCertificateAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_Certificate
int	decode_AF_Certificate(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_Certificate **parm;
{
  return (dec_f(_ZCertificateAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_Certificate
/* ARGSUSED */
int	print_AF_Certificate(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificateAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CrossCertificates
int	encode_AF_CrossCertificates(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CrossCertificates *parm;
{
  return (enc_f(_ZCrossCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CrossCertificates
int	decode_AF_CrossCertificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CrossCertificates **parm;
{
  return (dec_f(_ZCrossCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CrossCertificates
/* ARGSUSED */
int	print_AF_CrossCertificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCrossCertificatesAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_ForwardCertificationPath
int	encode_AF_ForwardCertificationPath(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_ForwardCertificationPath *parm;
{
  return (enc_f(_ZForwardCertificationPathAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_ForwardCertificationPath
int	decode_AF_ForwardCertificationPath(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_ForwardCertificationPath **parm;
{
  return (dec_f(_ZForwardCertificationPathAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_ForwardCertificationPath
/* ARGSUSED */
int	print_AF_ForwardCertificationPath(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZForwardCertificationPathAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_Certificates
int	encode_AF_Certificates(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_Certificates *parm;
{
  return (enc_f(_ZCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_Certificates
int	decode_AF_Certificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_Certificates **parm;
{
  return (dec_f(_ZCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_Certificates
/* ARGSUSED */
int	print_AF_Certificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificatesAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificatePair
int	encode_AF_CertificatePair(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificatePair *parm;
{
  return (enc_f(_ZCertificatePairAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificatePair
int	decode_AF_CertificatePair(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificatePair **parm;
{
  return (dec_f(_ZCertificatePairAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificatePair
/* ARGSUSED */
int	print_AF_CertificatePair(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificatePairAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificationPath
int	encode_AF_CertificationPath(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificationPath *parm;
{
  return (enc_f(_ZCertificationPathAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificationPath
int	decode_AF_CertificationPath(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificationPath **parm;
{
  return (dec_f(_ZCertificationPathAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificationPath
/* ARGSUSED */
int	print_AF_CertificationPath(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificationPathAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_RevokedCertificatesToSign
int	encode_AF_RevokedCertificatesToSign(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_RevokedCertificatesToSign *parm;
{
  return (enc_f(_ZRevokedCertificatesToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_RevokedCertificatesToSign
int	decode_AF_RevokedCertificatesToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_RevokedCertificatesToSign **parm;
{
  return (dec_f(_ZRevokedCertificatesToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_RevokedCertificatesToSign
/* ARGSUSED */
int	print_AF_RevokedCertificatesToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRevokedCertificatesToSignAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_RevokedCertificates
int	encode_AF_RevokedCertificates(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_RevokedCertificates *parm;
{
  return (enc_f(_ZRevokedCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_RevokedCertificates
int	decode_AF_RevokedCertificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_RevokedCertificates **parm;
{
  return (dec_f(_ZRevokedCertificatesAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_RevokedCertificates
/* ARGSUSED */
int	print_AF_RevokedCertificates(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRevokedCertificatesAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificateListToSign
int	encode_AF_CertificateListToSign(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificateListToSign *parm;
{
  return (enc_f(_ZCertificateListToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificateListToSign
int	decode_AF_CertificateListToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificateListToSign **parm;
{
  return (dec_f(_ZCertificateListToSignAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificateListToSign
/* ARGSUSED */
int	print_AF_CertificateListToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificateListToSignAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef encode_AF_CertificateList
int	encode_AF_CertificateList(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_AF_CertificateList *parm;
{
  return (enc_f(_ZCertificateListAF, &_ZAF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_AF_CertificateList
int	decode_AF_CertificateList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_AF_CertificateList **parm;
{
  return (dec_f(_ZCertificateListAF, &_ZAF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_AF_CertificateList
/* ARGSUSED */
int	print_AF_CertificateList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCertificateListAF, &_ZAF_mod, pe, top, len, buffer));
}

#undef print_IF_AttributeType
/* ARGSUSED */
int	print_IF_AttributeType(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeTypeIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_AttributeValue
int	encode_IF_AttributeValue(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_AttributeValue *parm;
{
  return (enc_f(_ZAttributeValueIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_AttributeValue
int	decode_IF_AttributeValue(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_AttributeValue **parm;
{
  return (dec_f(_ZAttributeValueIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_AttributeValue
/* ARGSUSED */
int	print_IF_AttributeValue(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeValueIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_AttributeValueAssertion
int	encode_IF_AttributeValueAssertion(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_AttributeValueAssertion *parm;
{
  return (enc_f(_ZAttributeValueAssertionIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_AttributeValueAssertion
int	decode_IF_AttributeValueAssertion(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_AttributeValueAssertion **parm;
{
  return (dec_f(_ZAttributeValueAssertionIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_AttributeValueAssertion
/* ARGSUSED */
int	print_IF_AttributeValueAssertion(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeValueAssertionIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_Attribute
int	encode_IF_Attribute(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_Attribute *parm;
{
  return (enc_f(_ZAttributeIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_Attribute
int	decode_IF_Attribute(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_Attribute **parm;
{
  return (dec_f(_ZAttributeIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_Attribute
/* ARGSUSED */
int	print_IF_Attribute(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_D__AValues
int	encode_IF_D__AValues(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_D__AValues *parm;
{
  return (enc_f(_ZD_AValuesIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_D__AValues
int	decode_IF_D__AValues(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_D__AValues **parm;
{
  return (dec_f(_ZD_AValuesIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_D__AValues
/* ARGSUSED */
int	print_IF_D__AValues(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZD_AValuesIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_RelativeDistinguishedName
int	encode_IF_RelativeDistinguishedName(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_RelativeDistinguishedName *parm;
{
  return (enc_f(_ZRelativeDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_RelativeDistinguishedName
int	decode_IF_RelativeDistinguishedName(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_RelativeDistinguishedName **parm;
{
  return (dec_f(_ZRelativeDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_RelativeDistinguishedName
/* ARGSUSED */
int	print_IF_RelativeDistinguishedName(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRelativeDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_RDNSequence
int	encode_IF_RDNSequence(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_RDNSequence *parm;
{
  return (enc_f(_ZRDNSequenceIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_RDNSequence
int	decode_IF_RDNSequence(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_RDNSequence **parm;
{
  return (dec_f(_ZRDNSequenceIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_RDNSequence
/* ARGSUSED */
int	print_IF_RDNSequence(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRDNSequenceIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_DistinguishedName
int	encode_IF_DistinguishedName(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_DistinguishedName *parm;
{
  return (enc_f(_ZDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_DistinguishedName
int	decode_IF_DistinguishedName(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_DistinguishedName **parm;
{
  return (dec_f(_ZDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_DistinguishedName
/* ARGSUSED */
int	print_IF_DistinguishedName(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDistinguishedNameIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef encode_IF_Name
int	encode_IF_Name(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_IF_Name *parm;
{
  return (enc_f(_ZNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_IF_Name
int	decode_IF_Name(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_IF_Name **parm;
{
  return (dec_f(_ZNameIF, &_ZIF_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_IF_Name
/* ARGSUSED */
int	print_IF_Name(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZNameIF, &_ZIF_mod, pe, top, len, buffer));
}

#undef print_Quipu_AccessSelector
/* ARGSUSED */
int	print_Quipu_AccessSelector(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAccessSelectorQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_AccessCategories
int	encode_Quipu_AccessCategories(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_AccessCategories *parm;
{
  return (enc_f(_ZAccessCategoriesQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_AccessCategories
int	decode_Quipu_AccessCategories(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_AccessCategories **parm;
{
  return (dec_f(_ZAccessCategoriesQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_AccessCategories
/* ARGSUSED */
int	print_Quipu_AccessCategories(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAccessCategoriesQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_ACLInfo
int	encode_Quipu_ACLInfo(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_ACLInfo *parm;
{
  return (enc_f(_ZACLInfoQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_ACLInfo
int	decode_Quipu_ACLInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_ACLInfo **parm;
{
  return (dec_f(_ZACLInfoQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_ACLInfo
/* ARGSUSED */
int	print_Quipu_ACLInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZACLInfoQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_AttributeACL
int	encode_Quipu_AttributeACL(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_AttributeACL *parm;
{
  return (enc_f(_ZAttributeACLQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_AttributeACL
int	decode_Quipu_AttributeACL(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_AttributeACL **parm;
{
  return (dec_f(_ZAttributeACLQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_AttributeACL
/* ARGSUSED */
int	print_Quipu_AttributeACL(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeACLQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_ACLSyntax
int	encode_Quipu_ACLSyntax(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_ACLSyntax *parm;
{
  return (enc_f(_ZACLSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_ACLSyntax
int	decode_Quipu_ACLSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_ACLSyntax **parm;
{
  return (dec_f(_ZACLSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_ACLSyntax
/* ARGSUSED */
int	print_Quipu_ACLSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZACLSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_NameList
int	encode_Quipu_NameList(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_NameList *parm;
{
  return (enc_f(_ZNameListQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_NameList
int	decode_Quipu_NameList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_NameList **parm;
{
  return (dec_f(_ZNameListQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_NameList
/* ARGSUSED */
int	print_Quipu_NameList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZNameListQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_EDBInfoSyntax
int	encode_Quipu_EDBInfoSyntax(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_EDBInfoSyntax *parm;
{
  return (enc_f(_ZEDBInfoSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_EDBInfoSyntax
int	decode_Quipu_EDBInfoSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_EDBInfoSyntax **parm;
{
  return (dec_f(_ZEDBInfoSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_EDBInfoSyntax
/* ARGSUSED */
int	print_Quipu_EDBInfoSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEDBInfoSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_RelativeEntry
int	encode_Quipu_RelativeEntry(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_RelativeEntry *parm;
{
  return (enc_f(_ZRelativeEntryQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_RelativeEntry
int	decode_Quipu_RelativeEntry(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_RelativeEntry **parm;
{
  return (dec_f(_ZRelativeEntryQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_RelativeEntry
/* ARGSUSED */
int	print_Quipu_RelativeEntry(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRelativeEntryQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_TreeStructureSyntax
int	encode_Quipu_TreeStructureSyntax(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_TreeStructureSyntax *parm;
{
  return (enc_f(_ZTreeStructureSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_TreeStructureSyntax
int	decode_Quipu_TreeStructureSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_TreeStructureSyntax **parm;
{
  return (dec_f(_ZTreeStructureSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_TreeStructureSyntax
/* ARGSUSED */
int	print_Quipu_TreeStructureSyntax(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTreeStructureSyntaxQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_EntryDataBlock
int	encode_Quipu_EntryDataBlock(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_EntryDataBlock *parm;
{
  return (enc_f(_ZEntryDataBlockQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_EntryDataBlock
int	decode_Quipu_EntryDataBlock(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_EntryDataBlock **parm;
{
  return (dec_f(_ZEntryDataBlockQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_EntryDataBlock
/* ARGSUSED */
int	print_Quipu_EntryDataBlock(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEntryDataBlockQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_EDBVersion
int	encode_Quipu_EDBVersion(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_EDBVersion *parm;
{
  return (enc_f(_ZEDBVersionQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_EDBVersion
int	decode_Quipu_EDBVersion(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_EDBVersion **parm;
{
  return (dec_f(_ZEDBVersionQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_EDBVersion
/* ARGSUSED */
int	print_Quipu_EDBVersion(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEDBVersionQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_GetEntryDataBlockArgument
int	encode_Quipu_GetEntryDataBlockArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_GetEntryDataBlockArgument *parm;
{
  return (enc_f(_ZGetEntryDataBlockArgumentQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_GetEntryDataBlockArgument
int	decode_Quipu_GetEntryDataBlockArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_GetEntryDataBlockArgument **parm;
{
  return (dec_f(_ZGetEntryDataBlockArgumentQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_GetEntryDataBlockArgument
/* ARGSUSED */
int	print_Quipu_GetEntryDataBlockArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZGetEntryDataBlockArgumentQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_GetEntryDataBlockResult
int	encode_Quipu_GetEntryDataBlockResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_GetEntryDataBlockResult *parm;
{
  return (enc_f(_ZGetEntryDataBlockResultQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_GetEntryDataBlockResult
int	decode_Quipu_GetEntryDataBlockResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_GetEntryDataBlockResult **parm;
{
  return (dec_f(_ZGetEntryDataBlockResultQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_GetEntryDataBlockResult
/* ARGSUSED */
int	print_Quipu_GetEntryDataBlockResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZGetEntryDataBlockResultQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_ProtectedPassword
int	encode_Quipu_ProtectedPassword(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_ProtectedPassword *parm;
{
  return (enc_f(_ZProtectedPasswordQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_ProtectedPassword
int	decode_Quipu_ProtectedPassword(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_ProtectedPassword **parm;
{
  return (dec_f(_ZProtectedPasswordQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_ProtectedPassword
/* ARGSUSED */
int	print_Quipu_ProtectedPassword(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZProtectedPasswordQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_InheritedList
int	encode_Quipu_InheritedList(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_InheritedList *parm;
{
  return (enc_f(_ZInheritedListQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_InheritedList
int	decode_Quipu_InheritedList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_InheritedList **parm;
{
  return (dec_f(_ZInheritedListQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_InheritedList
/* ARGSUSED */
int	print_Quipu_InheritedList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZInheritedListQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef encode_Quipu_InheritedAttribute
int	encode_Quipu_InheritedAttribute(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Quipu_InheritedAttribute *parm;
{
  return (enc_f(_ZInheritedAttributeQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Quipu_InheritedAttribute
int	decode_Quipu_InheritedAttribute(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Quipu_InheritedAttribute **parm;
{
  return (dec_f(_ZInheritedAttributeQuipu, &_ZQuipu_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Quipu_InheritedAttribute
/* ARGSUSED */
int	print_Quipu_InheritedAttribute(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZInheritedAttributeQuipu, &_ZQuipu_mod, pe, top, len, buffer));
}

#undef print_SA_FacsimileTelephoneNumber
/* ARGSUSED */
int	print_SA_FacsimileTelephoneNumber(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZFacsimileTelephoneNumberSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_PostalAddress
int	encode_SA_PostalAddress(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_PostalAddress *parm;
{
  return (enc_f(_ZPostalAddressSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_PostalAddress
int	decode_SA_PostalAddress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_PostalAddress **parm;
{
  return (dec_f(_ZPostalAddressSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_PostalAddress
/* ARGSUSED */
int	print_SA_PostalAddress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZPostalAddressSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_TelexNumber
int	encode_SA_TelexNumber(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_TelexNumber *parm;
{
  return (enc_f(_ZTelexNumberSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_TelexNumber
int	decode_SA_TelexNumber(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_TelexNumber **parm;
{
  return (dec_f(_ZTelexNumberSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_TelexNumber
/* ARGSUSED */
int	print_SA_TelexNumber(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTelexNumberSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_TeletexTerminalIdentifier
int	encode_SA_TeletexTerminalIdentifier(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_TeletexTerminalIdentifier *parm;
{
  return (enc_f(_ZTeletexTerminalIdentifierSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_TeletexTerminalIdentifier
int	decode_SA_TeletexTerminalIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_TeletexTerminalIdentifier **parm;
{
  return (dec_f(_ZTeletexTerminalIdentifierSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_TeletexTerminalIdentifier
/* ARGSUSED */
int	print_SA_TeletexTerminalIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTeletexTerminalIdentifierSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_PreferredDeliveryMethod
int	encode_SA_PreferredDeliveryMethod(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_PreferredDeliveryMethod *parm;
{
  return (enc_f(_ZPreferredDeliveryMethodSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_PreferredDeliveryMethod
int	decode_SA_PreferredDeliveryMethod(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_PreferredDeliveryMethod **parm;
{
  return (dec_f(_ZPreferredDeliveryMethodSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_PreferredDeliveryMethod
/* ARGSUSED */
int	print_SA_PreferredDeliveryMethod(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZPreferredDeliveryMethodSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_CriteriaItem
int	encode_SA_CriteriaItem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_CriteriaItem *parm;
{
  return (enc_f(_ZCriteriaItemSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_CriteriaItem
int	decode_SA_CriteriaItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_CriteriaItem **parm;
{
  return (dec_f(_ZCriteriaItemSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_CriteriaItem
/* ARGSUSED */
int	print_SA_CriteriaItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCriteriaItemSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_Criteria
int	encode_SA_Criteria(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_Criteria *parm;
{
  return (enc_f(_ZCriteriaSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_Criteria
int	decode_SA_Criteria(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_Criteria **parm;
{
  return (dec_f(_ZCriteriaSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_Criteria
/* ARGSUSED */
int	print_SA_Criteria(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCriteriaSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_Guide
int	encode_SA_Guide(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_Guide *parm;
{
  return (enc_f(_ZGuideSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_Guide
int	decode_SA_Guide(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_Guide **parm;
{
  return (dec_f(_ZGuideSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_Guide
/* ARGSUSED */
int	print_SA_Guide(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZGuideSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_SA_CaseIgnoreList
int	encode_SA_CaseIgnoreList(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_SA_CaseIgnoreList *parm;
{
  return (enc_f(_ZCaseIgnoreListSA, &_ZSA_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_SA_CaseIgnoreList
int	decode_SA_CaseIgnoreList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_SA_CaseIgnoreList **parm;
{
  return (dec_f(_ZCaseIgnoreListSA, &_ZSA_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_SA_CaseIgnoreList
/* ARGSUSED */
int	print_SA_CaseIgnoreList(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCaseIgnoreListSA, &_ZSA_mod, pe, top, len, buffer));
}

#undef encode_Thorn_MailBox
int	encode_Thorn_MailBox(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_Thorn_MailBox *parm;
{
  return (enc_f(_ZMailBoxThorn, &_ZThorn_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_Thorn_MailBox
int	decode_Thorn_MailBox(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_Thorn_MailBox **parm;
{
  return (dec_f(_ZMailBoxThorn, &_ZThorn_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_Thorn_MailBox
/* ARGSUSED */
int	print_Thorn_MailBox(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZMailBoxThorn, &_ZThorn_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedReadArgument
int	encode_DO_ChainedReadArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedReadArgument *parm;
{
  return (enc_f(_ZChainedReadArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedReadArgument
int	decode_DO_ChainedReadArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedReadArgument **parm;
{
  return (dec_f(_ZChainedReadArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedReadArgument
/* ARGSUSED */
int	print_DO_ChainedReadArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedReadArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedReadArgumentData
int	encode_DO_ChainedReadArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedReadArgumentData *parm;
{
  return (enc_f(_ZChainedReadArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedReadArgumentData
int	decode_DO_ChainedReadArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedReadArgumentData **parm;
{
  return (dec_f(_ZChainedReadArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedReadArgumentData
/* ARGSUSED */
int	print_DO_ChainedReadArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedReadArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedReadResult
int	encode_DO_ChainedReadResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedReadResult *parm;
{
  return (enc_f(_ZChainedReadResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedReadResult
int	decode_DO_ChainedReadResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedReadResult **parm;
{
  return (dec_f(_ZChainedReadResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedReadResult
/* ARGSUSED */
int	print_DO_ChainedReadResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedReadResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedReadResultData
int	encode_DO_ChainedReadResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedReadResultData *parm;
{
  return (enc_f(_ZChainedReadResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedReadResultData
int	decode_DO_ChainedReadResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedReadResultData **parm;
{
  return (dec_f(_ZChainedReadResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedReadResultData
/* ARGSUSED */
int	print_DO_ChainedReadResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedReadResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedCompareArgument
int	encode_DO_ChainedCompareArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedCompareArgument *parm;
{
  return (enc_f(_ZChainedCompareArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedCompareArgument
int	decode_DO_ChainedCompareArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedCompareArgument **parm;
{
  return (dec_f(_ZChainedCompareArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedCompareArgument
/* ARGSUSED */
int	print_DO_ChainedCompareArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedCompareArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedCompareArgumentData
int	encode_DO_ChainedCompareArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedCompareArgumentData *parm;
{
  return (enc_f(_ZChainedCompareArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedCompareArgumentData
int	decode_DO_ChainedCompareArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedCompareArgumentData **parm;
{
  return (dec_f(_ZChainedCompareArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedCompareArgumentData
/* ARGSUSED */
int	print_DO_ChainedCompareArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedCompareArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedCompareResult
int	encode_DO_ChainedCompareResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedCompareResult *parm;
{
  return (enc_f(_ZChainedCompareResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedCompareResult
int	decode_DO_ChainedCompareResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedCompareResult **parm;
{
  return (dec_f(_ZChainedCompareResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedCompareResult
/* ARGSUSED */
int	print_DO_ChainedCompareResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedCompareResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedCompareResultData
int	encode_DO_ChainedCompareResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedCompareResultData *parm;
{
  return (enc_f(_ZChainedCompareResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedCompareResultData
int	decode_DO_ChainedCompareResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedCompareResultData **parm;
{
  return (dec_f(_ZChainedCompareResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedCompareResultData
/* ARGSUSED */
int	print_DO_ChainedCompareResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedCompareResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAbandonArgument
int	encode_DO_ChainedAbandonArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAbandonArgument *parm;
{
  return (enc_f(_ZChainedAbandonArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAbandonArgument
int	decode_DO_ChainedAbandonArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAbandonArgument **parm;
{
  return (dec_f(_ZChainedAbandonArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAbandonArgument
/* ARGSUSED */
int	print_DO_ChainedAbandonArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAbandonArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAbandonResult
int	encode_DO_ChainedAbandonResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAbandonResult *parm;
{
  return (enc_f(_ZChainedAbandonResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAbandonResult
int	decode_DO_ChainedAbandonResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAbandonResult **parm;
{
  return (dec_f(_ZChainedAbandonResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAbandonResult
/* ARGSUSED */
int	print_DO_ChainedAbandonResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAbandonResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedListArgument
int	encode_DO_ChainedListArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedListArgument *parm;
{
  return (enc_f(_ZChainedListArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedListArgument
int	decode_DO_ChainedListArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedListArgument **parm;
{
  return (dec_f(_ZChainedListArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedListArgument
/* ARGSUSED */
int	print_DO_ChainedListArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedListArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedListArgumentData
int	encode_DO_ChainedListArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedListArgumentData *parm;
{
  return (enc_f(_ZChainedListArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedListArgumentData
int	decode_DO_ChainedListArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedListArgumentData **parm;
{
  return (dec_f(_ZChainedListArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedListArgumentData
/* ARGSUSED */
int	print_DO_ChainedListArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedListArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedListResult
int	encode_DO_ChainedListResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedListResult *parm;
{
  return (enc_f(_ZChainedListResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedListResult
int	decode_DO_ChainedListResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedListResult **parm;
{
  return (dec_f(_ZChainedListResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedListResult
/* ARGSUSED */
int	print_DO_ChainedListResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedListResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedListResultData
int	encode_DO_ChainedListResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedListResultData *parm;
{
  return (enc_f(_ZChainedListResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedListResultData
int	decode_DO_ChainedListResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedListResultData **parm;
{
  return (dec_f(_ZChainedListResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedListResultData
/* ARGSUSED */
int	print_DO_ChainedListResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedListResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedSearchArgument
int	encode_DO_ChainedSearchArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedSearchArgument *parm;
{
  return (enc_f(_ZChainedSearchArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedSearchArgument
int	decode_DO_ChainedSearchArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedSearchArgument **parm;
{
  return (dec_f(_ZChainedSearchArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedSearchArgument
/* ARGSUSED */
int	print_DO_ChainedSearchArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedSearchArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedSearchArgumentData
int	encode_DO_ChainedSearchArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedSearchArgumentData *parm;
{
  return (enc_f(_ZChainedSearchArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedSearchArgumentData
int	decode_DO_ChainedSearchArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedSearchArgumentData **parm;
{
  return (dec_f(_ZChainedSearchArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedSearchArgumentData
/* ARGSUSED */
int	print_DO_ChainedSearchArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedSearchArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedSearchResult
int	encode_DO_ChainedSearchResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedSearchResult *parm;
{
  return (enc_f(_ZChainedSearchResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedSearchResult
int	decode_DO_ChainedSearchResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedSearchResult **parm;
{
  return (dec_f(_ZChainedSearchResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedSearchResult
/* ARGSUSED */
int	print_DO_ChainedSearchResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedSearchResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedSearchResultData
int	encode_DO_ChainedSearchResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedSearchResultData *parm;
{
  return (enc_f(_ZChainedSearchResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedSearchResultData
int	decode_DO_ChainedSearchResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedSearchResultData **parm;
{
  return (dec_f(_ZChainedSearchResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedSearchResultData
/* ARGSUSED */
int	print_DO_ChainedSearchResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedSearchResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAddEntryArgument
int	encode_DO_ChainedAddEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAddEntryArgument *parm;
{
  return (enc_f(_ZChainedAddEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAddEntryArgument
int	decode_DO_ChainedAddEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAddEntryArgument **parm;
{
  return (dec_f(_ZChainedAddEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAddEntryArgument
/* ARGSUSED */
int	print_DO_ChainedAddEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAddEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAddEntryArgumentData
int	encode_DO_ChainedAddEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAddEntryArgumentData *parm;
{
  return (enc_f(_ZChainedAddEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAddEntryArgumentData
int	decode_DO_ChainedAddEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAddEntryArgumentData **parm;
{
  return (dec_f(_ZChainedAddEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAddEntryArgumentData
/* ARGSUSED */
int	print_DO_ChainedAddEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAddEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAddEntryResult
int	encode_DO_ChainedAddEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAddEntryResult *parm;
{
  return (enc_f(_ZChainedAddEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAddEntryResult
int	decode_DO_ChainedAddEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAddEntryResult **parm;
{
  return (dec_f(_ZChainedAddEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAddEntryResult
/* ARGSUSED */
int	print_DO_ChainedAddEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAddEntryResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedAddEntryResultData
int	encode_DO_ChainedAddEntryResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedAddEntryResultData *parm;
{
  return (enc_f(_ZChainedAddEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedAddEntryResultData
int	decode_DO_ChainedAddEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedAddEntryResultData **parm;
{
  return (dec_f(_ZChainedAddEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedAddEntryResultData
/* ARGSUSED */
int	print_DO_ChainedAddEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedAddEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedRemoveEntryArgument
int	encode_DO_ChainedRemoveEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedRemoveEntryArgument *parm;
{
  return (enc_f(_ZChainedRemoveEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedRemoveEntryArgument
int	decode_DO_ChainedRemoveEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedRemoveEntryArgument **parm;
{
  return (dec_f(_ZChainedRemoveEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedRemoveEntryArgument
/* ARGSUSED */
int	print_DO_ChainedRemoveEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedRemoveEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedRemoveEntryArgumentData
int	encode_DO_ChainedRemoveEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedRemoveEntryArgumentData *parm;
{
  return (enc_f(_ZChainedRemoveEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedRemoveEntryArgumentData
int	decode_DO_ChainedRemoveEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedRemoveEntryArgumentData **parm;
{
  return (dec_f(_ZChainedRemoveEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedRemoveEntryArgumentData
/* ARGSUSED */
int	print_DO_ChainedRemoveEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedRemoveEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedRemoveEntryResult
int	encode_DO_ChainedRemoveEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedRemoveEntryResult *parm;
{
  return (enc_f(_ZChainedRemoveEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedRemoveEntryResult
int	decode_DO_ChainedRemoveEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedRemoveEntryResult **parm;
{
  return (dec_f(_ZChainedRemoveEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedRemoveEntryResult
/* ARGSUSED */
int	print_DO_ChainedRemoveEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedRemoveEntryResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedRemoveEntryResultData
int	encode_DO_ChainedRemoveEntryResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedRemoveEntryResultData *parm;
{
  return (enc_f(_ZChainedRemoveEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedRemoveEntryResultData
int	decode_DO_ChainedRemoveEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedRemoveEntryResultData **parm;
{
  return (dec_f(_ZChainedRemoveEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedRemoveEntryResultData
/* ARGSUSED */
int	print_DO_ChainedRemoveEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedRemoveEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyEntryArgument
int	encode_DO_ChainedModifyEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyEntryArgument *parm;
{
  return (enc_f(_ZChainedModifyEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyEntryArgument
int	decode_DO_ChainedModifyEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyEntryArgument **parm;
{
  return (dec_f(_ZChainedModifyEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyEntryArgument
/* ARGSUSED */
int	print_DO_ChainedModifyEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyEntryArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyEntryArgumentData
int	encode_DO_ChainedModifyEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyEntryArgumentData *parm;
{
  return (enc_f(_ZChainedModifyEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyEntryArgumentData
int	decode_DO_ChainedModifyEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyEntryArgumentData **parm;
{
  return (dec_f(_ZChainedModifyEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyEntryArgumentData
/* ARGSUSED */
int	print_DO_ChainedModifyEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyEntryArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyEntryResult
int	encode_DO_ChainedModifyEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyEntryResult *parm;
{
  return (enc_f(_ZChainedModifyEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyEntryResult
int	decode_DO_ChainedModifyEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyEntryResult **parm;
{
  return (dec_f(_ZChainedModifyEntryResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyEntryResult
/* ARGSUSED */
int	print_DO_ChainedModifyEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyEntryResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyEntryResultData
int	encode_DO_ChainedModifyEntryResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyEntryResultData *parm;
{
  return (enc_f(_ZChainedModifyEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyEntryResultData
int	decode_DO_ChainedModifyEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyEntryResultData **parm;
{
  return (dec_f(_ZChainedModifyEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyEntryResultData
/* ARGSUSED */
int	print_DO_ChainedModifyEntryResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyEntryResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyRDNArgument
int	encode_DO_ChainedModifyRDNArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyRDNArgument *parm;
{
  return (enc_f(_ZChainedModifyRDNArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyRDNArgument
int	decode_DO_ChainedModifyRDNArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyRDNArgument **parm;
{
  return (dec_f(_ZChainedModifyRDNArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyRDNArgument
/* ARGSUSED */
int	print_DO_ChainedModifyRDNArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyRDNArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyRDNArgumentData
int	encode_DO_ChainedModifyRDNArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyRDNArgumentData *parm;
{
  return (enc_f(_ZChainedModifyRDNArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyRDNArgumentData
int	decode_DO_ChainedModifyRDNArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyRDNArgumentData **parm;
{
  return (dec_f(_ZChainedModifyRDNArgumentDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyRDNArgumentData
/* ARGSUSED */
int	print_DO_ChainedModifyRDNArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyRDNArgumentDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyRDNResult
int	encode_DO_ChainedModifyRDNResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyRDNResult *parm;
{
  return (enc_f(_ZChainedModifyRDNResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyRDNResult
int	decode_DO_ChainedModifyRDNResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyRDNResult **parm;
{
  return (dec_f(_ZChainedModifyRDNResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyRDNResult
/* ARGSUSED */
int	print_DO_ChainedModifyRDNResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyRDNResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainedModifyRDNResultData
int	encode_DO_ChainedModifyRDNResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainedModifyRDNResultData *parm;
{
  return (enc_f(_ZChainedModifyRDNResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainedModifyRDNResultData
int	decode_DO_ChainedModifyRDNResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainedModifyRDNResultData **parm;
{
  return (dec_f(_ZChainedModifyRDNResultDataDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainedModifyRDNResultData
/* ARGSUSED */
int	print_DO_ChainedModifyRDNResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainedModifyRDNResultDataDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_DSAReferralParm
int	encode_DO_DSAReferralParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_DSAReferralParm *parm;
{
  return (enc_f(_ZDSAReferralParmDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_DSAReferralParm
int	decode_DO_DSAReferralParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_DSAReferralParm **parm;
{
  return (dec_f(_ZDSAReferralParmDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_DSAReferralParm
/* ARGSUSED */
int	print_DO_DSAReferralParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDSAReferralParmDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainingArgument
int	encode_DO_ChainingArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainingArgument *parm;
{
  return (enc_f(_ZChainingArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainingArgument
int	decode_DO_ChainingArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainingArgument **parm;
{
  return (dec_f(_ZChainingArgumentDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainingArgument
/* ARGSUSED */
int	print_DO_ChainingArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainingArgumentDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ChainingResult
int	encode_DO_ChainingResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ChainingResult *parm;
{
  return (enc_f(_ZChainingResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ChainingResult
int	decode_DO_ChainingResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ChainingResult **parm;
{
  return (dec_f(_ZChainingResultDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ChainingResult
/* ARGSUSED */
int	print_DO_ChainingResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZChainingResultDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_CrossReference
int	encode_DO_CrossReference(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_CrossReference *parm;
{
  return (enc_f(_ZCrossReferenceDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_CrossReference
int	decode_DO_CrossReference(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_CrossReference **parm;
{
  return (dec_f(_ZCrossReferenceDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_CrossReference
/* ARGSUSED */
int	print_DO_CrossReference(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCrossReferenceDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ReferenceType
int	encode_DO_ReferenceType(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ReferenceType *parm;
{
  return (enc_f(_ZReferenceTypeDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ReferenceType
int	decode_DO_ReferenceType(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ReferenceType **parm;
{
  return (dec_f(_ZReferenceTypeDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ReferenceType
/* ARGSUSED */
int	print_DO_ReferenceType(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReferenceTypeDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_TraceInformation
int	encode_DO_TraceInformation(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_TraceInformation *parm;
{
  return (enc_f(_ZTraceInformationDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_TraceInformation
int	decode_DO_TraceInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_TraceInformation **parm;
{
  return (dec_f(_ZTraceInformationDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_TraceInformation
/* ARGSUSED */
int	print_DO_TraceInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTraceInformationDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_TraceItem
int	encode_DO_TraceItem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_TraceItem *parm;
{
  return (enc_f(_ZTraceItemDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_TraceItem
int	decode_DO_TraceItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_TraceItem **parm;
{
  return (dec_f(_ZTraceItemDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_TraceItem
/* ARGSUSED */
int	print_DO_TraceItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTraceItemDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_OperationProgress
int	encode_DO_OperationProgress(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_OperationProgress *parm;
{
  return (enc_f(_ZOperationProgressDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_OperationProgress
int	decode_DO_OperationProgress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_OperationProgress **parm;
{
  return (dec_f(_ZOperationProgressDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_OperationProgress
/* ARGSUSED */
int	print_DO_OperationProgress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZOperationProgressDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_DomainInfo
int	encode_DO_DomainInfo(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_DomainInfo *parm;
{
  return (enc_f(_ZDomainInfoDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_DomainInfo
int	decode_DO_DomainInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_DomainInfo **parm;
{
  return (dec_f(_ZDomainInfoDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_DomainInfo
/* ARGSUSED */
int	print_DO_DomainInfo(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDomainInfoDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ContinuationReference
int	encode_DO_ContinuationReference(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ContinuationReference *parm;
{
  return (enc_f(_ZContinuationReferenceDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ContinuationReference
int	decode_DO_ContinuationReference(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ContinuationReference **parm;
{
  return (dec_f(_ZContinuationReferenceDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ContinuationReference
/* ARGSUSED */
int	print_DO_ContinuationReference(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZContinuationReferenceDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_AccessPoint
int	encode_DO_AccessPoint(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_AccessPoint *parm;
{
  return (enc_f(_ZAccessPointDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_AccessPoint
int	decode_DO_AccessPoint(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_AccessPoint **parm;
{
  return (dec_f(_ZAccessPointDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_AccessPoint
/* ARGSUSED */
int	print_DO_AccessPoint(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAccessPointDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_ISODEPresentationAddress
int	encode_DO_ISODEPresentationAddress(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_ISODEPresentationAddress *parm;
{
  return (enc_f(_ZISODEPresentationAddressDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_ISODEPresentationAddress
int	decode_DO_ISODEPresentationAddress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_ISODEPresentationAddress **parm;
{
  return (dec_f(_ZISODEPresentationAddressDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_ISODEPresentationAddress
/* ARGSUSED */
int	print_DO_ISODEPresentationAddress(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZISODEPresentationAddressDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DO_InvokeID
int	encode_DO_InvokeID(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DO_InvokeID *parm;
{
  return (enc_f(_ZInvokeIDDO, &_ZDO_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DO_InvokeID
int	decode_DO_InvokeID(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DO_InvokeID **parm;
{
  return (dec_f(_ZInvokeIDDO, &_ZDO_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DO_InvokeID
/* ARGSUSED */
int	print_DO_InvokeID(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZInvokeIDDO, &_ZDO_mod, pe, top, len, buffer));
}

#undef encode_DAS_SimpleCredentials
int	encode_DAS_SimpleCredentials(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SimpleCredentials *parm;
{
  return (enc_f(_ZSimpleCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SimpleCredentials
int	decode_DAS_SimpleCredentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SimpleCredentials **parm;
{
  return (dec_f(_ZSimpleCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SimpleCredentials
/* ARGSUSED */
int	print_DAS_SimpleCredentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSimpleCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_TAlgorithmIdentifier
int	encode_DAS_TAlgorithmIdentifier(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TAlgorithmIdentifier *parm;
{
  return (enc_f(_ZTAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_TAlgorithmIdentifier
int	decode_DAS_TAlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_TAlgorithmIdentifier **parm;
{
  return (dec_f(_ZTAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_TAlgorithmIdentifier
/* ARGSUSED */
int	print_DAS_TAlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_TBitString
int	encode_DAS_TBitString(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TBitString *parm;
{
  return (enc_f(_ZTBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_TBitString
int	decode_DAS_TBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_TBitString **parm;
{
  return (dec_f(_ZTBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_TBitString
/* ARGSUSED */
int	print_DAS_TBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTBitStringDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_TokenToSign
int	encode_DAS_TokenToSign(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TokenToSign *parm;
{
  return (enc_f(_ZTokenToSignDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_TokenToSign
int	decode_DAS_TokenToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_TokenToSign **parm;
{
  return (dec_f(_ZTokenToSignDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_TokenToSign
/* ARGSUSED */
int	print_DAS_TokenToSign(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTokenToSignDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_Token
int	encode_DAS_Token(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_Token *parm;
{
  return (enc_f(_ZTokenDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_Token
int	decode_DAS_Token(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_Token **parm;
{
  return (dec_f(_ZTokenDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_Token
/* ARGSUSED */
int	print_DAS_Token(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTokenDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_StrongCredentials
int	encode_DAS_StrongCredentials(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_StrongCredentials *parm;
{
  return (enc_f(_ZStrongCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_StrongCredentials
int	decode_DAS_StrongCredentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_StrongCredentials **parm;
{
  return (dec_f(_ZStrongCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_StrongCredentials
/* ARGSUSED */
int	print_DAS_StrongCredentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZStrongCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_Credentials
int	encode_DAS_Credentials(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_Credentials *parm;
{
  return (enc_f(_ZCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_Credentials
int	decode_DAS_Credentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_Credentials **parm;
{
  return (dec_f(_ZCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_Credentials
/* ARGSUSED */
int	print_DAS_Credentials(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCredentialsDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_Versions
int	encode_DAS_Versions(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_Versions *parm;
{
  return (enc_f(_ZVersionsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_Versions
int	decode_DAS_Versions(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_Versions **parm;
{
  return (dec_f(_ZVersionsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_Versions
/* ARGSUSED */
int	print_DAS_Versions(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZVersionsDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SecurityProblem
int	encode_DAS_SecurityProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SecurityProblem *parm;
{
  return (enc_f(_ZSecurityProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SecurityProblem
int	decode_DAS_SecurityProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SecurityProblem **parm;
{
  return (dec_f(_ZSecurityProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SecurityProblem
/* ARGSUSED */
int	print_DAS_SecurityProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSecurityProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ServiceProblem
int	encode_DAS_ServiceProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ServiceProblem *parm;
{
  return (enc_f(_ZServiceProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ServiceProblem
int	decode_DAS_ServiceProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ServiceProblem **parm;
{
  return (dec_f(_ZServiceProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ServiceProblem
/* ARGSUSED */
int	print_DAS_ServiceProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZServiceProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_EntryInformationSelection
int	encode_DAS_EntryInformationSelection(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_EntryInformationSelection *parm;
{
  return (enc_f(_ZEntryInformationSelectionDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_EntryInformationSelection
int	decode_DAS_EntryInformationSelection(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_EntryInformationSelection **parm;
{
  return (dec_f(_ZEntryInformationSelectionDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_EntryInformationSelection
/* ARGSUSED */
int	print_DAS_EntryInformationSelection(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEntryInformationSelectionDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ServiceControls
int	encode_DAS_ServiceControls(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ServiceControls *parm;
{
  return (enc_f(_ZServiceControlsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ServiceControls
int	decode_DAS_ServiceControls(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ServiceControls **parm;
{
  return (dec_f(_ZServiceControlsDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ServiceControls
/* ARGSUSED */
int	print_DAS_ServiceControls(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZServiceControlsDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ProtectionRequest
int	encode_DAS_ProtectionRequest(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ProtectionRequest *parm;
{
  return (enc_f(_ZProtectionRequestDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ProtectionRequest
int	decode_DAS_ProtectionRequest(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ProtectionRequest **parm;
{
  return (dec_f(_ZProtectionRequestDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ProtectionRequest
/* ARGSUSED */
int	print_DAS_ProtectionRequest(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZProtectionRequestDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_DBitString
int	encode_DAS_DBitString(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_DBitString *parm;
{
  return (enc_f(_ZDBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_DBitString
int	decode_DAS_DBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_DBitString **parm;
{
  return (dec_f(_ZDBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_DBitString
/* ARGSUSED */
int	print_DAS_DBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDBitStringDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SecurityParameters
int	encode_DAS_SecurityParameters(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SecurityParameters *parm;
{
  return (enc_f(_ZSecurityParametersDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SecurityParameters
int	decode_DAS_SecurityParameters(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SecurityParameters **parm;
{
  return (dec_f(_ZSecurityParametersDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SecurityParameters
/* ARGSUSED */
int	print_DAS_SecurityParameters(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSecurityParametersDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_Extension
int	encode_DAS_Extension(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_Extension *parm;
{
  return (enc_f(_ZExtensionDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_Extension
int	decode_DAS_Extension(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_Extension **parm;
{
  return (dec_f(_ZExtensionDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_Extension
/* ARGSUSED */
int	print_DAS_Extension(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZExtensionDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_EntryInformation
int	encode_DAS_EntryInformation(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_EntryInformation *parm;
{
  return (enc_f(_ZEntryInformationDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_EntryInformation
int	decode_DAS_EntryInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_EntryInformation **parm;
{
  return (dec_f(_ZEntryInformationDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_EntryInformation
/* ARGSUSED */
int	print_DAS_EntryInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEntryInformationDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_LimitProblem
int	encode_DAS_LimitProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_LimitProblem *parm;
{
  return (enc_f(_ZLimitProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_LimitProblem
int	decode_DAS_LimitProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_LimitProblem **parm;
{
  return (dec_f(_ZLimitProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_LimitProblem
/* ARGSUSED */
int	print_DAS_LimitProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZLimitProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_PartialOutcomeQualifier
int	encode_DAS_PartialOutcomeQualifier(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_PartialOutcomeQualifier *parm;
{
  return (enc_f(_ZPartialOutcomeQualifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_PartialOutcomeQualifier
int	decode_DAS_PartialOutcomeQualifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_PartialOutcomeQualifier **parm;
{
  return (dec_f(_ZPartialOutcomeQualifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_PartialOutcomeQualifier
/* ARGSUSED */
int	print_DAS_PartialOutcomeQualifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZPartialOutcomeQualifierDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_FilterItem
int	encode_DAS_FilterItem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_FilterItem *parm;
{
  return (enc_f(_ZFilterItemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_FilterItem
int	decode_DAS_FilterItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_FilterItem **parm;
{
  return (dec_f(_ZFilterItemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_FilterItem
/* ARGSUSED */
int	print_DAS_FilterItem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZFilterItemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_Filter
int	encode_DAS_Filter(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_Filter *parm;
{
  return (enc_f(_ZFilterDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_Filter
int	decode_DAS_Filter(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_Filter **parm;
{
  return (dec_f(_ZFilterDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_Filter
/* ARGSUSED */
int	print_DAS_Filter(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZFilterDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_TAttributeType
int	encode_DAS_TAttributeType(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TAttributeType *parm;
{
  return (enc_f(_ZTAttributeTypeDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_TAttributeType
int	decode_DAS_TAttributeType(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_TAttributeType **parm;
{
  return (dec_f(_ZTAttributeTypeDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_TAttributeType
/* ARGSUSED */
int	print_DAS_TAttributeType(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTAttributeTypeDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_EntryModification
int	encode_DAS_EntryModification(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_EntryModification *parm;
{
  return (enc_f(_ZEntryModificationDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_EntryModification
int	decode_DAS_EntryModification(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_EntryModification **parm;
{
  return (dec_f(_ZEntryModificationDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_EntryModification
/* ARGSUSED */
int	print_DAS_EntryModification(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZEntryModificationDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AbandonProblem
int	encode_DAS_AbandonProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AbandonProblem *parm;
{
  return (enc_f(_ZAbandonProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AbandonProblem
int	decode_DAS_AbandonProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AbandonProblem **parm;
{
  return (dec_f(_ZAbandonProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AbandonProblem
/* ARGSUSED */
int	print_DAS_AbandonProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAbandonProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AttributeProblem
int	encode_DAS_AttributeProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AttributeProblem *parm;
{
  return (enc_f(_ZAttributeProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AttributeProblem
int	decode_DAS_AttributeProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AttributeProblem **parm;
{
  return (dec_f(_ZAttributeProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AttributeProblem
/* ARGSUSED */
int	print_DAS_AttributeProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_NameProblem
int	encode_DAS_NameProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_NameProblem *parm;
{
  return (enc_f(_ZNameProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_NameProblem
int	decode_DAS_NameProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_NameProblem **parm;
{
  return (dec_f(_ZNameProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_NameProblem
/* ARGSUSED */
int	print_DAS_NameProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZNameProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_UpdateProblem
int	encode_DAS_UpdateProblem(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_UpdateProblem *parm;
{
  return (enc_f(_ZUpdateProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_UpdateProblem
int	decode_DAS_UpdateProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_UpdateProblem **parm;
{
  return (dec_f(_ZUpdateProblemDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_UpdateProblem
/* ARGSUSED */
int	print_DAS_UpdateProblem(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZUpdateProblemDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_DirectoryBindArgument
int	encode_DAS_DirectoryBindArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_DirectoryBindArgument *parm;
{
  return (enc_f(_ZDirectoryBindArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_DirectoryBindArgument
int	decode_DAS_DirectoryBindArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_DirectoryBindArgument **parm;
{
  return (dec_f(_ZDirectoryBindArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_DirectoryBindArgument
/* ARGSUSED */
int	print_DAS_DirectoryBindArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDirectoryBindArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_DirectoryBindResult
int	encode_DAS_DirectoryBindResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_DirectoryBindResult *parm;
{
  return (enc_f(_ZDirectoryBindResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_DirectoryBindResult
int	decode_DAS_DirectoryBindResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_DirectoryBindResult **parm;
{
  return (dec_f(_ZDirectoryBindResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_DirectoryBindResult
/* ARGSUSED */
int	print_DAS_DirectoryBindResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDirectoryBindResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ReadArgumentData
int	encode_DAS_ReadArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReadArgumentData *parm;
{
  return (enc_f(_ZReadArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ReadArgumentData
int	decode_DAS_ReadArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ReadArgumentData **parm;
{
  return (dec_f(_ZReadArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ReadArgumentData
/* ARGSUSED */
int	print_DAS_ReadArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReadArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ReadArgument
int	encode_DAS_ReadArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReadArgument *parm;
{
  return (enc_f(_ZReadArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ReadArgument
int	decode_DAS_ReadArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ReadArgument **parm;
{
  return (dec_f(_ZReadArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ReadArgument
/* ARGSUSED */
int	print_DAS_ReadArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReadArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ReadResultData
int	encode_DAS_ReadResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReadResultData *parm;
{
  return (enc_f(_ZReadResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ReadResultData
int	decode_DAS_ReadResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ReadResultData **parm;
{
  return (dec_f(_ZReadResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ReadResultData
/* ARGSUSED */
int	print_DAS_ReadResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReadResultDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ReadResult
int	encode_DAS_ReadResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReadResult *parm;
{
  return (enc_f(_ZReadResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ReadResult
int	decode_DAS_ReadResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ReadResult **parm;
{
  return (dec_f(_ZReadResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ReadResult
/* ARGSUSED */
int	print_DAS_ReadResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReadResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_CompareArgumentData
int	encode_DAS_CompareArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_CompareArgumentData *parm;
{
  return (enc_f(_ZCompareArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_CompareArgumentData
int	decode_DAS_CompareArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_CompareArgumentData **parm;
{
  return (dec_f(_ZCompareArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_CompareArgumentData
/* ARGSUSED */
int	print_DAS_CompareArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCompareArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_CompareArgument
int	encode_DAS_CompareArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_CompareArgument *parm;
{
  return (enc_f(_ZCompareArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_CompareArgument
int	decode_DAS_CompareArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_CompareArgument **parm;
{
  return (dec_f(_ZCompareArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_CompareArgument
/* ARGSUSED */
int	print_DAS_CompareArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCompareArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_CompareResultData
int	encode_DAS_CompareResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_CompareResultData *parm;
{
  return (enc_f(_ZCompareResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_CompareResultData
int	decode_DAS_CompareResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_CompareResultData **parm;
{
  return (dec_f(_ZCompareResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_CompareResultData
/* ARGSUSED */
int	print_DAS_CompareResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCompareResultDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_CompareResult
int	encode_DAS_CompareResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_CompareResult *parm;
{
  return (enc_f(_ZCompareResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_CompareResult
int	decode_DAS_CompareResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_CompareResult **parm;
{
  return (dec_f(_ZCompareResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_CompareResult
/* ARGSUSED */
int	print_DAS_CompareResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZCompareResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_TInvokeID
int	encode_DAS_TInvokeID(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TInvokeID *parm;
{
  return (enc_f(_ZTInvokeIDDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_TInvokeID
int	decode_DAS_TInvokeID(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_TInvokeID **parm;
{
  return (dec_f(_ZTInvokeIDDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_TInvokeID
/* ARGSUSED */
int	print_DAS_TInvokeID(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZTInvokeIDDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AbandonArgument
int	encode_DAS_AbandonArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AbandonArgument *parm;
{
  return (enc_f(_ZAbandonArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AbandonArgument
int	decode_DAS_AbandonArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AbandonArgument **parm;
{
  return (dec_f(_ZAbandonArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AbandonArgument
/* ARGSUSED */
int	print_DAS_AbandonArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAbandonArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AbandonResult
int	encode_DAS_AbandonResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AbandonResult *parm;
{
  return (enc_f(_ZAbandonResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AbandonResult
int	decode_DAS_AbandonResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AbandonResult **parm;
{
  return (dec_f(_ZAbandonResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AbandonResult
/* ARGSUSED */
int	print_DAS_AbandonResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAbandonResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ListArgumentData
int	encode_DAS_ListArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ListArgumentData *parm;
{
  return (enc_f(_ZListArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ListArgumentData
int	decode_DAS_ListArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ListArgumentData **parm;
{
  return (dec_f(_ZListArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ListArgumentData
/* ARGSUSED */
int	print_DAS_ListArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZListArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ListArgument
int	encode_DAS_ListArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ListArgument *parm;
{
  return (enc_f(_ZListArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ListArgument
int	decode_DAS_ListArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ListArgument **parm;
{
  return (dec_f(_ZListArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ListArgument
/* ARGSUSED */
int	print_DAS_ListArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZListArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ListResultData
int	encode_DAS_ListResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ListResultData *parm;
{
  return (enc_f(_ZListResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ListResultData
int	decode_DAS_ListResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ListResultData **parm;
{
  return (dec_f(_ZListResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ListResultData
/* ARGSUSED */
int	print_DAS_ListResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZListResultDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ListResult
int	encode_DAS_ListResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ListResult *parm;
{
  return (enc_f(_ZListResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ListResult
int	decode_DAS_ListResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ListResult **parm;
{
  return (dec_f(_ZListResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ListResult
/* ARGSUSED */
int	print_DAS_ListResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZListResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SearchArgumentData
int	encode_DAS_SearchArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SearchArgumentData *parm;
{
  return (enc_f(_ZSearchArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SearchArgumentData
int	decode_DAS_SearchArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SearchArgumentData **parm;
{
  return (dec_f(_ZSearchArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SearchArgumentData
/* ARGSUSED */
int	print_DAS_SearchArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSearchArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SearchArgument
int	encode_DAS_SearchArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SearchArgument *parm;
{
  return (enc_f(_ZSearchArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SearchArgument
int	decode_DAS_SearchArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SearchArgument **parm;
{
  return (dec_f(_ZSearchArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SearchArgument
/* ARGSUSED */
int	print_DAS_SearchArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSearchArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SearchResultData
int	encode_DAS_SearchResultData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SearchResultData *parm;
{
  return (enc_f(_ZSearchResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SearchResultData
int	decode_DAS_SearchResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SearchResultData **parm;
{
  return (dec_f(_ZSearchResultDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SearchResultData
/* ARGSUSED */
int	print_DAS_SearchResultData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSearchResultDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SAlgorithmIdentifier
int	encode_DAS_SAlgorithmIdentifier(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SAlgorithmIdentifier *parm;
{
  return (enc_f(_ZSAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SAlgorithmIdentifier
int	decode_DAS_SAlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SAlgorithmIdentifier **parm;
{
  return (dec_f(_ZSAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SAlgorithmIdentifier
/* ARGSUSED */
int	print_DAS_SAlgorithmIdentifier(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSAlgorithmIdentifierDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SBitString
int	encode_DAS_SBitString(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SBitString *parm;
{
  return (enc_f(_ZSBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SBitString
int	decode_DAS_SBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SBitString **parm;
{
  return (dec_f(_ZSBitStringDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SBitString
/* ARGSUSED */
int	print_DAS_SBitString(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSBitStringDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SearchResult
int	encode_DAS_SearchResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SearchResult *parm;
{
  return (enc_f(_ZSearchResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SearchResult
int	decode_DAS_SearchResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SearchResult **parm;
{
  return (dec_f(_ZSearchResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SearchResult
/* ARGSUSED */
int	print_DAS_SearchResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSearchResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AddEntryArgumentData
int	encode_DAS_AddEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AddEntryArgumentData *parm;
{
  return (enc_f(_ZAddEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AddEntryArgumentData
int	decode_DAS_AddEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AddEntryArgumentData **parm;
{
  return (dec_f(_ZAddEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AddEntryArgumentData
/* ARGSUSED */
int	print_DAS_AddEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAddEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AddEntryArgument
int	encode_DAS_AddEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AddEntryArgument *parm;
{
  return (enc_f(_ZAddEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AddEntryArgument
int	decode_DAS_AddEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AddEntryArgument **parm;
{
  return (dec_f(_ZAddEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AddEntryArgument
/* ARGSUSED */
int	print_DAS_AddEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAddEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AddEntryResult
int	encode_DAS_AddEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AddEntryResult *parm;
{
  return (enc_f(_ZAddEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AddEntryResult
int	decode_DAS_AddEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AddEntryResult **parm;
{
  return (dec_f(_ZAddEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AddEntryResult
/* ARGSUSED */
int	print_DAS_AddEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAddEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_RemoveEntryArgumentData
int	encode_DAS_RemoveEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_RemoveEntryArgumentData *parm;
{
  return (enc_f(_ZRemoveEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_RemoveEntryArgumentData
int	decode_DAS_RemoveEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_RemoveEntryArgumentData **parm;
{
  return (dec_f(_ZRemoveEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_RemoveEntryArgumentData
/* ARGSUSED */
int	print_DAS_RemoveEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRemoveEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_RemoveEntryArgument
int	encode_DAS_RemoveEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_RemoveEntryArgument *parm;
{
  return (enc_f(_ZRemoveEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_RemoveEntryArgument
int	decode_DAS_RemoveEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_RemoveEntryArgument **parm;
{
  return (dec_f(_ZRemoveEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_RemoveEntryArgument
/* ARGSUSED */
int	print_DAS_RemoveEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRemoveEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_RemoveEntryResult
int	encode_DAS_RemoveEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_RemoveEntryResult *parm;
{
  return (enc_f(_ZRemoveEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_RemoveEntryResult
int	decode_DAS_RemoveEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_RemoveEntryResult **parm;
{
  return (dec_f(_ZRemoveEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_RemoveEntryResult
/* ARGSUSED */
int	print_DAS_RemoveEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRemoveEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyEntryArgumentData
int	encode_DAS_ModifyEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyEntryArgumentData *parm;
{
  return (enc_f(_ZModifyEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyEntryArgumentData
int	decode_DAS_ModifyEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyEntryArgumentData **parm;
{
  return (dec_f(_ZModifyEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyEntryArgumentData
/* ARGSUSED */
int	print_DAS_ModifyEntryArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyEntryArgument
int	encode_DAS_ModifyEntryArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyEntryArgument *parm;
{
  return (enc_f(_ZModifyEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyEntryArgument
int	decode_DAS_ModifyEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyEntryArgument **parm;
{
  return (dec_f(_ZModifyEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyEntryArgument
/* ARGSUSED */
int	print_DAS_ModifyEntryArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyEntryArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyEntryResult
int	encode_DAS_ModifyEntryResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyEntryResult *parm;
{
  return (enc_f(_ZModifyEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyEntryResult
int	decode_DAS_ModifyEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyEntryResult **parm;
{
  return (dec_f(_ZModifyEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyEntryResult
/* ARGSUSED */
int	print_DAS_ModifyEntryResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyEntryResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyRDNArgumentData
int	encode_DAS_ModifyRDNArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyRDNArgumentData *parm;
{
  return (enc_f(_ZModifyRDNArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyRDNArgumentData
int	decode_DAS_ModifyRDNArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyRDNArgumentData **parm;
{
  return (dec_f(_ZModifyRDNArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyRDNArgumentData
/* ARGSUSED */
int	print_DAS_ModifyRDNArgumentData(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyRDNArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyRDNArgument
int	encode_DAS_ModifyRDNArgument(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyRDNArgument *parm;
{
  return (enc_f(_ZModifyRDNArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyRDNArgument
int	decode_DAS_ModifyRDNArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyRDNArgument **parm;
{
  return (dec_f(_ZModifyRDNArgumentDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyRDNArgument
/* ARGSUSED */
int	print_DAS_ModifyRDNArgument(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyRDNArgumentDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ModifyRDNResult
int	encode_DAS_ModifyRDNResult(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyRDNResult *parm;
{
  return (enc_f(_ZModifyRDNResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ModifyRDNResult
int	decode_DAS_ModifyRDNResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ModifyRDNResult **parm;
{
  return (dec_f(_ZModifyRDNResultDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ModifyRDNResult
/* ARGSUSED */
int	print_DAS_ModifyRDNResult(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZModifyRDNResultDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_DirectoryBindError
int	encode_DAS_DirectoryBindError(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_DirectoryBindError *parm;
{
  return (enc_f(_ZDirectoryBindErrorDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_DirectoryBindError
int	decode_DAS_DirectoryBindError(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_DirectoryBindError **parm;
{
  return (dec_f(_ZDirectoryBindErrorDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_DirectoryBindError
/* ARGSUSED */
int	print_DAS_DirectoryBindError(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZDirectoryBindErrorDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AbandonFailedParm
int	encode_DAS_AbandonFailedParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AbandonFailedParm *parm;
{
  return (enc_f(_ZAbandonFailedParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AbandonFailedParm
int	decode_DAS_AbandonFailedParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AbandonFailedParm **parm;
{
  return (dec_f(_ZAbandonFailedParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AbandonFailedParm
/* ARGSUSED */
int	print_DAS_AbandonFailedParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAbandonFailedParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_AttributeErrorParm
int	encode_DAS_AttributeErrorParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AttributeErrorParm *parm;
{
  return (enc_f(_ZAttributeErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_AttributeErrorParm
int	decode_DAS_AttributeErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_AttributeErrorParm **parm;
{
  return (dec_f(_ZAttributeErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_AttributeErrorParm
/* ARGSUSED */
int	print_DAS_AttributeErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAttributeErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_NameErrorParm
int	encode_DAS_NameErrorParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_NameErrorParm *parm;
{
  return (enc_f(_ZNameErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_NameErrorParm
int	decode_DAS_NameErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_NameErrorParm **parm;
{
  return (dec_f(_ZNameErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_NameErrorParm
/* ARGSUSED */
int	print_DAS_NameErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZNameErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ReferralParm
int	encode_DAS_ReferralParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReferralParm *parm;
{
  return (enc_f(_ZReferralParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ReferralParm
int	decode_DAS_ReferralParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ReferralParm **parm;
{
  return (dec_f(_ZReferralParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ReferralParm
/* ARGSUSED */
int	print_DAS_ReferralParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZReferralParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_SecurityErrorParm
int	encode_DAS_SecurityErrorParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SecurityErrorParm *parm;
{
  return (enc_f(_ZSecurityErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_SecurityErrorParm
int	decode_DAS_SecurityErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_SecurityErrorParm **parm;
{
  return (dec_f(_ZSecurityErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_SecurityErrorParm
/* ARGSUSED */
int	print_DAS_SecurityErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZSecurityErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_ServiceErrorParm
int	encode_DAS_ServiceErrorParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ServiceErrorParm *parm;
{
  return (enc_f(_ZServiceErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_ServiceErrorParm
int	decode_DAS_ServiceErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_ServiceErrorParm **parm;
{
  return (dec_f(_ZServiceErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_ServiceErrorParm
/* ARGSUSED */
int	print_DAS_ServiceErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZServiceErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_DAS_UpdateErrorParm
int	encode_DAS_UpdateErrorParm(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_UpdateErrorParm *parm;
{
  return (enc_f(_ZUpdateErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_DAS_UpdateErrorParm
int	decode_DAS_UpdateErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_DAS_UpdateErrorParm **parm;
{
  return (dec_f(_ZUpdateErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_DAS_UpdateErrorParm
/* ARGSUSED */
int	print_DAS_UpdateErrorParm(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZUpdateErrorParmDAS, &_ZDAS_mod, pe, top, len, buffer));
}

#undef encode_NRS_Context
int	encode_NRS_Context(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_NRS_Context *parm;
{
  return (enc_f(_ZContextNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_NRS_Context
int	decode_NRS_Context(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_NRS_Context **parm;
{
  return (dec_f(_ZContextNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_NRS_Context
/* ARGSUSED */
int	print_NRS_Context(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZContextNRS, &_ZNRS_mod, pe, top, len, buffer));
}

#undef encode_NRS_Address__space__id
int	encode_NRS_Address__space__id(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_NRS_Address__space__id *parm;
{
  return (enc_f(_ZAddress_space_idNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_NRS_Address__space__id
int	decode_NRS_Address__space__id(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_NRS_Address__space__id **parm;
{
  return (dec_f(_ZAddress_space_idNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_NRS_Address__space__id
/* ARGSUSED */
int	print_NRS_Address__space__id(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAddress_space_idNRS, &_ZNRS_mod, pe, top, len, buffer));
}

#undef encode_NRS_Route__cost
int	encode_NRS_Route__cost(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_NRS_Route__cost *parm;
{
  return (enc_f(_ZRoute_costNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_NRS_Route__cost
int	decode_NRS_Route__cost(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_NRS_Route__cost **parm;
{
  return (dec_f(_ZRoute_costNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_NRS_Route__cost
/* ARGSUSED */
int	print_NRS_Route__cost(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZRoute_costNRS, &_ZNRS_mod, pe, top, len, buffer));
}

#undef encode_NRS_Addressing__info
int	encode_NRS_Addressing__info(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_NRS_Addressing__info *parm;
{
  return (enc_f(_ZAddressing_infoNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_NRS_Addressing__info
int	decode_NRS_Addressing__info(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_NRS_Addressing__info **parm;
{
  return (dec_f(_ZAddressing_infoNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_NRS_Addressing__info
/* ARGSUSED */
int	print_NRS_Addressing__info(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZAddressing_infoNRS, &_ZNRS_mod, pe, top, len, buffer));
}

#undef encode_NRS_NRSInformation
int	encode_NRS_NRSInformation(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_NRS_NRSInformation *parm;
{
  return (enc_f(_ZNRSInformationNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef decode_NRS_NRSInformation
int	decode_NRS_NRSInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer;
struct type_NRS_NRSInformation **parm;
{
  return (dec_f(_ZNRSInformationNRS, &_ZNRS_mod, pe, top, len, buffer,
		(char **) parm));
}

#undef print_NRS_NRSInformation
/* ARGSUSED */
int	print_NRS_NRSInformation(pe, top, len, buffer, parm)
PE	pe;
int	top,
       *len;
char  **buffer,
       *parm;
{
  return (prnt_f(_ZNRSInformationNRS, &_ZNRS_mod, pe, top, len, buffer));
}