/* llib-ldsap - lint library for -ldsap */

/* llib-lcommon - lint library for QUIPU-common */

/*
 * $Header: /xtel/isode/isode/dsap/common/RCS/llib-lcommon,v 9.0 1992/06/16 12:12:39 isode Rel $
 *
 *
 * $Log: llib-lcommon,v $
 * Revision 9.0  1992/06/16  12:12:39  isode
 * Release 8.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 <signal.h>
#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/connection.h"
#include "quipu/list.h"     
#include "quipu/ds_search.h"
#include "quipu/ufn.h"
#include "pepsy.h"
#include "osisec-stub.h"


struct acl_info * acl_info_new (x,y,z) 
register int x,y; 
struct dn_seq * z; 
{
	return (acl_info_new(x,y,z));
} 

struct acl_info * acl_default () 
{
	return (acl_default());
} 

int	  acl_cmp (acl1, acl2)
struct acl	* acl1;
struct acl	* acl2;
{
	return (acl_cmp(acl1,acl2));
}

get_default_acl () 
{
	(void) get_default_acl();
} 

set_default_acl (ai_ptr) 
struct acl_info * ai_ptr; 
{
	(void) set_default_acl(ai_ptr);
} 

test_acl_default (a)
struct acl_info * a;
{
	return (test_acl_default (a));
}

acl_syntax ()
{
	(void) (acl_syntax ());
}

as_cmp_comp (a,b) 
Attr_Sequence a,b; 
{
	return (as_cmp_comp(a,b));
} 

as_cmp (a,b) 
Attr_Sequence a,b; 
{
	return (as_cmp(a,b));
} 


Attr_Sequence as_comp_cpy (as) 
Attr_Sequence as; 
{
	return (as_comp_cpy(as));
} 

Attr_Sequence as_cpy (as) 
Attr_Sequence as; 
{
	return (as_cpy(as));
} 


as_delnext (as) 
Attr_Sequence as; 
{
	(void) as_delnext(as);
} 


Attr_Sequence as_find_type (a,b) 
Attr_Sequence a; 
AttributeType b; 
{
	return (as_find_type(a,b));
} 


as_comp_free (as) 
Attr_Sequence as; 
{
	(void) as_comp_free(as);
} 

as_free (as) 
Attr_Sequence as; 
{
	(void) as_free(as);
} 

Attr_Sequence as_merge_aux (a,b) 
Attr_Sequence a,b; 
{
	return (as_merge_aux (a,b));
} 

Attr_Sequence as_merge (a,b) 
Attr_Sequence a,b; 
{
	return (as_merge(a,b));
} 


Attr_Sequence as_comp_new (at,as,acl) 
AttributeType at; 
AV_Sequence as; 
struct acl_info * acl; 
{
	return (as_comp_new(at,as,acl));
} 


as_comp_print (ps,as,format) 
PS ps; 
Attr_Sequence as; 
int format; 
{
	(void) as_comp_print(ps,as,format);
} 

as_print (ps,as,format) 
Attr_Sequence as; 
PS ps; 
int format; 
{
	(void) as_print(ps,as,format);
} 


Attr_Sequence str2as (str) 
register char * str; 
{
	return (str2as(str));
} 

Attr_Sequence as_combine (as,str,allownull) 
Attr_Sequence as; 
register char * str; 
char allownull;
{
	return (as_combine(as,str,allownull));
} 

oid_table_attr * AttrT_new_aux (name) 
register char * name; 
{
	return (AttrT_new_aux(name));
} 

AttributeType AttrT_new (name) 
register char * name; 
{
	return (AttrT_new(name));
} 


AttrT_print (ps,x,format) 
register PS ps; 
register AttributeType x; 
register int format; 
{
	(void) AttrT_print(ps,x,format);
} 

short add_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
char * sntx; 
IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
char * print_pe; 
char multiline; 
{
	return (add_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline));
} 

set_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline) 
short sntx; 
IFP enc,dec,parse,print,cpy,cmp,sfree,approx; 
char * print_pe; 
char multiline; 
{
	(void) set_attribute_syntax(sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline);
} 

set_av_pe_print (sntx,print_pe) 
short sntx; 
char * print_pe; 
{
	(void) set_av_pe_print(sntx,print_pe);
} 
set_av_printer (sntx,print_pe) 
short sntx; 
IFP print_pe; 
{
	(void) set_av_printer (sntx,print_pe);
} 
short modify_av_printer (at,sntx,print)
AttributeType at;
char * sntx;
IFP print;
{
	return modify_av_printer (at,sntx,print);
}

split_attr (as) 
Attr_Sequence as; 
{
	return (split_attr(as));
} 

IFP approxfn (x) 
short x; 
{
	return (approxfn(x));
} 

char * syntax2str (sntx) 
int sntx; 
{
	return (syntax2str(sntx));
} 

short str2syntax (str) 
char * str; 
{
	return (str2syntax(str));
} 

sntx_table * get_syntax_table (x) 
short x; 
{
	return (get_syntax_table(x));
} 

AttrV_free (x) 
register AttributeValue x; 
{
	(void) AttrV_free(x);
} 

AttrV_free_aux (x) 
register AttributeValue x; 
{
	(void) AttrV_free_aux(x);
} 

PE grab_pe(av) 
AttributeValue av; 
{
	return (grab_pe(av));
} 

AttrV_decode(x,y) 
register AttributeType x; 
register AttributeValue y; 
{
	return (AttrV_decode(x,y));
} 


str_at2AttrV_aux (str,at,rav)
char * str;
AttributeType at;
AttributeValue rav;
{
	return str_at2AttrV_aux (str,at,rav);
}

AttributeValue str_at2AttrV (str,at)
char * str;
AttributeType at;
{
	return str_at2AttrV (str,at);
}

AttributeValue str2AttrV (str,syntax)
register char * str;
short syntax;
{
	return (str2AttrV (str,syntax));
}

str2AttrV_aux (str,syntax,x)
register char * str;
short syntax;
AttributeValue x;
{
	return str2AttrV_aux(str,syntax,x);
}

AttributeValue AttrV_cpy (x)
register AttributeValue x;
{
	return ( AttrV_cpy (x));
}

AttrV_cpy_aux (x,y)
register AttributeValue x;
register AttributeValue y;
{
	(void) AttrV_cpy_aux (x,y);
}

AttrV_cpy_enc (x,y)
register AttributeValue x;
register AttributeValue y;
{
	(void) AttrV_cpy_enc (x,y);
}

AttrV_cmp (x,y)
register AttributeValue x,y;
{
	return AttrV_cmp (x,y);
}

IFP av_cmp_fn (syntax)
int syntax;
{
	return av_cmp_fn (syntax);
}

AttrV_print (ps,x,format)
register PS ps;
register AttributeValue x;
register int format;
{
	(void) AttrV_print (ps,x,format);
}

avs_cmp (a,b) 
AV_Sequence a,b; 
{
	return (avs_cmp(a,b));
} 

AV_Sequence avs_comp_cpy (avs) 
AV_Sequence avs; 
{
	return (avs_comp_cpy(avs));
} 

AV_Sequence avs_cpy (avs) 
AV_Sequence avs; 
{
	return (avs_cpy(avs));
} 

AV_Sequence avs_cpy_enc (avs) 
AV_Sequence avs; 
{
	return (avs_cpy_enc(avs));
} 


avs_delnext (avs) 
AV_Sequence avs; 
{
	(void) avs_delnext(avs);
} 


avs_comp_free (avs) 
AV_Sequence avs; 
{
	(void) avs_comp_free(avs);
} 

avs_free (avs) 
AV_Sequence avs; 
{
	(void) avs_free(avs);
} 

AV_Sequence avs_merge (a,b) 
AV_Sequence a,b; 
{
	return (avs_merge(a,b));
} 


avs_comp_fill (ptr,pe) 
AV_Sequence ptr; 
AttributeValue pe; 
{
	(void) avs_comp_fill(ptr,pe);
} 

AV_Sequence avs_comp_new (pe) 
AttributeValue pe; 
{
	return (avs_comp_new(pe));
} 

avs_print (ps,avs,format) 
AV_Sequence avs; 
PS ps; 
int format; 
{
	(void) avs_print(ps,avs,format);
} 

avs_print_aux (ps,avs,format,sep) 
AV_Sequence avs; 
PS ps; 
int format; 
char * sep;
{
	(void) avs_print_aux(ps,avs,format,sep);
} 


AV_Sequence str2avs (str,at) 
char * str; 
AttributeType at; 
{
	return (str2avs(str,at));
} 

boolean_syntax () 
{
	(void) boolean_syntax();
} 


struct common_args * get_ca_ref(dsarg) 
struct ds_op_arg * dsarg; 
{
	return get_ca_ref(dsarg);
} 

cha_loopdetected(cha) 
struct chain_arg * cha; 
{
	return cha_loopdetected(cha);
} 

ti_is_elem(ti, ti_list) 
struct trace_info * ti; 
struct trace_info * ti_list; 
{
	return ti_is_elem(ti,ti_list);
} 

struct trace_info * ti_cpy(ti) 
struct trace_info * ti; 
{
	return ti_cpy(ti);
} 


correlate_search_results(sr_res) 
struct ds_search_result * sr_res; 
{
	(void) correlate_search_results(sr_res);
} 

merge_search_results(sr_res, sr_tmp) 
struct ds_search_result * sr_res; 
struct ds_search_result * sr_tmp; 
{
	(void) merge_search_results(sr_res,sr_tmp);
} 

search_result_free(arg) 
struct ds_search_result * arg; 
{
	(void) search_result_free(arg);
} 


dn_append (a,b) 
DN a,b; 
{
	(void) dn_append(a,b);
} 


dn_cmp (a,b) 
register DN a,b; 
{
	return (dn_cmp(a,b));
} 

dn_cmp_prefix (a,b) 
register DN a,b; 
{
	return (dn_cmp_prefix(a,b));
} 


DN dn_comp_cpy (dn) 
register DN dn; 
{
	return (dn_comp_cpy(dn));
} 

DN dn_cpy (dn) 
register DN dn; 
{
	return (dn_cpy(dn));
} 


dn_comp_free (dn) 
DN dn; 
{
	(void) dn_comp_free(dn);
} 
dn_free (dn) 
DN dn; 
{
	(void) dn_free(dn);
} 


DN dn_comp_new (rdn) 
RDN rdn; 
{
	return (dn_comp_new(rdn));
} 


void dn_print (ps,dn,format) 
DN dn; 
PS ps; 
int format; 
{
	dn_print(ps,dn,format);
} 

void ufn_dn_print (ps,dn,multiline)
PS  ps;
DN  dn;
char multiline;
{
	ufn_dn_print (ps,dn,multiline);
}
void dn_rfc_print(ps, dn, sep)
PS ps;
DN dn;
char * sep;
{
	dn_rfc_print(ps, dn, sep);
}

ufn_dn_print_aux (ps,dn,marker,multiline)
PS  ps;
DN  dn;
DN marker;
int	multiline;
{
	(void) ufn_dn_print_aux (ps,dn,marker,multiline);
} 

void ufn_rdn_print (ps,rdn)
RDN  rdn;
PS   ps;
{	
	(void) ufn_rdn_print (ps,rdn);
}
char * dn2str(dn)
DN dn;
{
	return dn2str(dn);
}
char * dn2ufn(dn,multiline)
DN dn;
char multiline;
{
	return dn2ufn(dn,multiline);
}

char   *dn2rfc (dn,sep)
DN	dn;
char   *sep;
{
	return dn2rfc(dn,sep);
}
dn_seq_free (dnseq) 
struct dn_seq * dnseq; 
{
	(void) dn_seq_free(dnseq);
} 

struct dn_seq * dn_seq_cpy (dnseq) 
struct dn_seq * dnseq; 
{
	return (dn_seq_cpy(dnseq));
} 

check_dnseq (dnseq,who) 
struct dn_seq * dnseq; 
DN who; 
{
	return (check_dnseq(dnseq,who));
} 

dn_seq_cmp (a,b) 
struct dn_seq * a, * b; 
{
	return (dn_seq_cmp(a,b));
} 

check_dnseq_prefix (dnseq,who) 
struct dn_seq * dnseq; 
DN who; 
{
	return (check_dnseq_prefix(dnseq,who));
} 

dn_seq_print (ps,dnseq,format) 
PS ps; 
struct dn_seq * dnseq; 
int format; 
{
	(void) dn_seq_print(ps,dnseq,format);
} 

struct dn_seq * str2dnseq (str) 
register char * str; 
{
	return (str2dnseq(str));
} 

int       dn_in_dnseq(dn, dnseq)
DN                dn;
struct dn_seq   * dnseq;
{
	return (dn_in_dnseq(dn, dnseq));
}

struct dn_seq   * dn_seq_push(dn,dnseq)
DN                dn;
struct dn_seq   * dnseq;
{
	return dn_seq_push(dn,dnseq);
}

struct dn_seq   * dn_seq_pop(dnseq)
struct dn_seq   * dnseq;
{
	return dn_seq_pop(dnseq);
}

DN str2dn (str) 
register char * str; 
{
	return (str2dn(str));
} 

DN str2dn_aux (str,alias) 
char * str; 
char *alias; 
{
	return (str2dn_aux(str,alias));
} 

DN str2dnX (str) 
register char * str; 
{
	return (str2dnX(str));
} 

DN dn_dec (pe)
PE pe;
{
	return dn_dec (pe);
}

PE dn_enc (dn)
DN dn;
{
	return dn_enc (dn);
}

dn_syntax ()
{
	(void) dn_syntax ();
}

DN dq2dn (designator, qualifier) 
char *designator, 
*qualifier; 
{
	return (dq2dn(designator,qualifier));
} 

edbinfo_syntax ()
{
	(void) edbinfo_syntax ();
}

entryinfo_comp_free (a,state) 
register EntryInfo *a; 
int state; 
{
	(void) entryinfo_comp_free(a,state);
} 

entryinfo_free (a,state) 
register EntryInfo * a; 
register int state; 
{
	(void) entryinfo_free(a,state);
} 

entryinfo_cpy (a,b) 
register EntryInfo *a; 
register EntryInfo *b; 
{
	(void) entryinfo_cpy(a,b);
} 

entryinfo_append (a,b) 
register EntryInfo *a,*b; 
{
	(void) entryinfo_append(a,b);
} 

entryinfo_merge (a,b,fast) 
EntryInfo *a,*b;
int fast; 
{
	(void) entryinfo_merge(a,b,fast);
} 

entryinfo_print (ps,entryinfo,format) 
PS ps; 
EntryInfo *entryinfo; 
int format; 
{
	(void) entryinfo_print(ps,entryinfo,format);
} 

fax_syntax ()
{
	(void) fax_syntax ();
}

struct file_syntax * fileattr_cpy (fs) 
struct file_syntax * fs; 
{
	return (fileattr_cpy(fs));
} 

file_cmp (a,b) 
struct file_syntax *a, *b; 
{
	return (file_cmp(a,b));
} 

PE grab_filepe (av) 
AttributeValue av; 
{
	return (grab_filepe(av));
}


file_decode (x)
AttributeValue x;
{
	(void) file_decode (x);
}

#ifndef SYS5
/* ARGSUSED */
#endif
int dflt_attr_file (at,x,full) 
AttributeType at; 
AttributeValue x; 
char full;
{
	return (dflt_attr_file(at,x,full));
} 

fileattr_print (ps,y,format) 
PS ps; 
AttributeValue y; 
int format; 
{
	(void) fileattr_print(ps,y,format);
} 


str2file_aux (str,at,x) 
char * str; 
AttributeType at; 
AttributeValue x; 
{
	return (str2file_aux(str,at,x));
} 

AttributeValue str2file (str,at) 
char * str; 
AttributeType at; 
{
	return (str2file(str,at));
} 

file_free (fs) 
struct file_syntax * fs; 
{
	(void) file_free(fs);
} 

filter_free (filt) 
Filter filt; 
{
	(void) filter_free(filt);
} 

filter_append (a,b) 
Filter a,b; 
{
	(void) filter_append(a,b);
} 

Filter strfilter (at,s,type)
AttributeType at;
char * s;
char type;
{
	return strfilter (at,s,type);
}

Filter ocfilter (s)
char * s;
{
	return ocfilter (s);
}

Filter joinfilter (f, type)
Filter f;
char type;
{
	return joinfilter (f, type);
}

print_filter (nps, fi, level)
PS nps;
register Filter fi;
int     level;
{
	(void) print_filter (nps, fi, level);
}

guide_syntax ()
{
	(void) guide_syntax ();
}

integer_syntax () 
{
	(void) integer_syntax();
} 

mailbox_syntax () 
{
	(void) mailbox_syntax();
} 

objectclass * oc_add (oid) 
OID oid; 
{
	return (oc_add(oid));
} 

check_in_oc (oid,avs) 
OID oid; 
AV_Sequence avs; 
{
	return (check_in_oc(oid,avs));
} 

oc_print (ps,oc,format)
PS ps;
objectclass * oc;
int format;
{
	(void) oc_print (ps,oc,format);
}

objectclass_syntax () 
{
	(void) objectclass_syntax();
} 

int load_oid_table (table) 
char * table; 
{
	return load_oid_table(table);
} 

add_entry_aux (a,b,c,d) 
char * a; 
caddr_t b; 
int c; 
char * d; 
{
	(void) add_entry_aux(a,b,c,d);
} 

char * get_oid (str) 
char * str; 
{
	return (get_oid(str));
} 

oid_table_attr *name2attr(nodename) 
char * nodename; 
{
	return (name2attr(nodename));
} 

set_heap (x) 
AttributeType x; 
{
	return (set_heap(x));
} 

oid_table_attr *oid2attr(oid) 
OID oid; 
{
	return (oid2attr(oid));
} 

objectclass *name2oc(nodename) 
register char * nodename; 
{
	return (name2oc(nodename));
} 

objectclass *oid2oc(oid) 
OID oid; 
{
	return (oid2oc(oid));
} 

char *attr2name(oa,format) 
register oid_table_attr *oa; 
int format; 
{
	return (attr2name(oa,format));
} 

char *oc2name(oc,format) 
register objectclass *oc; 
int format; 
{
	return (oc2name(oc,format));
} 

char *oid2name(oid,format) 
OID oid; 
int format; 
{
	return (oid2name(oid,format));
} 

OID name2oid (str) 
register char * str; 
{
	return (name2oid(str));
} 

PE oid2pe (o) 
OID o; 
{
	return (oid2pe(o));
} 

oidprint (ps,o,format) 
PS ps; 
OID o; 
int format; 
{
	(void) oidprint(ps,o,format);
} 

OID dup_prim2oid (pe) 
PE pe; 
{
	return (dup_prim2oid(pe));
} 

oid_syntax () 
{
	(void) oid_syntax();
} 

want_oc_hierarchy () 
{
	(void) want_oc_hierarchy();
} 

load_obj_hier (sep,newname) 
char * sep; 
char * newname; 
{
	return load_obj_hier(sep,newname);
} 

void dumpalloid () 
{
	dumpalloid();
} 

objectclass * str2oc (str)
char * str;
{
	return (str2oc (str));
}

add_oc_macro (buf,ptr) 
char * buf, *ptr; 
{
	(void) add_oc_macro(buf,ptr);
} 

oid_seq_free (ptr) 
struct oid_seq * ptr; 
{
	(void) oid_seq_free(ptr);
} 

struct oid_seq *oid_seq_merge (a,b) 
struct oid_seq *a; 
struct oid_seq *b; 
{
	return (oid_seq_merge(a,b));
} 

oid_seq_cmp (a,b) 
struct oid_seq *a, *b; 
{
	return (oid_seq_cmp(a,b));
} 

struct oid_seq * oid_seq_cpy (a) 
struct oid_seq * a; 
{
	return (oid_seq_cpy(a));
} 

oid_seq_print (ps,ptr,format) 
PS ps; 
register struct oid_seq * ptr; 
int format; 
{
	(void) oid_seq_print(ps,ptr,format);
} 

struct oid_seq * str2oidseq (str) 
char * str; 
{
	return (str2oidseq(str));
} 

parse_error (a,b) 
char *a, *b; 
{
	(void) parse_error(a,b);
} 

pref_deliv_syntax ()
{
	(void) pref_deliv_syntax ();
}

pe_print (ps, pe, format) 
register PS ps; 
register PE pe; 
int format; 
{
	(void) pe_print (ps,pe,format);
} 

PE asn2pe (str) 
char * str; 
{
	return (asn2pe(str));
} 

char * show_picture (picture,picture_process,len) 
char *picture; 
char *picture_process; 
int len; 
{
	return (show_picture(picture,picture_process,len));
} 

exec_print (ps,av,proc) 
PS ps; 
AttributeValue av; 
char * proc; 
{
	(void) exec_print(ps,av,proc);
} 

hide_picture () 
{
	(void) hide_picture();
} 

picture_print (ps,pe,format) 
PS ps; 
PE pe; 
int format; 
{
	(void) picture_print(ps,pe,format);
} 

photo_syntax () 
{
	(void) photo_syntax();
} 

post_syntax () 
{
	(void) post_syntax();
} 


psap_free (psap) 
struct PSAPaddr * psap; 
{
	(void) psap_free(psap);
} 

struct PSAPaddr * psap_cpy (a) 
struct PSAPaddr * a; 
{
	return (psap_cpy(a));
} 

psap_dup (r,a) 
struct PSAPaddr * r, * a; 
{
	(void) psap_dup(r,a);
} 

psap_syntax () 
{
	(void) psap_syntax();
} 

quipu_syntaxes () 
{
	(void) quipu_syntaxes();
} 

rdn_cmp_comp (a,b) 
RDN a,b; 
{
	return (rdn_cmp_comp(a,b));
} 

rdn_cmp (a,b) 
register RDN a,b; 
{
	return (rdn_cmp(a,b));
} 


RDN rdn_comp_cpy (rdn) 
RDN rdn; 
{
	return (rdn_comp_cpy(rdn));
} 

RDN rdn_cpy (rdn) 
RDN rdn; 
{
	return (rdn_cpy(rdn));
} 


rdn_comp_free (rdn) 
RDN rdn; 
{
	(void) rdn_comp_free(rdn);
} 

rdn_free (rdn) 
RDN rdn; 
{
	(void) rdn_free(rdn);
} 


RDN rdn_merge (a,b) 
RDN a,b; 
{
	return (rdn_merge(a,b));
} 


RDN rdn_comp_new (at,av) 
AttributeType at; 
AttributeValue av; 
{
	return (rdn_comp_new(at,av));
} 


rdn_comp_print (ps,rdn,format) 
PS ps; 
RDN rdn; 
int format; 
{
	(void) rdn_comp_print(ps,rdn,format);
} 

rdn_print (ps,rdn,format) 
RDN rdn; 
PS ps; 
int format; 
{
	(void) rdn_print(ps,rdn,format);
} 


RDN str2rdn_aux (str) 
char * str; 
{
	return (str2rdn_aux(str));
} 

RDN str2rdn (str) 
char * str; 
{
	return (str2rdn(str));
} 

stop_listeners () 
{
	(void) stop_listeners();
} 

soundex_cmp (a,b)
register char * a;
register char * b;
{
	return (soundex_cmp (a,b));
}

soundex_match (fitem,avs) 
register struct filter_item *fitem; 
register AV_Sequence avs; 
{
	return (soundex_match(fitem,avs));
} 

standard_syntaxes () 
{
	(void) standard_syntaxes();
} 

char * octparse (str) 
char * str; 
{
	return (octparse(str));
} 

char * prtparse (str) 
char * str; 
{
	return (prtparse(str));
} 

sfree (x) 
char *x; 
{
	(void) sfree(x);
} 

pstrcmp (a,b)
char * a, *b;
{
	return pstrcmp (a,b);
}

telcmp (a, b) 
char *a, 
*b; 
{
	return (telcmp(a,b));
} 

strprint (ps,str,format) 
PS ps; 
char * str; 
int format; 
{
	(void) strprint(ps,str,format);
} 

octprint (ps,str,format) 
PS ps; 
char * str; 
int format; 
{
	(void) octprint(ps,str,format);
} 

case_exact_match (sntx) 
short sntx; 
{
	return (case_exact_match(sntx));
} 

approx_string (sntx) 
short sntx; 
{
	return (approx_string(sntx));
} 

sub_string (sntx) 
short sntx; 
{
	return (sub_string(sntx));
} 

string_syntaxes () 
{
	(void) string_syntaxes();
} 


teletex_syntax () 
{
	(void) teletex_syntax();
} 

telex_syntax () 
{
	(void) telex_syntax();
} 

utcprint (ps,xtime,format)
PS ps;
char *xtime;
int format;
{
	(void) utcprint (ps,xtime,format);
}

time_syntax () 
{
	(void) time_syntax();
} 

schema_syntax () 
{
	(void) schema_syntax();
} 

char * SkipSpace (ptr) 
register char * ptr; 
{
	return (SkipSpace(ptr));
} 

void StripSpace (b) 
register char *b; 
{
	StripSpace (b);
} 

void StripSpace2 (b) 
register char *b; 
{
	StripSpace2 (b);
} 

char * TidyString (a) 
register char * a; 
{
	return (TidyString(a));
} 

test_prim_pe (pe,class,id) 
PE pe; 
PElementClass class; 
PElementID id; 
{
	return (test_prim_pe(pe,class,id));
} 

/* VARARGS2 */
ps_printf (ps,fmt) 
PS ps; 
char * fmt; 
{
	(void) ps_printf(ps,fmt);
} 

fatal (code,fmt) 
int code; 
char *fmt; 
{
	(void) fatal(code,fmt);
} 

pslog (lp,event,str,func,ptr) 
LLog * lp; 
int event; 
char * str; 
int (*func) (); 
caddr_t ptr; 
{
	(void) pslog(lp,event,str,func,ptr);
} 

quipu_pe_cmp (a,b) 
register PE a,b; 
{
	return (quipu_pe_cmp(a,b));
} 

struct acl_info * acl_dflt () 
{
	return (acl_dflt());
} 

/* VARARGS2 */
dsap_init(acptr,avptr)
int *acptr;
char *** avptr;
{
        (void) dsap_init(acptr,avptr);
}

dsap_tai (argc, argv)
char    **argv;
{
        return (dsap_tai (argc, argv));
}

tai_args (acptr,avptr)
int *acptr;
char ***avptr;
{
        (void) tai_args (acptr,avptr);
}

dsap_tai_init()
{
        return (dsap_tai_init());
}


tai_string (str)
char * str;
{
        return (tai_string (str));
}

ds_error (ps,err)
PS ps;
struct DSError *err;
{
	(void) ds_error (ps,err);
}
ds_bind_error_aux (ps, err, mode)
PS ps;
struct ds_bind_error *err;
int mode;
{
	(void) ds_bind_error_aux (ps, err, mode);
}
char * print_bind_error (err, mode)
struct ds_bind_error *err;
int mode;
{
	return print_bind_error (err, mode);
}

log_ds_error (err)
struct DSError *err;
{
	(void) log_ds_error (err);
}

ds_error_free (err)
struct DSError * err;
{
	(void) ds_error_free (err);
}

struct subordinate * subord_cpy (x) 
struct subordinate * x; 
{
	return (subord_cpy(x));
} 

cache_list (ptr, prob,dn,sizelimit) 
struct subordinate *ptr; 
int prob; 
DN dn; 
int sizelimit; 
{
	(void) cache_list (ptr,prob,dn,sizelimit);
} 

delete_list_cache (adn)
DN adn;
{
	(void) delete_list_cache (adn);
}

struct list_cache *find_list_cache (dn,sizelimit) 
DN dn; 
int sizelimit; 
{
	return (find_list_cache(dn,sizelimit));
} 

cache_entry (ptr, complete, vals) 
EntryInfo *ptr; 
char complete; 
char vals; 
{
	(void) cache_entry (ptr, complete, vals);
} 

delete_cache (adn) 
DN adn; 
{
	(void) delete_cache(adn);
} 

Entry local_find_entry (object,deref) 
DN object; 
char deref; 
{
	return (local_find_entry(object,deref));
} 

Entry local_find_entry_aux (object,deref) 
DN object; 
char deref; 
{
	return (local_find_entry_aux(object,deref));
} 

DN get_copy_dn (entryptr) 
Entry entryptr; 
{
	return (get_copy_dn(entryptr));
} 

unravel_attribute (eptr,error) 
Entry eptr; 
struct DSError * error; 
{
	return (unravel_attribute(eptr,error));
} 

check_schema (eptr,as,error) 
Entry eptr; 
Attr_Sequence as; 
struct DSError * error; 
{
	return (check_schema(eptr,as,error));
} 

char * new_version ()
{
	return new_version();
}

directory_free (directory) 
Entry directory; 
{
	(void) directory_free(directory);
} 

entry_free (entryptr) 
Entry entryptr; 
{
	(void) entry_free(entryptr);
} 

Entry entry_cpy (entryptr) 
register Entry entryptr; 
{
	return (entry_cpy(entryptr));
} 

Entry get_default_entry (parent) 
Entry parent; 
{
	return (get_default_entry(parent));
} 

check_known_oids () 
{
	(void) check_known_oids();
} 

char * getline (file)
FILE * file;
{
	return getline (file);
}

Attr_Sequence get_attributes_aux (file) 
FILE * file; 
{
	return (get_attributes_aux(file));
} 

Attr_Sequence get_attributes (file) 
FILE * file; 
{
	return (get_attributes(file));
} 

Entry get_entry_aux (file,parent,dtype) 
FILE * file; 
Entry parent; 
int dtype; 
{
	return (get_entry_aux(file,parent,dtype));
} 

Entry get_entry (file,parent,dtype) 
FILE * file; 
Entry parent; 
int dtype; 
{
	return (get_entry(file,parent,dtype));
} 

Entry new_constructor (parent) 
Entry parent; 
{
	return (new_constructor(parent));
} 

Entry make_path (dn) 
DN dn; 
{
	return (make_path(dn));
} 


DNS DNS_append (a,b)
DNS a, b;
{
	return DNS_append (a,b);
}

dnSelect (s,dlist,interact,el)
char * s;
DNS *dlist;
DNS (* interact) ();
DNS el;
{
	return dnSelect (s,dlist,interact,el);
}

ufn_search (base, subtree, filt, res, s, interact, el)
DN base;
char subtree;
Filter filt;
DNS * res;
char * s;
DNS (* interact) ();
DNS el;
{
	return ufn_search (base, subtree, filt, res, s, interact, el);
}

envlist read_envlist()
{
	return read_envlist();
}

ufn_match (c,v,interact,result,el)
int c;
char ** v;
DNS (* interact) ();
DNS * result;
envlist el;
{
	return ufn_match (c,v,interact,result,el);
}


ufn_init ()
{
	return ufn_init ();
}


aet_match (c,v,interact,result,el,context)
int c;
char ** v;
DNS *result;
DNS (* interact) ();
envlist el;
char * context;
{
	return aet_match (c,v,interact,result,el,context);
}

set_lookup_ufn (flag)
char	flag;
{
    set_lookup_ufn (flag);
}

set_lookup_dap (flag)
char flag;
{
	set_lookup_dap (flag);
}


reset_arg () 
{
	(void) reset_arg();
} 

print_arg_error (opt) 
PS opt; 
{
	return (print_arg_error(opt));
} 

int test_arg (x, y, c) 
char *x; 
char *y; 
int c; 
{
	return test_arg (x, y, c);
} 


set_default_service (opt) 
PS opt; 
{
	return (set_default_service(opt));
} 

int get_default_service (ca) 
CommonArgs * ca; 
{
	return (get_default_service(ca));
} 

int service_control (opt,argc, argv, ca) 
PS opt; 
int argc; 
char **argv; 
CommonArgs *ca; 
{
	return service_control (opt,argc, argv, ca);
} 

int do_service_control (opt,argc, argv, ca) 
PS opt; 
int argc; 
char **argv; 
CommonArgs *ca; 
{
	return do_service_control (opt,argc, argv, ca);
} 

shuffle_up (argc, argv, start) 
register int argc; 
char **argv; 
register int start; 
{
	(void) shuffle_up (argc, argv, start);
} 

new_service (ptr) 
char * ptr; 
{
	(void) new_service(ptr);
} 


subords_free(subp) 
struct subordinate *subp; 
{
	(void) subords_free(subp);
} 

ems_free(emp) 
struct entrymod *emp; 
{
	(void) ems_free(emp);
} 

aps_free(app) 
struct access_point *app; 
{
	(void) aps_free(app);
} 

crefs_free(crefp) 
ContinuationRef crefp; 
{
	(void) crefs_free(crefp);
} 


avl_insert( root, data, fcmp, fdup )
Avlnode	**root;
caddr_t	data;
IFP	fcmp;
IFP	fdup;
{
	return( avl_insert( root, data, fcmp, fdup) );
}

caddr_t avl_delete( root, data, fcmp )
Avlnode	**root;
caddr_t	data;
IFP	fcmp;
{
	return( avl_delete( root, data, fcmp ) );
}

avl_inapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_inapply( root, fn, arg, stopflag );
}

avl_postapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_postapply( root, fn, arg, stopflag );
}

avl_preapply( root, fn, arg, stopflag )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
{
return avl_preapply( root, fn, arg, stopflag );
}

/*
 * avl_apply -- avl tree root is traversed, function fn is called with
 * arguments arg and the data portion of each node.  if fn returns stopflag,
 * the traversal is cut short, otherwise it continues.  Do not use -6 as
 * a stopflag.
 */

avl_apply( root, fn, arg, stopflag, type )
Avlnode	*root;
IFP	fn;
caddr_t	arg;
int	stopflag;
int	type;
{
return avl_apply( root, fn, arg, stopflag, type );
}

avl_prefixapply( root, data, fmatch, marg, fcmp, carg, stopflag )
Avlnode	*root;
caddr_t	data;
IFP	fmatch;
caddr_t	marg;
IFP	fcmp;
caddr_t	carg;
int	stopflag;
{
return avl_prefixapply( root, data, fmatch, marg, fcmp, carg, stopflag );
}

avl_free( root, dfree )
Avlnode	*root;
IFP	dfree;
{
return avl_free( root, dfree );
}

caddr_t avl_find( root, data, fcmp )
Avlnode	*root;
caddr_t	data;
IFP	fcmp;
{
return avl_find( root, data, fcmp );
}

caddr_t avl_getfirst( root )
Avlnode	*root;
{
return avl_getfirst( root );
}

caddr_t avl_getnext()
{
return avl_getnext();
}

build_trees ()
{
return build_trees();
}

int decode_t4 (data, name, size)
char *data;
char *name;
int   size;
{
return decode_t4 (data, name, size);
}

int decode_t4_aux (inbuf, winname, length, twoDimensional)
char *inbuf;
char *winname;
int   length;
int   twoDimensional;
{
return decode_t4_aux (inbuf, winname, length, twoDimensional);
}

void as_write_files (as,where)
Attr_Sequence as;
char *where;
{
	as_write_files (as,where);
}

struct signature *
nullsigned(data, type, module)
	char           *data;
	int             type;
	modtyp         *module;
{
	return (nullsigned(data, type, module));
}


int
nullverify(data, type, module, sig, pubkey, keyparms, hashparms)
	char           *data;
	int             type;
	modtyp         *module;
	struct signature *sig;
	struct GenericPublicKey  *pubkey; 	
	struct GenericParameters *keyparms;  	
	struct GenericHashParameters *hashparms; 
{
return nullverify(data, type, module, sig, pubkey, keyparms, hashparms);
}

int
null_ckpath(data, type, module, path, sig, nameptr)
	caddr_t         data;
	int             type;
	modtyp         *module;
	struct certificate_list *path;
	struct signature *sig;
	DN             *nameptr;
{
	return (null_ckpath(data, type, module, path, sig, nameptr));
}

struct certificate_list *
null_mkpath()
{
	return null_mkpath();
}

struct encrypted *
nullencrypted(concrete, type, module, publickey, parms)
	char           *concrete;
	int             type;
	modtyp         *module;
	struct GenericPublicKey *publickey;	
	struct GenericParameters *parms;	
{
	return (nullencrypted(concrete, type, module, publickey, parms));
}


int
nulldecrypted(enc, type, module, concrete, privkey, parms)
	struct encrypted *enc;
	int             type;
	modtyp         *module;
	char          **concrete;
	struct GenericSecretKey *privkey;	 
	struct GenericParameters *parms;	
{
	return nulldecrypted(enc, type, module, concrete, privkey, parms);
}

struct Nonce *
nullmknonce(previous)
	struct Nonce *previous;
{
	return nullmknonce(previous);
}

int
nullcknonce(nonce)
	struct Nonce *nonce;
{
	return nullcknonce(nonce);
}




/* llib-lnet - lint library for QUIPU-net */

/*
 * $Header: /xtel/isode/isode/dsap/net/RCS/llib-lnet,v 9.0 1992/06/16 12:14:05 isode Rel $
 *
 *
 * $Log: llib-lnet,v $
 * Revision 9.0  1992/06/16  12:14:05  isode
 * Release 8.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/util.h"
#include "quipu/common.h"
#include "quipu/dap2.h"
#include "quipu/dsap.h"
#include "tsap.h"

/* DAP operations */

ds_bind (arg, error, result) 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
{
	return ds_bind (arg, error, result) ;
} 

secure_ds_bind (arg, error, result) 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
{
	return secure_ds_bind (arg, error, result);
} 

dap_bind (ad, arg, error, result, addr) 
int * ad; 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
struct PSAPaddr *addr; 
{
	return dap_bind (ad, arg, error, result, addr);
} 

int       DapAsynBindRequest (calledaddr, bindarg, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
struct DAPconnect       * dc;
struct DAPindication    * di;
int                       async;
{
	return (DapAsynBindRequest (calledaddr, bindarg, dc, di, async));
}

int       DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DAPconnect       * dc;
struct DAPindication    * di;
int                       async;
{
        return ( DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       DapAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DAPconnect       * dc;
struct DAPindication    * di;
{
	return (DapAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       DapBindDecode (acc, dc, rni)
struct AcSAPconnect     * acc;
struct DAPconnect       * dc;
struct RoNOTindication	* rni;
{
	return (DapBindDecode (acc, dc, rni));
}

ds_unbind () 
{
	return ds_unbind();
} 

dap_unbind (ad) 
int ad; 
{
	return dap_unbind(ad);
} 

int	  DapUnBindRequest (sd, secs, dr, di)
int			  sd;
int			  secs;
struct DAPrelease	* dr;
struct DAPindication	* di;
{
	return (DapUnBindRequest (sd, secs, dr, di));
}

int	  DapUnBindRetry (sd, secs, dr, di)
int			  sd;
int			  secs;
struct DAPrelease	* dr;
struct DAPindication	* di;
{
	return (DapUnBindRetry (sd, secs, dr, di));
}

int       DapInitWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DAPindication    * di;
{
	return (DapInitWaitRequest (sd, secs, di));
}

int       DapDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DAPindication    * di;
{
	return (DapDecodeResult (sd, ror, di));
}

int       DapDecodeError (sd, roe, di)
int                       sd;
struct RoSAPerror       * roe;
struct DAPindication    * di;
{
	return (DapDecodeError (sd, roe, di));
}

int       DapInvokeReqAux (sd, id, op, pe, di, asyn)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
int                       asyn;
{
	return (DapInvokeReqAux (sd, id, op, pe, di, asyn));
}

int       DapSyncInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapSyncInvokeRequest (sd, id, op, pe, di));
}

int       DapIntrInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapIntrInvokeRequest (sd, id, op, pe, di));
}

int       DapAsynInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapAsynInvokeRequest (sd, id, op, pe, di));
}

int       DapInterrupt(sd, id, op, di)
int                       sd;
int                       id;
int                       op;
struct DAPindication    * di;
{
	return (DapInterrupt(sd, id, op, di));
}

pdu_dump_init (dir) 
char * dir; 
{
	(void) pdu_dump_init(dir);
} 

pdu_dump (pe,type,op) 
PE pe; 
char * type; 
int op; 
{
	(void) pdu_dump(pe,type,op);
} 

pdu_arg_log (pe,op)
PE pe;
int op;
{
	return (pdu_arg_log (pe,op));
}

pdu_res_log (pe,op)
PE pe;
int op;
{
	return (pdu_arg_log (pe,op));
}

dap_abandon (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_abandon_arg *arg; 
struct DSError *error; 
{
	return dap_abandon (ad, id, arg, error);
} 

int       DapAbandon (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_abandon_arg   * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapAbandon (ad, id, arg, di, asyn));
}

dap_addentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_addentry_arg *arg; 
struct DSError *error; 
{
	return dap_addentry (ad, id, arg, error);
} 

int       DapAddEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_addentry_arg  * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapAddEntry (ad, id, arg, di, asyn));
}

dap_compare (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_compare_arg *arg; 
struct ds_compare_result *result; 
struct DSError *error; 
{
	return dap_compare (ad, id, arg, error, result);
} 

int       DapCompare (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_compare_arg   * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapCompare (ad, id, arg, di, asyn));
}

dap_list (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_list_arg *arg; 
struct ds_list_result *result; 
struct DSError *error; 
{
	return dap_list (ad, id, arg, error, result) ;
} 

int       DapList (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_list_arg      * arg;
struct DAPindication    * di;
int                       asyn;
{
	return ( DapList (ad, id, arg, di, asyn));
}

dap_modifyentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_modifyentry_arg *arg; 
struct DSError *error; 
{
	return dap_modifyentry (ad, id, arg, error) ;
} 

int       DapModifyEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_modifyentry_arg       * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapModifyEntry (ad, id, arg, di, asyn));
}

dap_modifyrdn (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_modifyrdn_arg *arg; 
struct DSError *error; 
{
	return dap_modifyrdn (ad, id, arg, error) ;
} 

int       DapModifyRDN (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_modifyrdn_arg * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapModifyRDN (ad, id, arg, di, asyn));
}

dap_read (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_read_arg *arg; 
struct ds_read_result *result; 
struct DSError *error; 
{
	return dap_read (ad, id, arg, error, result) ;
} 

int       DapRead (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_read_arg      * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapRead (ad, id, arg, di, asyn));
}

dap_removeentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_removeentry_arg *arg; 
struct DSError *error; 
{
	return dap_removeentry (ad, id, arg, error) ;
} 

int       DapRemoveEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_removeentry_arg       * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapRemoveEntry (ad, id, arg, di, asyn));
}

dap_search (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_search_arg *arg; 
struct ds_search_result *result; 
struct DSError *error; 
{
	return dap_search (ad, id, arg, error, result) ;
} 

int       DapSearch (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_search_arg    * arg;
struct DAPindication    * di;
int                       asyn;
{
	return ( DapSearch (ad, id, arg, di, asyn));
}

void ros_log(rop, event) 
register struct RoSAPpreject *rop; 
char *event; 
{
	ros_log(rop,event);
} 

void acs_log(aca, event) 
register struct AcSAPabort *aca; 
char *event; 
{
	acs_log(aca,event);
} 

td_log(td, event) 
struct TSAPdisconnect *td; 
char *event; 
{
	(void) td_log(td,event);
} 

int       DUAbortRequest (sd, di)
int                       sd;
struct DSAPindication   * di;
{
	return (DUAbortRequest (sd, di));
}

int       DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
int                       qos_maxtime;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

int       QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
int                       qos_maxtime;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

int       DspAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
{
	return (DspAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       QspAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
{
	return (QspAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       DBindDecode (acc, dc)
struct AcSAPconnect     * acc;
struct DSAPconnect      * dc;
{
	return (DBindDecode (acc, dc));
}

int       DBindInit (vecp, vec, ds, di)
int                       vecp;
char                    **vec;
struct DSAPstart        * ds;
struct DSAPindication   * di;
{
	return (DBindInit (vecp, vec, ds, di));
}

int       DBindResult (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, bind_res, pctx_id, di)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
struct ds_bind_arg      * bind_res;
int                       pctx_id;
struct DSAPindication   * di;
{
	return (DBindResult (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, bind_res, pctx_id, di));
}

int       DBindError (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bind_err, pctx_id, di)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
struct ds_bind_error    * bind_err;
int                       pctx_id;
struct DSAPindication   * di;
{
	return (DBindError (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bind_err, pctx_id, di));
}

int       DBindReject (ds, status, reason, di)
struct DSAPstart        * ds;
int                       status;
int                       reason;
struct DSAPindication   * di;
{
	return (DBindReject (ds, status, reason, di));
}

int       select_context (app_ctx)
OID                       app_ctx;
{
	return (select_context (app_ctx));
}

int       judge_ctxlist(req_ctxlist, ok_ctxlist)
struct PSAPctxlist      * req_ctxlist;
struct PSAPctxlist      * ok_ctxlist;
{
	return (judge_ctxlist(req_ctxlist, ok_ctxlist));
}

int       find_ctx_id(pcdl, ctx_oid)
struct PSAPctxlist      * pcdl;
OID                       ctx_oid;
{
	return (find_ctx_id(pcdl, ctx_oid));
}

int       check_dap_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_dap_ctxlist (ctxlist));
}

int       check_dsp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_dsp_ctxlist (ctxlist));
}

int       check_qsp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_qsp_ctxlist (ctxlist));
}

int       DapErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (DapErrorRequest (sd, id, err, di));
}

int       DspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (DspErrorRequest (sd, id, err, di));
}

int       QspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (QspErrorRequest (sd, id, err, di));
}

int             DEncodeError(pep, err)
PE              *pep;
struct DSError  *err;
{
	return (DEncodeError(pep, err));
}

int       DapInvokeRequest (sd, id, arg, di)
int                       sd;
int                       id;
struct DSArgument       * arg;
struct DSAPindication   * di;
{
	return (DapInvokeRequest (sd, id, arg, di));
}

int       DapEncodeInvoke (pep, arg)
PE                      * pep;
struct DSArgument       * arg;
{
	return (DapEncodeInvoke (pep, arg));
}

int       DspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (DspInvokeRequest (sd, id, arg, di));
}

int       DspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (DspEncodeInvoke (pep, arg));
}

int       QspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (QspInvokeRequest (sd, id, arg, di));
}

int       QspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (QspEncodeInvoke (pep, arg));
}

int     dsaplose (di, reason, what, fmt)
struct DSAPindication *di;
int     reason;
char   *what,
       *fmt;
{
    return dsaplose (di, reason, what, fmt);
}

int     dsapreject (di, reason, id, what, fmt)
struct DSAPindication *di;
int     reason;
int     id;
char   *what,
       *fmt;
{
    return dsapreject (di, reason, id, what, fmt);
}

int       DRejectRequest (sd, reason, id)
int       sd;
int       reason;
int       id;
{
	return (DRejectRequest (sd, reason, id));
}

int       DapResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct DSResult         * res;
struct DSAPindication   * di;
{
	return ( DapResultRequest (sd, id, res, di));
}

int       DapEncodeResult (pep, res)
PE              * pep;
struct DSResult * res;
{
	return (DapEncodeResult (pep, res));
}

int       DspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (DspResultRequest (sd, id, res, di));
}

int       DspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return (DspEncodeResult (pep, res));
}

int       QspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (QspResultRequest (sd, id, res, di));
}

int       QspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return ( QspEncodeResult (pep, res));
}

int       ronot2dsaplose (di, event, rni)
struct DSAPindication   * di;
char                    * event;
struct RoNOTindication  * rni;
{
	return (ronot2dsaplose (di, event, rni));
}

int       ros2dsaplose (di, event, rop)
struct DSAPindication   * di;
char                    * event;
struct RoSAPpreject     * rop;
{
	return (ros2dsaplose (di, event, rop));
}

int       ros2dsapreject (di, event, rou)
struct DSAPindication   * di;
char                    * event;
struct RoSAPureject     * rou;
{
	return (ros2dsapreject (di, event, rou));
}

int       DUnBindRequest (sd, secs, dr, di)
int                       sd;
int                       secs;
struct DSAPrelease      * dr;
struct DSAPindication   * di;
{
	return (DUnBindRequest (sd, secs, dr, di));
}

int       DUnBindRetry (sd, secs, dr, di)
int                       sd;
int                       secs;
struct DSAPrelease      * dr;
struct DSAPindication   * di;
{
	return (DUnBindRetry (sd, secs, dr, di));
}

int       DUnBindAccept (sd, di)
int                       sd;
struct DSAPindication   * di;
{
	return (DUnBindAccept (sd, di));
}

int       DUnBindReject (sd, status, reason, di)
int                       sd;
int                       status;
int                       reason;
struct DSAPindication   * di;
{
	return (DUnBindReject (sd, status, reason, di));
}

int       DWaitRequest (ctx, sd, secs, di)
int                       ctx;
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (DWaitRequest (ctx, sd, secs, di));
}

int       DapRespWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (DapRespWaitRequest (sd, secs, di));
}

int       DspWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (DspWaitRequest (sd, secs, di));
}

int       QspWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (QspWaitRequest (sd, secs, di));
}

int       DapDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return ( DapDecodeInvoke (sd, rox, di));
}

int       DDecodeUnbind (sd, acf, di)
int                       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (DDecodeUnbind (sd, acf, di));
}

int       DspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (DspDecodeInvoke (sd, rox, di));
}

int       DspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return (DspDecodeResult (sd, ror, di));
}

int       DspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (DspDecodeError (sd, roe, di));
}

int       DspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (DspDecodeUnbind (sd, acf, di));
}

int       QspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (QspDecodeInvoke (sd, rox, di));
}

int       QspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return ( QspDecodeResult (sd, ror, di));
}

int       QspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (QspDecodeError (sd, roe, di));
}

int       QspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (QspDecodeUnbind (sd, acf, di));
}

/* Some types routines */

bind_arg_free (arg)
struct ds_bind_arg          *arg;
{
	(void) bind_arg_free (arg);
}

op_arg_free (arg)
struct ds_op_arg * arg;
{
	(void) op_arg_free (arg);
}

ch_arg_free (arg)
struct chain_arg * arg;
{
	(void) ch_arg_free (arg);
}

ds_arg_free (arg)
struct DSArgument * arg;
{
	(void) ds_arg_free (arg);
}

read_arg_free (arg)
struct ds_read_arg      * arg;
{
	(void) read_arg_free (arg);
}

compare_arg_free (arg)
struct ds_compare_arg   * arg;
{
	(void) compare_arg_free (arg);
}

list_arg_free (arg)
struct ds_list_arg      * arg;
{
	(void) list_arg_free (arg);
}

search_arg_free (arg)
struct ds_search_arg    * arg;
{
	(void) search_arg_free (arg);
}

addentry_arg_free (arg)
struct ds_addentry_arg  * arg;
{
	(void) addentry_arg_free (arg);
}

removeentry_arg_free (arg)
struct ds_removeentry_arg       * arg;
{
	(void) removeentry_arg_free (arg);
}

modifyentry_arg_free (arg)
struct ds_modifyentry_arg       * arg;
{
	(void) modifyentry_arg_free (arg);
}

modifyrdn_arg_free (arg)
struct ds_modifyrdn_arg * arg;
{
	(void) modifyrdn_arg_free (arg);
}

getedb_arg_free (arg)
struct getedb_arg       * arg;
{
	(void) getedb_arg_free (arg);
}

op_res_free (res)
struct ds_op_res * res;
{
	(void) op_res_free (res);
}

ch_res_free (res)
struct chain_res        * res;
{
	(void) ch_res_free (res);
}

ds_res_free (res)
struct DSResult * res;
{
	(void) ds_res_free (res);
}

trace_info_free (ti)
struct trace_info * ti;
{
	(void) trace_info_free (ti);
}

ca_free (ca)
CommonArgs * ca;
{
	(void) ca_free (ca);
}

extension_free (ext)
struct extension * ext;
{
	(void) extension_free (ext);
}

cross_refs_free (xref)
struct cross_ref * xref;
{
	(void) cross_refs_free (xref);
}

watch_dog (where)
char * where;
{
	(void) watch_dog (where);
}

watch_dog_aux (where,secs)
char * where;
unsigned secs;
{
	(void) watch_dog_aux (where,secs);
}

watch_dog_reset ()
{
	(void) watch_dog_reset ();
}



int       IspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (IspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       IspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
int                       qos_maxtime;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (IspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

int       IspAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
{
	return (IspAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       check_isp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_isp_ctxlist (ctxlist));
}
int       IspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (IspErrorRequest (sd, id, err, di));
}

int       IspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (IspInvokeRequest (sd, id, arg, di));
}

int       IspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (IspEncodeInvoke (pep, arg));
}
int       IspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (IspResultRequest (sd, id, res, di));
}

int       IspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return ( IspEncodeResult (pep, res));
}

int       IspWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (IspWaitRequest (sd, secs, di));
}
int       IspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (IspDecodeInvoke (sd, rox, di));
}

int       IspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return ( IspDecodeResult (sd, ror, di));
}

int       IspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (IspDecodeError (sd, roe, di));
}

int       IspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (IspDecodeUnbind (sd, acf, di));
}

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

/* 
 * $Header: /xtel/isode/isode/dsap/x500as/RCS/llib-lx500as,v 9.0 1992/06/16 12:14:33 isode Rel $
 *
 *
 * $Log: llib-lx500as,v $
 * Revision 9.0  1992/06/16  12:14:33  isode
 * Release 8.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 "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;
DN     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;
DN *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 postaddr *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 postaddr **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));
}