//   NOTE: this is a machine generated file--editing not recommended
//
// rfc1213-mib2.C - class member functions for ASN.1 module RFC1213-MIB
//
//   This file was generated by snacc on Mon May 25 16:21:56 1998
//   UBC snacc written by Mike Sample
//   A couple of enhancements made by IBM European Networking Center

#include <typeinfo> 

#include "asn-incl.h"
#include "rfc1155-smi.h"
#include "rfc1157-snmp.h"
#include "rfc1213-mib2.h"

//------------------------------------------------------------------------------
// value defs

const AsnOid mib_2 (1, 3, 6, 1, 2, 1);

const AsnOid system1 (1, 3, 6, 1, 2, 1, 1);

const AsnOid interfaces (1, 3, 6, 1, 2, 1, 2);

const AsnOid at (1, 3, 6, 1, 2, 1, 3);

const AsnOid ip (1, 3, 6, 1, 2, 1, 4);

const AsnOid icmp (1, 3, 6, 1, 2, 1, 5);

const AsnOid tcp (1, 3, 6, 1, 2, 1, 6);

const AsnOid udp (1, 3, 6, 1, 2, 1, 7);

const AsnOid egp (1, 3, 6, 1, 2, 1, 8);

const AsnOid transmission (1, 3, 6, 1, 2, 1, 10);

const AsnOid snmp (1, 3, 6, 1, 2, 1, 11);

const AsnOid sysDescr (1, 3, 6, 1, 2, 1, 1, 1);

const AsnOid sysObjectID (1, 3, 6, 1, 2, 1, 1, 2);

const AsnOid sysUpTime (1, 3, 6, 1, 2, 1, 1, 3);

const AsnOid sysContact (1, 3, 6, 1, 2, 1, 1, 4);

const AsnOid sysName (1, 3, 6, 1, 2, 1, 1, 5);

const AsnOid sysLocation (1, 3, 6, 1, 2, 1, 1, 6);

const AsnOid sysServices (1, 3, 6, 1, 2, 1, 1, 7);

const AsnOid ifNumber (1, 3, 6, 1, 2, 1, 2, 1);

const AsnOid ifTable (1, 3, 6, 1, 2, 1, 2, 2);

const AsnOid ifEntry (1, 3, 6, 1, 2, 1, 2, 2, 1);

const AsnOid ifIndex (1, 3, 6, 1, 2, 1, 2, 2, 1, 1);

const AsnOid ifDescr (1, 3, 6, 1, 2, 1, 2, 2, 1, 2);

const AsnOid ifType (1, 3, 6, 1, 2, 1, 2, 2, 1, 3);

const AsnOid ifMtu (1, 3, 6, 1, 2, 1, 2, 2, 1, 4);

const AsnOid ifSpeed (1, 3, 6, 1, 2, 1, 2, 2, 1, 5);

const AsnOid ifPhysAddress (1, 3, 6, 1, 2, 1, 2, 2, 1, 6);

const AsnOid ifAdminStatus (1, 3, 6, 1, 2, 1, 2, 2, 1, 7);

const AsnOid ifOperStatus (1, 3, 6, 1, 2, 1, 2, 2, 1, 8);

const AsnOid ifLastChange (1, 3, 6, 1, 2, 1, 2, 2, 1, 9);

const AsnOid ifInOctets (1, 3, 6, 1, 2, 1, 2, 2, 1, 10);

const AsnOid ifInUcastPkts (1, 3, 6, 1, 2, 1, 2, 2, 1, 11);

const AsnOid ifInNUcastPkts (1, 3, 6, 1, 2, 1, 2, 2, 1, 12);

const AsnOid ifInDiscards (1, 3, 6, 1, 2, 1, 2, 2, 1, 13);

const AsnOid ifInErrors (1, 3, 6, 1, 2, 1, 2, 2, 1, 14);

const AsnOid ifInUnknownProtos (1, 3, 6, 1, 2, 1, 2, 2, 1, 15);

const AsnOid ifOutOctets (1, 3, 6, 1, 2, 1, 2, 2, 1, 16);

const AsnOid ifOutUcastPkts (1, 3, 6, 1, 2, 1, 2, 2, 1, 17);

const AsnOid ifOutNUcastPkts (1, 3, 6, 1, 2, 1, 2, 2, 1, 18);

const AsnOid ifOutDiscards (1, 3, 6, 1, 2, 1, 2, 2, 1, 19);

const AsnOid ifOutErrors (1, 3, 6, 1, 2, 1, 2, 2, 1, 20);

const AsnOid ifOutQLen (1, 3, 6, 1, 2, 1, 2, 2, 1, 21);

const AsnOid ifSpecific (1, 3, 6, 1, 2, 1, 2, 2, 1, 22);

const AsnOid atTable (1, 3, 6, 1, 2, 1, 3, 1);

const AsnOid atEntry (1, 3, 6, 1, 2, 1, 3, 1, 1);

const AsnOid atIfIndex (1, 3, 6, 1, 2, 1, 3, 1, 1, 1);

const AsnOid atPhysAddress (1, 3, 6, 1, 2, 1, 3, 1, 1, 2);

const AsnOid atNetAddress (1, 3, 6, 1, 2, 1, 3, 1, 1, 3);

const AsnOid ipForwarding (1, 3, 6, 1, 2, 1, 4, 1);

const AsnOid ipDefaultTTL (1, 3, 6, 1, 2, 1, 4, 2);

const AsnOid ipInReceives (1, 3, 6, 1, 2, 1, 4, 3);

const AsnOid ipInHdrErrors (1, 3, 6, 1, 2, 1, 4, 4);

const AsnOid ipInAddrErrors (1, 3, 6, 1, 2, 1, 4, 5);

const AsnOid ipForwDatagrams (1, 3, 6, 1, 2, 1, 4, 6);

const AsnOid ipInUnknownProtos (1, 3, 6, 1, 2, 1, 4, 7);

const AsnOid ipInDiscards (1, 3, 6, 1, 2, 1, 4, 8);

const AsnOid ipInDelivers (1, 3, 6, 1, 2, 1, 4, 9);

const AsnOid ipOutRequests (1, 3, 6, 1, 2, 1, 4, 10);

const AsnOid ipOutDiscards (1, 3, 6, 1, 2, 1, 4, 11);

const AsnOid ipOutNoRoutes (1, 3, 6, 1, 2, 1, 4, 12);

const AsnOid ipReasmTimeout (1, 3, 6, 1, 2, 1, 4, 13);

const AsnOid ipReasmReqds (1, 3, 6, 1, 2, 1, 4, 14);

const AsnOid ipReasmOKs (1, 3, 6, 1, 2, 1, 4, 15);

const AsnOid ipReasmFails (1, 3, 6, 1, 2, 1, 4, 16);

const AsnOid ipFragOKs (1, 3, 6, 1, 2, 1, 4, 17);

const AsnOid ipFragFails (1, 3, 6, 1, 2, 1, 4, 18);

const AsnOid ipFragCreates (1, 3, 6, 1, 2, 1, 4, 19);

const AsnOid ipAddrTable (1, 3, 6, 1, 2, 1, 4, 20);

const AsnOid ipAddrEntry (1, 3, 6, 1, 2, 1, 4, 20, 1);

const AsnOid ipAdEntAddr (1, 3, 6, 1, 2, 1, 4, 20, 1, 1);

const AsnOid ipAdEntIfIndex (1, 3, 6, 1, 2, 1, 4, 20, 1, 2);

const AsnOid ipAdEntNetMask (1, 3, 6, 1, 2, 1, 4, 20, 1, 3);

const AsnOid ipAdEntBcastAddr (1, 3, 6, 1, 2, 1, 4, 20, 1, 4);

const AsnOid ipAdEntReasmMaxSize (1, 3, 6, 1, 2, 1, 4, 20, 1, 5);

const AsnOid ipRouteTable (1, 3, 6, 1, 2, 1, 4, 21);

const AsnOid ipRouteEntry (1, 3, 6, 1, 2, 1, 4, 21, 1);

const AsnOid ipRouteDest (1, 3, 6, 1, 2, 1, 4, 21, 1, 1);

const AsnOid ipRouteIfIndex (1, 3, 6, 1, 2, 1, 4, 21, 1, 2);

const AsnOid ipRouteMetric1 (1, 3, 6, 1, 2, 1, 4, 21, 1, 3);

const AsnOid ipRouteMetric2 (1, 3, 6, 1, 2, 1, 4, 21, 1, 4);

const AsnOid ipRouteMetric3 (1, 3, 6, 1, 2, 1, 4, 21, 1, 5);

const AsnOid ipRouteMetric4 (1, 3, 6, 1, 2, 1, 4, 21, 1, 6);

const AsnOid ipRouteNextHop (1, 3, 6, 1, 2, 1, 4, 21, 1, 7);

const AsnOid ipRouteType (1, 3, 6, 1, 2, 1, 4, 21, 1, 8);

const AsnOid ipRouteProto (1, 3, 6, 1, 2, 1, 4, 21, 1, 9);

const AsnOid ipRouteAge (1, 3, 6, 1, 2, 1, 4, 21, 1, 10);

const AsnOid ipRouteMask (1, 3, 6, 1, 2, 1, 4, 21, 1, 11);

const AsnOid ipRouteMetric5 (1, 3, 6, 1, 2, 1, 4, 21, 1, 12);

const AsnOid ipRouteInfo (1, 3, 6, 1, 2, 1, 4, 21, 1, 13);

const AsnOid ipNetToMediaTable (1, 3, 6, 1, 2, 1, 4, 22);

const AsnOid ipNetToMediaEntry (1, 3, 6, 1, 2, 1, 4, 22, 1);

const AsnOid ipNetToMediaIfIndex (1, 3, 6, 1, 2, 1, 4, 22, 1, 1);

const AsnOid ipNetToMediaPhysAddress (1, 3, 6, 1, 2, 1, 4, 22, 1, 2);

const AsnOid ipNetToMediaNetAddress (1, 3, 6, 1, 2, 1, 4, 22, 1, 3);

const AsnOid ipNetToMediaType (1, 3, 6, 1, 2, 1, 4, 22, 1, 4);

const AsnOid ipRoutingDiscards (1, 3, 6, 1, 2, 1, 4, 23);

const AsnOid icmpInMsgs (1, 3, 6, 1, 2, 1, 5, 1);

const AsnOid icmpInErrors (1, 3, 6, 1, 2, 1, 5, 2);

const AsnOid icmpInDestUnreachs (1, 3, 6, 1, 2, 1, 5, 3);

const AsnOid icmpInTimeExcds (1, 3, 6, 1, 2, 1, 5, 4);

const AsnOid icmpInParmProbs (1, 3, 6, 1, 2, 1, 5, 5);

const AsnOid icmpInSrcQuenchs (1, 3, 6, 1, 2, 1, 5, 6);

const AsnOid icmpInRedirects (1, 3, 6, 1, 2, 1, 5, 7);

const AsnOid icmpInEchos (1, 3, 6, 1, 2, 1, 5, 8);

const AsnOid icmpInEchoReps (1, 3, 6, 1, 2, 1, 5, 9);

const AsnOid icmpInTimestamps (1, 3, 6, 1, 2, 1, 5, 10);

const AsnOid icmpInTimestampReps (1, 3, 6, 1, 2, 1, 5, 11);

const AsnOid icmpInAddrMasks (1, 3, 6, 1, 2, 1, 5, 12);

const AsnOid icmpInAddrMaskReps (1, 3, 6, 1, 2, 1, 5, 13);

const AsnOid icmpOutMsgs (1, 3, 6, 1, 2, 1, 5, 14);

const AsnOid icmpOutErrors (1, 3, 6, 1, 2, 1, 5, 15);

const AsnOid icmpOutDestUnreachs (1, 3, 6, 1, 2, 1, 5, 16);

const AsnOid icmpOutTimeExcds (1, 3, 6, 1, 2, 1, 5, 17);

const AsnOid icmpOutParmProbs (1, 3, 6, 1, 2, 1, 5, 18);

const AsnOid icmpOutSrcQuenchs (1, 3, 6, 1, 2, 1, 5, 19);

const AsnOid icmpOutRedirects (1, 3, 6, 1, 2, 1, 5, 20);

const AsnOid icmpOutEchos (1, 3, 6, 1, 2, 1, 5, 21);

const AsnOid icmpOutEchoReps (1, 3, 6, 1, 2, 1, 5, 22);

const AsnOid icmpOutTimestamps (1, 3, 6, 1, 2, 1, 5, 23);

const AsnOid icmpOutTimestampReps (1, 3, 6, 1, 2, 1, 5, 24);

const AsnOid icmpOutAddrMasks (1, 3, 6, 1, 2, 1, 5, 25);

const AsnOid icmpOutAddrMaskReps (1, 3, 6, 1, 2, 1, 5, 26);

const AsnOid tcpRtoAlgorithm (1, 3, 6, 1, 2, 1, 6, 1);

const AsnOid tcpRtoMin (1, 3, 6, 1, 2, 1, 6, 2);

const AsnOid tcpRtoMax (1, 3, 6, 1, 2, 1, 6, 3);

const AsnOid tcpMaxConn (1, 3, 6, 1, 2, 1, 6, 4);

const AsnOid tcpActiveOpens (1, 3, 6, 1, 2, 1, 6, 5);

const AsnOid tcpPassiveOpens (1, 3, 6, 1, 2, 1, 6, 6);

const AsnOid tcpAttemptFails (1, 3, 6, 1, 2, 1, 6, 7);

const AsnOid tcpEstabResets (1, 3, 6, 1, 2, 1, 6, 8);

const AsnOid tcpCurrEstab (1, 3, 6, 1, 2, 1, 6, 9);

const AsnOid tcpInSegs (1, 3, 6, 1, 2, 1, 6, 10);

const AsnOid tcpOutSegs (1, 3, 6, 1, 2, 1, 6, 11);

const AsnOid tcpRetransSegs (1, 3, 6, 1, 2, 1, 6, 12);

const AsnOid tcpConnTable (1, 3, 6, 1, 2, 1, 6, 13);

const AsnOid tcpConnEntry (1, 3, 6, 1, 2, 1, 6, 13, 1);

const AsnOid tcpConnState (1, 3, 6, 1, 2, 1, 6, 13, 1, 1);

const AsnOid tcpConnLocalAddress (1, 3, 6, 1, 2, 1, 6, 13, 1, 2);

const AsnOid tcpConnLocalPort (1, 3, 6, 1, 2, 1, 6, 13, 1, 3);

const AsnOid tcpConnRemAddress (1, 3, 6, 1, 2, 1, 6, 13, 1, 4);

const AsnOid tcpConnRemPort (1, 3, 6, 1, 2, 1, 6, 13, 1, 5);

const AsnOid tcpInErrs (1, 3, 6, 1, 2, 1, 6, 14);

const AsnOid tcpOutRsts (1, 3, 6, 1, 2, 1, 6, 15);

const AsnOid udpInDatagrams (1, 3, 6, 1, 2, 1, 7, 1);

const AsnOid udpNoPorts (1, 3, 6, 1, 2, 1, 7, 2);

const AsnOid udpInErrors (1, 3, 6, 1, 2, 1, 7, 3);

const AsnOid udpOutDatagrams (1, 3, 6, 1, 2, 1, 7, 4);

const AsnOid udpTable (1, 3, 6, 1, 2, 1, 7, 5);

const AsnOid udpEntry (1, 3, 6, 1, 2, 1, 7, 5, 1);

const AsnOid udpLocalAddress (1, 3, 6, 1, 2, 1, 7, 5, 1, 1);

const AsnOid udpLocalPort (1, 3, 6, 1, 2, 1, 7, 5, 1, 2);

const AsnOid egpInMsgs (1, 3, 6, 1, 2, 1, 8, 1);

const AsnOid egpInErrors (1, 3, 6, 1, 2, 1, 8, 2);

const AsnOid egpOutMsgs (1, 3, 6, 1, 2, 1, 8, 3);

const AsnOid egpOutErrors (1, 3, 6, 1, 2, 1, 8, 4);

const AsnOid egpNeighTable (1, 3, 6, 1, 2, 1, 8, 5);

const AsnOid egpNeighEntry (1, 3, 6, 1, 2, 1, 8, 5, 1);

const AsnOid egpNeighState (1, 3, 6, 1, 2, 1, 8, 5, 1, 1);

const AsnOid egpNeighAddr (1, 3, 6, 1, 2, 1, 8, 5, 1, 2);

const AsnOid egpNeighAs (1, 3, 6, 1, 2, 1, 8, 5, 1, 3);

const AsnOid egpNeighInMsgs (1, 3, 6, 1, 2, 1, 8, 5, 1, 4);

const AsnOid egpNeighInErrs (1, 3, 6, 1, 2, 1, 8, 5, 1, 5);

const AsnOid egpNeighOutMsgs (1, 3, 6, 1, 2, 1, 8, 5, 1, 6);

const AsnOid egpNeighOutErrs (1, 3, 6, 1, 2, 1, 8, 5, 1, 7);

const AsnOid egpNeighInErrMsgs (1, 3, 6, 1, 2, 1, 8, 5, 1, 8);

const AsnOid egpNeighOutErrMsgs (1, 3, 6, 1, 2, 1, 8, 5, 1, 9);

const AsnOid egpNeighStateUps (1, 3, 6, 1, 2, 1, 8, 5, 1, 10);

const AsnOid egpNeighStateDowns (1, 3, 6, 1, 2, 1, 8, 5, 1, 11);

const AsnOid egpNeighIntervalHello (1, 3, 6, 1, 2, 1, 8, 5, 1, 12);

const AsnOid egpNeighIntervalPoll (1, 3, 6, 1, 2, 1, 8, 5, 1, 13);

const AsnOid egpNeighMode (1, 3, 6, 1, 2, 1, 8, 5, 1, 14);

const AsnOid egpNeighEventTrigger (1, 3, 6, 1, 2, 1, 8, 5, 1, 15);

const AsnOid egpAs (1, 3, 6, 1, 2, 1, 8, 6);

const AsnOid snmpInPkts (1, 3, 6, 1, 2, 1, 11, 1);

const AsnOid snmpOutPkts (1, 3, 6, 1, 2, 1, 11, 2);

const AsnOid snmpInBadVersions (1, 3, 6, 1, 2, 1, 11, 3);

const AsnOid snmpInBadCommunityNames (1, 3, 6, 1, 2, 1, 11, 4);

const AsnOid snmpInBadCommunityUses (1, 3, 6, 1, 2, 1, 11, 5);

const AsnOid snmpInASNParseErrs (1, 3, 6, 1, 2, 1, 11, 6);

const AsnOid snmpInTooBigs (1, 3, 6, 1, 2, 1, 11, 8);

const AsnOid snmpInNoSuchNames (1, 3, 6, 1, 2, 1, 11, 9);

const AsnOid snmpInBadValues (1, 3, 6, 1, 2, 1, 11, 10);

const AsnOid snmpInReadOnlys (1, 3, 6, 1, 2, 1, 11, 11);

const AsnOid snmpInGenErrs (1, 3, 6, 1, 2, 1, 11, 12);

const AsnOid snmpInTotalReqVars (1, 3, 6, 1, 2, 1, 11, 13);

const AsnOid snmpInTotalSetVars (1, 3, 6, 1, 2, 1, 11, 14);

const AsnOid snmpInGetRequests (1, 3, 6, 1, 2, 1, 11, 15);

const AsnOid snmpInGetNexts (1, 3, 6, 1, 2, 1, 11, 16);

const AsnOid snmpInSetRequests (1, 3, 6, 1, 2, 1, 11, 17);

const AsnOid snmpInGetResponses (1, 3, 6, 1, 2, 1, 11, 18);

const AsnOid snmpInTraps (1, 3, 6, 1, 2, 1, 11, 19);

const AsnOid snmpOutTooBigs (1, 3, 6, 1, 2, 1, 11, 20);

const AsnOid snmpOutNoSuchNames (1, 3, 6, 1, 2, 1, 11, 21);

const AsnOid snmpOutBadValues (1, 3, 6, 1, 2, 1, 11, 22);

const AsnOid snmpOutGenErrs (1, 3, 6, 1, 2, 1, 11, 24);

const AsnOid snmpOutGetRequests (1, 3, 6, 1, 2, 1, 11, 25);

const AsnOid snmpOutGetNexts (1, 3, 6, 1, 2, 1, 11, 26);

const AsnOid snmpOutSetRequests (1, 3, 6, 1, 2, 1, 11, 27);

const AsnOid snmpOutGetResponses (1, 3, 6, 1, 2, 1, 11, 28);

const AsnOid snmpOutTraps (1, 3, 6, 1, 2, 1, 11, 29);

const AsnOid snmpEnableAuthenTraps (1, 3, 6, 1, 2, 1, 11, 30);


//------------------------------------------------------------------------------
// class member definitions:

// this class will automatically intialize the any hash tbl
class InitAny
{
  public:
    InitAny();
};

static InitAny anyInitalizer;
InitAny::InitAny()
{
    AsnOid oid0(1, 3, 6, 1, 2, 1, 1, 7);
    AsnOid oid1(1, 3, 6, 1, 2, 1, 2, 1);
    AsnOid oid2(1, 3, 6, 1, 2, 1, 2, 2, 1, 1);
    AsnOid oid3(1, 3, 6, 1, 2, 1, 2, 2, 1, 4);
    AsnOid oid4(1, 3, 6, 1, 2, 1, 3, 1, 1, 1);
    AsnOid oid5(1, 3, 6, 1, 2, 1, 4, 2);
    AsnOid oid6(1, 3, 6, 1, 2, 1, 4, 13);
    AsnOid oid7(1, 3, 6, 1, 2, 1, 4, 20, 1, 2);
    AsnOid oid8(1, 3, 6, 1, 2, 1, 4, 20, 1, 4);
    AsnOid oid9(1, 3, 6, 1, 2, 1, 4, 20, 1, 5);
    AsnOid oid10(1, 3, 6, 1, 2, 1, 4, 21, 1, 2);
    AsnOid oid11(1, 3, 6, 1, 2, 1, 4, 21, 1, 3);
    AsnOid oid12(1, 3, 6, 1, 2, 1, 4, 21, 1, 4);
    AsnOid oid13(1, 3, 6, 1, 2, 1, 4, 21, 1, 5);
    AsnOid oid14(1, 3, 6, 1, 2, 1, 4, 21, 1, 6);
    AsnOid oid15(1, 3, 6, 1, 2, 1, 4, 21, 1, 10);
    AsnOid oid16(1, 3, 6, 1, 2, 1, 4, 21, 1, 12);
    AsnOid oid17(1, 3, 6, 1, 2, 1, 4, 22, 1, 1);
    AsnOid oid18(1, 3, 6, 1, 2, 1, 6, 2);
    AsnOid oid19(1, 3, 6, 1, 2, 1, 6, 3);
    AsnOid oid20(1, 3, 6, 1, 2, 1, 6, 4);
    AsnOid oid21(1, 3, 6, 1, 2, 1, 6, 13, 1, 3);
    AsnOid oid22(1, 3, 6, 1, 2, 1, 6, 13, 1, 5);
    AsnOid oid23(1, 3, 6, 1, 2, 1, 7, 5, 1, 2);
    AsnOid oid24(1, 3, 6, 1, 2, 1, 8, 5, 1, 3);
    AsnOid oid25(1, 3, 6, 1, 2, 1, 8, 5, 1, 12);
    AsnOid oid26(1, 3, 6, 1, 2, 1, 8, 5, 1, 13);
    AsnOid oid27(1, 3, 6, 1, 2, 1, 8, 6);
    AsnOid oid28(1, 3, 6, 1, 2, 1, 1, 2);
    AsnOid oid29(1, 3, 6, 1, 2, 1, 2, 2, 1, 22);
    AsnOid oid30(1, 3, 6, 1, 2, 1, 4, 21, 1, 13);
    AsnOid oid31(1, 3, 6, 1, 2, 1, 11, 30);
    AsnOid oid32(1, 3, 6, 1, 2, 1, 8, 5, 1, 15);
    AsnOid oid33(1, 3, 6, 1, 2, 1, 8, 5, 1, 14);
    AsnOid oid34(1, 3, 6, 1, 2, 1, 8, 5, 1, 1);
    AsnOid oid35(1, 3, 6, 1, 2, 1, 6, 13, 1, 1);
    AsnOid oid36(1, 3, 6, 1, 2, 1, 6, 1);
    AsnOid oid37(1, 3, 6, 1, 2, 1, 4, 22, 1, 4);
    AsnOid oid38(1, 3, 6, 1, 2, 1, 4, 21, 1, 9);
    AsnOid oid39(1, 3, 6, 1, 2, 1, 4, 21, 1, 8);
    AsnOid oid40(1, 3, 6, 1, 2, 1, 4, 1);
    AsnOid oid41(1, 3, 6, 1, 2, 1, 2, 2, 1, 8);
    AsnOid oid42(1, 3, 6, 1, 2, 1, 2, 2, 1, 7);
    AsnOid oid43(1, 3, 6, 1, 2, 1, 2, 2, 1, 3);
    AsnOid oid44(1, 3, 6, 1, 2, 1, 1, 1);
    AsnOid oid45(1, 3, 6, 1, 2, 1, 1, 4);
    AsnOid oid46(1, 3, 6, 1, 2, 1, 1, 5);
    AsnOid oid47(1, 3, 6, 1, 2, 1, 1, 6);
    AsnOid oid48(1, 3, 6, 1, 2, 1, 2, 2, 1, 2);
    AsnOid oid49(1, 3, 6, 1, 2, 1, 2, 2, 1, 6);
    AsnOid oid50(1, 3, 6, 1, 2, 1, 3, 1, 1, 2);
    AsnOid oid51(1, 3, 6, 1, 2, 1, 4, 22, 1, 2);
    AsnOid oid52(1, 3, 6, 1, 2, 1, 4, 20, 1);
    AsnOid oid53(1, 3, 6, 1, 2, 1, 4, 21, 1);
    AsnOid oid54(1, 3, 6, 1, 2, 1, 6, 13, 1);
    AsnOid oid55(1, 3, 6, 1, 2, 1, 7, 5, 1);
    AsnOid oid56(1, 3, 6, 1, 2, 1, 8, 5, 1);
    AsnOid oid57(1, 3, 6, 1, 2, 1, 2, 2, 1);
    AsnOid oid58(1, 3, 6, 1, 2, 1, 3, 1, 1);
    AsnOid oid59(1, 3, 6, 1, 2, 1, 4, 22, 1);
    AsnOid oid60(1, 3, 6, 1, 2, 1, 8, 5);
    AsnOid oid61(1, 3, 6, 1, 2, 1, 7, 5);
    AsnOid oid62(1, 3, 6, 1, 2, 1, 6, 13);
    AsnOid oid63(1, 3, 6, 1, 2, 1, 4, 22);
    AsnOid oid64(1, 3, 6, 1, 2, 1, 4, 21);
    AsnOid oid65(1, 3, 6, 1, 2, 1, 4, 20);
    AsnOid oid66(1, 3, 6, 1, 2, 1, 3, 1);
    AsnOid oid67(1, 3, 6, 1, 2, 1, 2, 2);
    AsnAny::InstallAnyByOid (oid0, sysServices_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid1, ifNumber_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid2, ifIndex_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid3, ifMtu_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid4, atIfIndex_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid5, ipDefaultTTL_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid6, ipReasmTimeout_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid7, ipAdEntIfIndex_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid8, ipAdEntBcastAddr_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid9, ipAdEntReasmMaxSize_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid10, ipRouteIfIndex_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid11, ipRouteMetric1_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid12, ipRouteMetric2_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid13, ipRouteMetric3_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid14, ipRouteMetric4_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid15, ipRouteAge_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid16, ipRouteMetric5_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid17, ipNetToMediaIfIndex_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid18, tcpRtoMin_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid19, tcpRtoMax_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid20, tcpMaxConn_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid21, tcpConnLocalPort_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid22, tcpConnRemPort_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid23, udpLocalPort_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid24, egpNeighAs_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid25, egpNeighIntervalHello_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid26, egpNeighIntervalPoll_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid27, egpAs_ANY_ID, new AsnInt);
    AsnAny::InstallAnyByOid (oid28, sysObjectID_ANY_ID, new AsnOid);
    AsnAny::InstallAnyByOid (oid29, ifSpecific_ANY_ID, new AsnOid);
    AsnAny::InstallAnyByOid (oid30, ipRouteInfo_ANY_ID, new AsnOid);
    AsnAny::InstallAnyByOid (oid31, snmpEnableAuthenTraps_ANY_ID, new SnmpEnableAuthenTraps);
    AsnAny::InstallAnyByOid (oid32, egpNeighEventTrigger_ANY_ID, new EgpNeighEventTrigger);
    AsnAny::InstallAnyByOid (oid33, egpNeighMode_ANY_ID, new EgpNeighMode);
    AsnAny::InstallAnyByOid (oid34, egpNeighState_ANY_ID, new EgpNeighState);
    AsnAny::InstallAnyByOid (oid35, tcpConnState_ANY_ID, new TcpConnState);
    AsnAny::InstallAnyByOid (oid36, tcpRtoAlgorithm_ANY_ID, new TcpRtoAlgorithm);
    AsnAny::InstallAnyByOid (oid37, ipNetToMediaType_ANY_ID, new IpNetToMediaType);
    AsnAny::InstallAnyByOid (oid38, ipRouteProto_ANY_ID, new IpRouteProto);
    AsnAny::InstallAnyByOid (oid39, ipRouteType_ANY_ID, new IpRouteType);
    AsnAny::InstallAnyByOid (oid40, ipForwarding_ANY_ID, new IpForwarding);
    AsnAny::InstallAnyByOid (oid41, ifOperStatus_ANY_ID, new IfOperStatus);
    AsnAny::InstallAnyByOid (oid42, ifAdminStatus_ANY_ID, new IfAdminStatus);
    AsnAny::InstallAnyByOid (oid43, ifType_ANY_ID, new IfType);
    AsnAny::InstallAnyByOid (oid44, sysDescr_ANY_ID, new DisplayString);
    AsnAny::InstallAnyByOid (oid45, sysContact_ANY_ID, new DisplayString);
    AsnAny::InstallAnyByOid (oid46, sysName_ANY_ID, new DisplayString);
    AsnAny::InstallAnyByOid (oid47, sysLocation_ANY_ID, new DisplayString);
    AsnAny::InstallAnyByOid (oid48, ifDescr_ANY_ID, new DisplayString);
    AsnAny::InstallAnyByOid (oid49, ifPhysAddress_ANY_ID, new PhysAddress);
    AsnAny::InstallAnyByOid (oid50, atPhysAddress_ANY_ID, new PhysAddress);
    AsnAny::InstallAnyByOid (oid51, ipNetToMediaPhysAddress_ANY_ID, new PhysAddress);
    AsnAny::InstallAnyByOid (oid52, ipAddrEntry_ANY_ID, new IpAddrEntry);
    AsnAny::InstallAnyByOid (oid53, ipRouteEntry_ANY_ID, new IpRouteEntry);
    AsnAny::InstallAnyByOid (oid54, tcpConnEntry_ANY_ID, new TcpConnEntry);
    AsnAny::InstallAnyByOid (oid55, udpEntry_ANY_ID, new UdpEntry);
    AsnAny::InstallAnyByOid (oid56, egpNeighEntry_ANY_ID, new EgpNeighEntry);
    AsnAny::InstallAnyByOid (oid57, ifEntry_ANY_ID, new IfEntry);
    AsnAny::InstallAnyByOid (oid58, atEntry_ANY_ID, new AtEntry);
    AsnAny::InstallAnyByOid (oid59, ipNetToMediaEntry_ANY_ID, new IpNetToMediaEntry);
    AsnAny::InstallAnyByOid (oid60, egpNeighTable_ANY_ID, new EgpNeighTable);
    AsnAny::InstallAnyByOid (oid61, udpTable_ANY_ID, new UdpTable);
    AsnAny::InstallAnyByOid (oid62, tcpConnTable_ANY_ID, new TcpConnTable);
    AsnAny::InstallAnyByOid (oid63, ipNetToMediaTable_ANY_ID, new IpNetToMediaTable);
    AsnAny::InstallAnyByOid (oid64, ipRouteTable_ANY_ID, new IpRouteTable);
    AsnAny::InstallAnyByOid (oid65, ipAddrTable_ANY_ID, new IpAddrTable);
    AsnAny::InstallAnyByOid (oid66, atTable_ANY_ID, new AtTable);
    AsnAny::InstallAnyByOid (oid67, ifTable_ANY_ID, new IfTable);
}  /* InitAny::InitAny */


IpAddrEntry::IpAddrEntry()
{
}

IpAddrEntry::IpAddrEntry (const IpAddrEntry &)
{
  Asn1Error << "use of incompletely defined IpAddrEntry::IpAddrEntry (const IpAddrEntry &)" << endl;
  abort();
}

IpAddrEntry::~IpAddrEntry()
{
}

AsnType *IpAddrEntry::Clone() const
{
  return new IpAddrEntry;
}

#if SNACC_DEEP_COPY
IpAddrEntry &IpAddrEntry::operator = (const IpAddrEntry &that)
#else // SNACC_DEEP_COPY
IpAddrEntry &IpAddrEntry::operator = (const IpAddrEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    ipAdEntAddr = that.ipAdEntAddr;
    ipAdEntIfIndex = that.ipAdEntIfIndex;
    ipAdEntNetMask = that.ipAdEntNetMask;
    ipAdEntBcastAddr = that.ipAdEntBcastAddr;
    ipAdEntReasmMaxSize = that.ipAdEntReasmMaxSize;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpAddrEntry &IpAddrEntry::operator = (const IpAddrEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
IpAddrEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = ipAdEntReasmMaxSize.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipAdEntBcastAddr.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipAdEntNetMask.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = ipAdEntIfIndex.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipAdEntAddr.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

  return totalLen;
} // IpAddrEntry::BEncContent


void IpAddrEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipAdEntAddr.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -100);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipAdEntIfIndex.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -101);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipAdEntNetMask.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -102);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipAdEntBcastAddr.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -103);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipAdEntReasmMaxSize.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -104);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -105);
  }
  else
    return;
} // IpAddrEntry::BDecContent

AsnLen IpAddrEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpAddrEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpAddrEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -106);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int IpAddrEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int IpAddrEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void IpAddrEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "ipAdEntAddr ";
    os << ipAdEntAddr;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipAdEntIfIndex ";
    os << ipAdEntIfIndex;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipAdEntNetMask ";
    os << ipAdEntNetMask;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipAdEntBcastAddr ";
    os << ipAdEntBcastAddr;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipAdEntReasmMaxSize ";
    os << ipAdEntReasmMaxSize;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // IpAddrEntry::Print


IpRouteEntry::IpRouteEntry()
{
}

IpRouteEntry::IpRouteEntry (const IpRouteEntry &)
{
  Asn1Error << "use of incompletely defined IpRouteEntry::IpRouteEntry (const IpRouteEntry &)" << endl;
  abort();
}

IpRouteEntry::~IpRouteEntry()
{
}

AsnType *IpRouteEntry::Clone() const
{
  return new IpRouteEntry;
}

#if SNACC_DEEP_COPY
IpRouteEntry &IpRouteEntry::operator = (const IpRouteEntry &that)
#else // SNACC_DEEP_COPY
IpRouteEntry &IpRouteEntry::operator = (const IpRouteEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    ipRouteDest = that.ipRouteDest;
    ipRouteIfIndex = that.ipRouteIfIndex;
    ipRouteMetric1 = that.ipRouteMetric1;
    ipRouteMetric2 = that.ipRouteMetric2;
    ipRouteMetric3 = that.ipRouteMetric3;
    ipRouteMetric4 = that.ipRouteMetric4;
    ipRouteNextHop = that.ipRouteNextHop;
    ipRouteType = that.ipRouteType;
    ipRouteProto = that.ipRouteProto;
    ipRouteAge = that.ipRouteAge;
    ipRouteMask = that.ipRouteMask;
    ipRouteMetric5 = that.ipRouteMetric5;
    ipRouteInfo = that.ipRouteInfo;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpRouteEntry &IpRouteEntry::operator = (const IpRouteEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
IpRouteEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = ipRouteInfo.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OID_TAG_CODE);
    totalLen += l;

    l = ipRouteMetric5.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteMask.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = ipRouteAge.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteProto.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteType.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteNextHop.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = ipRouteMetric4.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteMetric3.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteMetric2.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteMetric1.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteIfIndex.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipRouteDest.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

  return totalLen;
} // IpRouteEntry::BEncContent


void IpRouteEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteDest.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -107);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteIfIndex.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -108);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMetric1.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -109);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMetric2.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -110);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMetric3.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -111);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMetric4.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -112);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteNextHop.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -113);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteType.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -114);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteProto.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -115);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteAge.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -116);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMask.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -117);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteMetric5.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -118);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OID_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipRouteInfo.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -119);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -120);
  }
  else
    return;
} // IpRouteEntry::BDecContent

AsnLen IpRouteEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpRouteEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpRouteEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -121);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int IpRouteEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int IpRouteEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void IpRouteEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "ipRouteDest ";
    os << ipRouteDest;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteIfIndex ";
    os << ipRouteIfIndex;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMetric1 ";
    os << ipRouteMetric1;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMetric2 ";
    os << ipRouteMetric2;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMetric3 ";
    os << ipRouteMetric3;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMetric4 ";
    os << ipRouteMetric4;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteNextHop ";
    os << ipRouteNextHop;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteType ";
    os << ipRouteType;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteProto ";
    os << ipRouteProto;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteAge ";
    os << ipRouteAge;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMask ";
    os << ipRouteMask;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteMetric5 ";
    os << ipRouteMetric5;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipRouteInfo ";
    os << ipRouteInfo;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // IpRouteEntry::Print


TcpConnEntry::TcpConnEntry()
{
}

TcpConnEntry::TcpConnEntry (const TcpConnEntry &)
{
  Asn1Error << "use of incompletely defined TcpConnEntry::TcpConnEntry (const TcpConnEntry &)" << endl;
  abort();
}

TcpConnEntry::~TcpConnEntry()
{
}

AsnType *TcpConnEntry::Clone() const
{
  return new TcpConnEntry;
}

#if SNACC_DEEP_COPY
TcpConnEntry &TcpConnEntry::operator = (const TcpConnEntry &that)
#else // SNACC_DEEP_COPY
TcpConnEntry &TcpConnEntry::operator = (const TcpConnEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    tcpConnState = that.tcpConnState;
    tcpConnLocalAddress = that.tcpConnLocalAddress;
    tcpConnLocalPort = that.tcpConnLocalPort;
    tcpConnRemAddress = that.tcpConnRemAddress;
    tcpConnRemPort = that.tcpConnRemPort;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined TcpConnEntry &TcpConnEntry::operator = (const TcpConnEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
TcpConnEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = tcpConnRemPort.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = tcpConnRemAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = tcpConnLocalPort.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = tcpConnLocalAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = tcpConnState.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // TcpConnEntry::BEncContent


void TcpConnEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    tcpConnState.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -122);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    tcpConnLocalAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -123);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    tcpConnLocalPort.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -124);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    tcpConnRemAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -125);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    tcpConnRemPort.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -126);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -127);
  }
  else
    return;
} // TcpConnEntry::BDecContent

AsnLen TcpConnEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void TcpConnEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "TcpConnEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -128);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int TcpConnEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int TcpConnEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void TcpConnEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "tcpConnState ";
    os << tcpConnState;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "tcpConnLocalAddress ";
    os << tcpConnLocalAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "tcpConnLocalPort ";
    os << tcpConnLocalPort;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "tcpConnRemAddress ";
    os << tcpConnRemAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "tcpConnRemPort ";
    os << tcpConnRemPort;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // TcpConnEntry::Print


UdpEntry::UdpEntry()
{
}

UdpEntry::UdpEntry (const UdpEntry &)
{
  Asn1Error << "use of incompletely defined UdpEntry::UdpEntry (const UdpEntry &)" << endl;
  abort();
}

UdpEntry::~UdpEntry()
{
}

AsnType *UdpEntry::Clone() const
{
  return new UdpEntry;
}

#if SNACC_DEEP_COPY
UdpEntry &UdpEntry::operator = (const UdpEntry &that)
#else // SNACC_DEEP_COPY
UdpEntry &UdpEntry::operator = (const UdpEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    udpLocalAddress = that.udpLocalAddress;
    udpLocalPort = that.udpLocalPort;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined UdpEntry &UdpEntry::operator = (const UdpEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
UdpEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = udpLocalPort.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = udpLocalAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

  return totalLen;
} // UdpEntry::BEncContent


void UdpEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    udpLocalAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -129);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    udpLocalPort.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -130);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -131);
  }
  else
    return;
} // UdpEntry::BDecContent

AsnLen UdpEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void UdpEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "UdpEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -132);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int UdpEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int UdpEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void UdpEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "udpLocalAddress ";
    os << udpLocalAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "udpLocalPort ";
    os << udpLocalPort;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // UdpEntry::Print


EgpNeighEntry::EgpNeighEntry()
{
}

EgpNeighEntry::EgpNeighEntry (const EgpNeighEntry &)
{
  Asn1Error << "use of incompletely defined EgpNeighEntry::EgpNeighEntry (const EgpNeighEntry &)" << endl;
  abort();
}

EgpNeighEntry::~EgpNeighEntry()
{
}

AsnType *EgpNeighEntry::Clone() const
{
  return new EgpNeighEntry;
}

#if SNACC_DEEP_COPY
EgpNeighEntry &EgpNeighEntry::operator = (const EgpNeighEntry &that)
#else // SNACC_DEEP_COPY
EgpNeighEntry &EgpNeighEntry::operator = (const EgpNeighEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    egpNeighState = that.egpNeighState;
    egpNeighAddr = that.egpNeighAddr;
    egpNeighAs = that.egpNeighAs;
    egpNeighInMsgs = that.egpNeighInMsgs;
    egpNeighInErrs = that.egpNeighInErrs;
    egpNeighOutMsgs = that.egpNeighOutMsgs;
    egpNeighOutErrs = that.egpNeighOutErrs;
    egpNeighInErrMsgs = that.egpNeighInErrMsgs;
    egpNeighOutErrMsgs = that.egpNeighOutErrMsgs;
    egpNeighStateUps = that.egpNeighStateUps;
    egpNeighStateDowns = that.egpNeighStateDowns;
    egpNeighIntervalHello = that.egpNeighIntervalHello;
    egpNeighIntervalPoll = that.egpNeighIntervalPoll;
    egpNeighMode = that.egpNeighMode;
    egpNeighEventTrigger = that.egpNeighEventTrigger;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined EgpNeighEntry &EgpNeighEntry::operator = (const EgpNeighEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
EgpNeighEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = egpNeighEventTrigger.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = egpNeighMode.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = egpNeighIntervalPoll.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = egpNeighIntervalHello.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = egpNeighStateDowns.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighStateUps.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighOutErrMsgs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighInErrMsgs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighOutErrs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighOutMsgs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighInErrs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighInMsgs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = egpNeighAs.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = egpNeighAddr.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = egpNeighState.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // EgpNeighEntry::BEncContent


void EgpNeighEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighState.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -133);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighAddr.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -134);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighAs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -135);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighInMsgs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -136);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighInErrs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -137);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighOutMsgs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -138);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighOutErrs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -139);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighInErrMsgs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -140);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighOutErrMsgs.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -141);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighStateUps.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -142);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighStateDowns.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -143);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighIntervalHello.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -144);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighIntervalPoll.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -145);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighMode.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -146);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    egpNeighEventTrigger.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -147);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -148);
  }
  else
    return;
} // EgpNeighEntry::BDecContent

AsnLen EgpNeighEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void EgpNeighEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "EgpNeighEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -149);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int EgpNeighEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int EgpNeighEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void EgpNeighEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "egpNeighState ";
    os << egpNeighState;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighAddr ";
    os << egpNeighAddr;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighAs ";
    os << egpNeighAs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighInMsgs ";
    os << egpNeighInMsgs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighInErrs ";
    os << egpNeighInErrs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighOutMsgs ";
    os << egpNeighOutMsgs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighOutErrs ";
    os << egpNeighOutErrs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighInErrMsgs ";
    os << egpNeighInErrMsgs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighOutErrMsgs ";
    os << egpNeighOutErrMsgs;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighStateUps ";
    os << egpNeighStateUps;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighStateDowns ";
    os << egpNeighStateDowns;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighIntervalHello ";
    os << egpNeighIntervalHello;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighIntervalPoll ";
    os << egpNeighIntervalPoll;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighMode ";
    os << egpNeighMode;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "egpNeighEventTrigger ";
    os << egpNeighEventTrigger;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // EgpNeighEntry::Print


IfEntry::IfEntry()
{
}

IfEntry::IfEntry (const IfEntry &)
{
  Asn1Error << "use of incompletely defined IfEntry::IfEntry (const IfEntry &)" << endl;
  abort();
}

IfEntry::~IfEntry()
{
}

AsnType *IfEntry::Clone() const
{
  return new IfEntry;
}

#if SNACC_DEEP_COPY
IfEntry &IfEntry::operator = (const IfEntry &that)
#else // SNACC_DEEP_COPY
IfEntry &IfEntry::operator = (const IfEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    ifIndex = that.ifIndex;
    ifDescr = that.ifDescr;
    ifType = that.ifType;
    ifMtu = that.ifMtu;
    ifSpeed = that.ifSpeed;
    ifPhysAddress = that.ifPhysAddress;
    ifAdminStatus = that.ifAdminStatus;
    ifOperStatus = that.ifOperStatus;
    ifLastChange = that.ifLastChange;
    ifInOctets = that.ifInOctets;
    ifInUcastPkts = that.ifInUcastPkts;
    ifInNUcastPkts = that.ifInNUcastPkts;
    ifInDiscards = that.ifInDiscards;
    ifInErrors = that.ifInErrors;
    ifInUnknownProtos = that.ifInUnknownProtos;
    ifOutOctets = that.ifOutOctets;
    ifOutUcastPkts = that.ifOutUcastPkts;
    ifOutNUcastPkts = that.ifOutNUcastPkts;
    ifOutDiscards = that.ifOutDiscards;
    ifOutErrors = that.ifOutErrors;
    ifOutQLen = that.ifOutQLen;
    ifSpecific = that.ifSpecific;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IfEntry &IfEntry::operator = (const IfEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
IfEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = ifSpecific.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OID_TAG_CODE);
    totalLen += l;

    l = ifOutQLen.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 2);
    totalLen += l;

    l = ifOutErrors.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifOutDiscards.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifOutNUcastPkts.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifOutUcastPkts.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifOutOctets.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInUnknownProtos.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInErrors.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInDiscards.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInNUcastPkts.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInUcastPkts.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifInOctets.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 1);
    totalLen += l;

    l = ifLastChange.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 3);
    totalLen += l;

    l = ifOperStatus.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ifAdminStatus.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ifPhysAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OCTETSTRING_TAG_CODE);
    totalLen += l;

    l = ifSpeed.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, APPL, PRIM, 2);
    totalLen += l;

    l = ifMtu.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ifType.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ifDescr.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OCTETSTRING_TAG_CODE);
    totalLen += l;

    l = ifIndex.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // IfEntry::BEncContent


void IfEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifIndex.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -150);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OCTETSTRING_TAG_CODE))
    || (tag1 == MAKE_TAG_ID (UNIV, CONS, OCTETSTRING_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifDescr.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -151);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifType.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -152);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifMtu.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -153);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 2)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifSpeed.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -154);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OCTETSTRING_TAG_CODE))
    || (tag1 == MAKE_TAG_ID (UNIV, CONS, OCTETSTRING_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifPhysAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -155);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifAdminStatus.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -156);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOperStatus.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -157);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 3)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifLastChange.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -158);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInOctets.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -159);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInUcastPkts.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -160);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInNUcastPkts.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -161);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInDiscards.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -162);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInErrors.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -163);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifInUnknownProtos.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -164);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutOctets.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -165);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutUcastPkts.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -166);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutNUcastPkts.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -167);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutDiscards.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -168);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 1)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutErrors.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -169);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 2)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifOutQLen.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -170);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OID_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ifSpecific.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -171);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -172);
  }
  else
    return;
} // IfEntry::BDecContent

AsnLen IfEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IfEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IfEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -173);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int IfEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int IfEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void IfEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "ifIndex ";
    os << ifIndex;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifDescr ";
    os << ifDescr;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifType ";
    os << ifType;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifMtu ";
    os << ifMtu;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifSpeed ";
    os << ifSpeed;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifPhysAddress ";
    os << ifPhysAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifAdminStatus ";
    os << ifAdminStatus;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOperStatus ";
    os << ifOperStatus;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifLastChange ";
    os << ifLastChange;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInOctets ";
    os << ifInOctets;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInUcastPkts ";
    os << ifInUcastPkts;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInNUcastPkts ";
    os << ifInNUcastPkts;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInDiscards ";
    os << ifInDiscards;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInErrors ";
    os << ifInErrors;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifInUnknownProtos ";
    os << ifInUnknownProtos;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutOctets ";
    os << ifOutOctets;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutUcastPkts ";
    os << ifOutUcastPkts;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutNUcastPkts ";
    os << ifOutNUcastPkts;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutDiscards ";
    os << ifOutDiscards;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutErrors ";
    os << ifOutErrors;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifOutQLen ";
    os << ifOutQLen;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ifSpecific ";
    os << ifSpecific;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // IfEntry::Print


AtEntry::AtEntry()
{
#if TCL
  atNetAddress = new NetworkAddress;
#else
  atNetAddress = NULL; // incomplete initialization of mandatory element!
#endif // TCL
}

AtEntry::AtEntry (const AtEntry &)
{
  Asn1Error << "use of incompletely defined AtEntry::AtEntry (const AtEntry &)" << endl;
  abort();
}

AtEntry::~AtEntry()
{
  delete atNetAddress;
}

AsnType *AtEntry::Clone() const
{
  return new AtEntry;
}

#if SNACC_DEEP_COPY
AtEntry &AtEntry::operator = (const AtEntry &that)
#else // SNACC_DEEP_COPY
AtEntry &AtEntry::operator = (const AtEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    atIfIndex = that.atIfIndex;
    atPhysAddress = that.atPhysAddress;
    if (that.atNetAddress)
    {
      if (!atNetAddress)
        atNetAddress = new NetworkAddress;
      *atNetAddress = *that.atNetAddress;
    }
    else
    {
      delete atNetAddress;
      atNetAddress = NULL;
    }
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined AtEntry &AtEntry::operator = (const AtEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
AtEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = atNetAddress->BEncContent (b);
    totalLen += l;

    l = atPhysAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OCTETSTRING_TAG_CODE);
    totalLen += l;

    l = atIfIndex.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // AtEntry::BEncContent


void AtEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    atIfIndex.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -174);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OCTETSTRING_TAG_CODE))
    || (tag1 == MAKE_TAG_ID (UNIV, CONS, OCTETSTRING_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    atPhysAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -175);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    atNetAddress = new NetworkAddress;
    atNetAddress->BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -176);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -177);
  }
  else
    return;
} // AtEntry::BDecContent

AsnLen AtEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void AtEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "AtEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -178);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int AtEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int AtEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void AtEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "atIfIndex ";
    os << atIfIndex;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "atPhysAddress ";
    os << atPhysAddress;
    os << "," << endl;
  }

  if (NOT_NULL (atNetAddress))
  {
    Indent (os, indentG);
    os << "atNetAddress ";
    os << *atNetAddress;
  }
  else
  {
    Indent (os, indentG);
    os << "atNetAddress ";
    os << "-- void --";
    os << endl;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // AtEntry::Print


IpNetToMediaEntry::IpNetToMediaEntry()
{
}

IpNetToMediaEntry::IpNetToMediaEntry (const IpNetToMediaEntry &)
{
  Asn1Error << "use of incompletely defined IpNetToMediaEntry::IpNetToMediaEntry (const IpNetToMediaEntry &)" << endl;
  abort();
}

IpNetToMediaEntry::~IpNetToMediaEntry()
{
}

AsnType *IpNetToMediaEntry::Clone() const
{
  return new IpNetToMediaEntry;
}

#if SNACC_DEEP_COPY
IpNetToMediaEntry &IpNetToMediaEntry::operator = (const IpNetToMediaEntry &that)
#else // SNACC_DEEP_COPY
IpNetToMediaEntry &IpNetToMediaEntry::operator = (const IpNetToMediaEntry &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    ipNetToMediaIfIndex = that.ipNetToMediaIfIndex;
    ipNetToMediaPhysAddress = that.ipNetToMediaPhysAddress;
    ipNetToMediaNetAddress = that.ipNetToMediaNetAddress;
    ipNetToMediaType = that.ipNetToMediaType;
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpNetToMediaEntry &IpNetToMediaEntry::operator = (const IpNetToMediaEntry &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

AsnLen
IpNetToMediaEntry::BEncContent (BUF_TYPE b)
{
  AsnLen totalLen = 0;
  AsnLen l;

    l = ipNetToMediaType.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

    l = ipNetToMediaNetAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, APPL, PRIM, 0);
    totalLen += l;

    l = ipNetToMediaPhysAddress.BEncContent (b);
    l += BEncDefLen (b, l);

    l += BEncTag1 (b, UNIV, PRIM, OCTETSTRING_TAG_CODE);
    totalLen += l;

    l = ipNetToMediaIfIndex.BEncContent (b);
    BEncDefLenTo127 (b, l);
    l++;

    l += BEncTag1 (b, UNIV, PRIM, INTEGER_TAG_CODE);
    totalLen += l;

  return totalLen;
} // IpNetToMediaEntry::BEncContent


void IpNetToMediaEntry::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag1;
  AsnLen seqBytesDecoded = 0;
  AsnLen elmtLen1;
  tag1 = BDecTag (b, seqBytesDecoded, env);

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipNetToMediaIfIndex.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -179);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, OCTETSTRING_TAG_CODE))
    || (tag1 == MAKE_TAG_ID (UNIV, CONS, OCTETSTRING_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipNetToMediaPhysAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -180);
  }

  if ((tag1 == MAKE_TAG_ID (APPL, PRIM, 0))
    || (tag1 == MAKE_TAG_ID (APPL, CONS, 0)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipNetToMediaNetAddress.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
    tag1 = BDecTag (b, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -181);
  }

  if ((tag1 == MAKE_TAG_ID (UNIV, PRIM, INTEGER_TAG_CODE)))
  {
    elmtLen1 = BDecLen (b, seqBytesDecoded, env);
    ipNetToMediaType.BDecContent (b, tag1, elmtLen1, seqBytesDecoded, env);
  }
  else
  {
    Asn1Error << "ERROR - SEQUENCE is missing non-optional elmt." << endl;
    longjmp (env, -182);
  }

  bytesDecoded += seqBytesDecoded;
  if (elmtLen0 == INDEFINITE_LEN)
  {
    BDecEoc (b, bytesDecoded, env);
    return;
  }
  else if (seqBytesDecoded != elmtLen0)
  {
    Asn1Error << "ERROR - Length discrepancy on sequence." << endl;
    longjmp (env, -183);
  }
  else
    return;
} // IpNetToMediaEntry::BDecContent

AsnLen IpNetToMediaEntry::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpNetToMediaEntry::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpNetToMediaEntry::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -184);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

int IpNetToMediaEntry::BEncPdu (BUF_TYPE b, AsnLen &bytesEncoded)
{
    bytesEncoded = BEnc (b);
    return !b.WriteError();
}

int IpNetToMediaEntry::BDecPdu (BUF_TYPE b, AsnLen &bytesDecoded)
{
    ENV_TYPE env;
    int val;

    bytesDecoded = 0;
    if ((val = setjmp (env)) == 0)
    {
         BDec (b, bytesDecoded, env);
         return !b.ReadError();
    }
    else
        return false;
}

void IpNetToMediaEntry::Print (ostream &os) const
{
  os << "{ -- SEQUENCE --" << endl;
  indentG += stdIndentG;

  {
    Indent (os, indentG);
    os << "ipNetToMediaIfIndex ";
    os << ipNetToMediaIfIndex;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipNetToMediaPhysAddress ";
    os << ipNetToMediaPhysAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipNetToMediaNetAddress ";
    os << ipNetToMediaNetAddress;
    os << "," << endl;
  }

  {
    Indent (os, indentG);
    os << "ipNetToMediaType ";
    os << ipNetToMediaType;
  }

  os << endl;
  indentG -= stdIndentG;
  Indent (os, indentG);
  os << "}";
} // IpNetToMediaEntry::Print


AsnType *EgpNeighTable::Clone() const
{
  return new EgpNeighTable;
}

AsnLen EgpNeighTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void EgpNeighTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "EgpNeighTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -185);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

EgpNeighTable::EgpNeighTable (const EgpNeighTable &)
{
  Asn1Error << "use of incompletely defined EgpNeighTable::EgpNeighTable (const EgpNeighTable &)" << endl;
  abort();
}

EgpNeighTable::~EgpNeighTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
EgpNeighTable &EgpNeighTable::operator = (const EgpNeighTable &that)
#else // SNACC_DEEP_COPY
EgpNeighTable &EgpNeighTable::operator = (const EgpNeighTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined EgpNeighTable &EgpNeighTable::operator = (const EgpNeighTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void EgpNeighTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  EgpNeighTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // EgpNeighTable::SetCurrElmt


unsigned long int  EgpNeighTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // EgpNeighTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
EgpNeighEntry *EgpNeighTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new EgpNeighEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // EgpNeighTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
EgpNeighEntry  *EgpNeighTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // EgpNeighTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
EgpNeighEntry  *EgpNeighTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // EgpNeighTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
EgpNeighEntry *EgpNeighTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // EgpNeighTable::InsertAfter


EgpNeighTable  &EgpNeighTable::AppendCopy (EgpNeighEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


EgpNeighTable  &EgpNeighTable::PrependCopy (EgpNeighEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // EgpNeighTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
EgpNeighTable &EgpNeighTable::InsertBeforeAndCopy (EgpNeighEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // EgpNeighTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
EgpNeighTable  &EgpNeighTable::InsertAfterAndCopy (EgpNeighEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new EgpNeighEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // EgpNeighTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void EgpNeighTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen EgpNeighTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // EgpNeighTable::BEncContent


void  EgpNeighTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    EgpNeighEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -186);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // EgpNeighTable::BDecContent


AsnType *UdpTable::Clone() const
{
  return new UdpTable;
}

AsnLen UdpTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void UdpTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "UdpTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -187);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

UdpTable::UdpTable (const UdpTable &)
{
  Asn1Error << "use of incompletely defined UdpTable::UdpTable (const UdpTable &)" << endl;
  abort();
}

UdpTable::~UdpTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
UdpTable &UdpTable::operator = (const UdpTable &that)
#else // SNACC_DEEP_COPY
UdpTable &UdpTable::operator = (const UdpTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined UdpTable &UdpTable::operator = (const UdpTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void UdpTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  UdpTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // UdpTable::SetCurrElmt


unsigned long int  UdpTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // UdpTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
UdpEntry *UdpTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new UdpEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // UdpTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
UdpEntry  *UdpTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // UdpTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
UdpEntry  *UdpTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // UdpTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
UdpEntry *UdpTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // UdpTable::InsertAfter


UdpTable  &UdpTable::AppendCopy (UdpEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


UdpTable  &UdpTable::PrependCopy (UdpEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // UdpTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
UdpTable &UdpTable::InsertBeforeAndCopy (UdpEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // UdpTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
UdpTable  &UdpTable::InsertAfterAndCopy (UdpEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new UdpEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // UdpTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void UdpTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen UdpTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // UdpTable::BEncContent


void  UdpTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    UdpEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -188);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // UdpTable::BDecContent


AsnType *TcpConnTable::Clone() const
{
  return new TcpConnTable;
}

AsnLen TcpConnTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void TcpConnTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "TcpConnTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -189);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

TcpConnTable::TcpConnTable (const TcpConnTable &)
{
  Asn1Error << "use of incompletely defined TcpConnTable::TcpConnTable (const TcpConnTable &)" << endl;
  abort();
}

TcpConnTable::~TcpConnTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
TcpConnTable &TcpConnTable::operator = (const TcpConnTable &that)
#else // SNACC_DEEP_COPY
TcpConnTable &TcpConnTable::operator = (const TcpConnTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined TcpConnTable &TcpConnTable::operator = (const TcpConnTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void TcpConnTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  TcpConnTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // TcpConnTable::SetCurrElmt


unsigned long int  TcpConnTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // TcpConnTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
TcpConnEntry *TcpConnTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new TcpConnEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // TcpConnTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
TcpConnEntry  *TcpConnTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // TcpConnTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
TcpConnEntry  *TcpConnTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // TcpConnTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
TcpConnEntry *TcpConnTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // TcpConnTable::InsertAfter


TcpConnTable  &TcpConnTable::AppendCopy (TcpConnEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


TcpConnTable  &TcpConnTable::PrependCopy (TcpConnEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // TcpConnTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
TcpConnTable &TcpConnTable::InsertBeforeAndCopy (TcpConnEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // TcpConnTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
TcpConnTable  &TcpConnTable::InsertAfterAndCopy (TcpConnEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new TcpConnEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // TcpConnTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void TcpConnTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen TcpConnTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // TcpConnTable::BEncContent


void  TcpConnTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    TcpConnEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -190);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // TcpConnTable::BDecContent


AsnType *IpNetToMediaTable::Clone() const
{
  return new IpNetToMediaTable;
}

AsnLen IpNetToMediaTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpNetToMediaTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpNetToMediaTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -191);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

IpNetToMediaTable::IpNetToMediaTable (const IpNetToMediaTable &)
{
  Asn1Error << "use of incompletely defined IpNetToMediaTable::IpNetToMediaTable (const IpNetToMediaTable &)" << endl;
  abort();
}

IpNetToMediaTable::~IpNetToMediaTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
IpNetToMediaTable &IpNetToMediaTable::operator = (const IpNetToMediaTable &that)
#else // SNACC_DEEP_COPY
IpNetToMediaTable &IpNetToMediaTable::operator = (const IpNetToMediaTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpNetToMediaTable &IpNetToMediaTable::operator = (const IpNetToMediaTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void IpNetToMediaTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  IpNetToMediaTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // IpNetToMediaTable::SetCurrElmt


unsigned long int  IpNetToMediaTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // IpNetToMediaTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
IpNetToMediaEntry *IpNetToMediaTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new IpNetToMediaEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpNetToMediaTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
IpNetToMediaEntry  *IpNetToMediaTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpNetToMediaTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
IpNetToMediaEntry  *IpNetToMediaTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpNetToMediaTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpNetToMediaEntry *IpNetToMediaTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpNetToMediaTable::InsertAfter


IpNetToMediaTable  &IpNetToMediaTable::AppendCopy (IpNetToMediaEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


IpNetToMediaTable  &IpNetToMediaTable::PrependCopy (IpNetToMediaEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // IpNetToMediaTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
IpNetToMediaTable &IpNetToMediaTable::InsertBeforeAndCopy (IpNetToMediaEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // IpNetToMediaTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpNetToMediaTable  &IpNetToMediaTable::InsertAfterAndCopy (IpNetToMediaEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpNetToMediaEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // IpNetToMediaTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void IpNetToMediaTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen IpNetToMediaTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // IpNetToMediaTable::BEncContent


void  IpNetToMediaTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    IpNetToMediaEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -192);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // IpNetToMediaTable::BDecContent


AsnType *IpRouteTable::Clone() const
{
  return new IpRouteTable;
}

AsnLen IpRouteTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpRouteTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpRouteTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -193);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

IpRouteTable::IpRouteTable (const IpRouteTable &)
{
  Asn1Error << "use of incompletely defined IpRouteTable::IpRouteTable (const IpRouteTable &)" << endl;
  abort();
}

IpRouteTable::~IpRouteTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
IpRouteTable &IpRouteTable::operator = (const IpRouteTable &that)
#else // SNACC_DEEP_COPY
IpRouteTable &IpRouteTable::operator = (const IpRouteTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpRouteTable &IpRouteTable::operator = (const IpRouteTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void IpRouteTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  IpRouteTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // IpRouteTable::SetCurrElmt


unsigned long int  IpRouteTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // IpRouteTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
IpRouteEntry *IpRouteTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new IpRouteEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpRouteTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
IpRouteEntry  *IpRouteTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpRouteTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
IpRouteEntry  *IpRouteTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpRouteTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpRouteEntry *IpRouteTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpRouteTable::InsertAfter


IpRouteTable  &IpRouteTable::AppendCopy (IpRouteEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


IpRouteTable  &IpRouteTable::PrependCopy (IpRouteEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // IpRouteTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
IpRouteTable &IpRouteTable::InsertBeforeAndCopy (IpRouteEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // IpRouteTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpRouteTable  &IpRouteTable::InsertAfterAndCopy (IpRouteEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpRouteEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // IpRouteTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void IpRouteTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen IpRouteTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // IpRouteTable::BEncContent


void  IpRouteTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    IpRouteEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -194);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // IpRouteTable::BDecContent


AsnType *IpAddrTable::Clone() const
{
  return new IpAddrTable;
}

AsnLen IpAddrTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IpAddrTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IpAddrTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -195);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

IpAddrTable::IpAddrTable (const IpAddrTable &)
{
  Asn1Error << "use of incompletely defined IpAddrTable::IpAddrTable (const IpAddrTable &)" << endl;
  abort();
}

IpAddrTable::~IpAddrTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
IpAddrTable &IpAddrTable::operator = (const IpAddrTable &that)
#else // SNACC_DEEP_COPY
IpAddrTable &IpAddrTable::operator = (const IpAddrTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IpAddrTable &IpAddrTable::operator = (const IpAddrTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void IpAddrTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  IpAddrTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // IpAddrTable::SetCurrElmt


unsigned long int  IpAddrTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // IpAddrTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
IpAddrEntry *IpAddrTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new IpAddrEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpAddrTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
IpAddrEntry  *IpAddrTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpAddrTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
IpAddrEntry  *IpAddrTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpAddrTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpAddrEntry *IpAddrTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IpAddrTable::InsertAfter


IpAddrTable  &IpAddrTable::AppendCopy (IpAddrEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


IpAddrTable  &IpAddrTable::PrependCopy (IpAddrEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // IpAddrTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
IpAddrTable &IpAddrTable::InsertBeforeAndCopy (IpAddrEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // IpAddrTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IpAddrTable  &IpAddrTable::InsertAfterAndCopy (IpAddrEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IpAddrEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // IpAddrTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void IpAddrTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen IpAddrTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // IpAddrTable::BEncContent


void  IpAddrTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    IpAddrEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -196);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // IpAddrTable::BDecContent


AsnType *AtTable::Clone() const
{
  return new AtTable;
}

AsnLen AtTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void AtTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "AtTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -197);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

AtTable::AtTable (const AtTable &)
{
  Asn1Error << "use of incompletely defined AtTable::AtTable (const AtTable &)" << endl;
  abort();
}

AtTable::~AtTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
AtTable &AtTable::operator = (const AtTable &that)
#else // SNACC_DEEP_COPY
AtTable &AtTable::operator = (const AtTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined AtTable &AtTable::operator = (const AtTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void AtTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  AtTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // AtTable::SetCurrElmt


unsigned long int  AtTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // AtTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
AtEntry *AtTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new AtEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // AtTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
AtEntry  *AtTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // AtTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
AtEntry  *AtTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // AtTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
AtEntry *AtTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // AtTable::InsertAfter


AtTable  &AtTable::AppendCopy (AtEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


AtTable  &AtTable::PrependCopy (AtEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // AtTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
AtTable &AtTable::InsertBeforeAndCopy (AtEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // AtTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
AtTable  &AtTable::InsertAfterAndCopy (AtEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new AtEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // AtTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void AtTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen AtTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // AtTable::BEncContent


void  AtTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    AtEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -198);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // AtTable::BDecContent


AsnType *IfTable::Clone() const
{
  return new IfTable;
}

AsnLen IfTable::BEnc (BUF_TYPE b)
{
  AsnLen l;
  l = BEncContent (b);
  l += BEncConsLen (b, l);
  l += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
  return l;
}

void IfTable::BDec (BUF_TYPE b, AsnLen &bytesDecoded, ENV_TYPE env)
{
  AsnTag tag;
  AsnLen elmtLen1;

  if ((tag = BDecTag (b, bytesDecoded, env)) != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE))
  {
    Asn1Error << "IfTable::BDec: ERROR - wrong tag" << endl;
    longjmp (env, -199);
  }
  elmtLen1 = BDecLen (b, bytesDecoded, env);
  BDecContent (b, tag, elmtLen1, bytesDecoded, env);
}

IfTable::IfTable (const IfTable &)
{
  Asn1Error << "use of incompletely defined IfTable::IfTable (const IfTable &)" << endl;
  abort();
}

IfTable::~IfTable()
{
  SetCurrToFirst();
  for (; Curr() != NULL; RemoveCurrFromList())
    ;
} // end of destructor

#if SNACC_DEEP_COPY
IfTable &IfTable::operator = (const IfTable &that)
#else // SNACC_DEEP_COPY
IfTable &IfTable::operator = (const IfTable &)
#endif // SNACC_DEEP_COPY
{
#if SNACC_DEEP_COPY
  if (this != &that)
  {
    SetCurrToFirst();
    for (; Curr(); RemoveCurrFromList())
      ;

    //that.SetCurrToFirst();
    //for (; that.Curr(); that.GoNext())
    //  AppendCopy (*that.Curr());
    for (const AsnListElmt *run=that.first; run; run=run->next)
      AppendCopy (*run->elmt);
  }

  return *this;
#else // SNACC_DEEP_COPY
  Asn1Error << "use of incompletely defined IfTable &IfTable::operator = (const IfTable &)" << endl;
  abort();
  // if your compiler complains here, check the -novolat option
#endif // SNACC_DEEP_COPY
}

void IfTable::Print (ostream &os) const
{
    os << "{ -- SEQUENCE/SET OF -- " << endl;
    indentG += stdIndentG;
    //SetCurrToFirst();
    //for (; Curr() != NULL; GoNext())
    for (const AsnListElmt *run=first; run; run=run->next)
    {
        Indent (os, indentG);
        //os << *Curr();
        os << *run->elmt;
        //if (Curr() != Last())
        if (run != last)
            os << ",";
        os << endl;
    }
    indentG -= stdIndentG;
    Indent (os, indentG);
    os << "}\n";
} // Print


void  IfTable::SetCurrElmt (unsigned long int index)
{
  unsigned long int i;
  curr = first;
  if (count)
    for (i = 0; (i < (count-1)) && (i < index); i++)
      curr = curr->next;
} // IfTable::SetCurrElmt


unsigned long int  IfTable::GetCurrElmtIndex()
{
    unsigned long int i;
    AsnListElmt *tmp;
    if (curr != NULL)
    {
        for (i = 0, tmp = first; tmp != NULL; i++)
        {
            if (tmp == curr)
                return i;
            else
                tmp = tmp->next;
        }
    }
    return count;
} // IfTable::GetCurrElmtIndex


// alloc new list elmt, put at end of list
//  and return the component type
IfEntry *IfTable::Append()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt  = new IfEntry;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IfTable::Append


// alloc new list elmt, put at begining of list
//  and return the component type
IfEntry  *IfTable::Prepend()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IfTable::Prepend


// alloc new list elmt, insert it before the
// current element and return the component type
// if the current element is null, the new element
// is placed at the beginning of the list.
IfEntry  *IfTable::InsertBefore()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IfTable::InsertBefore


// alloc new list elmt, insert it after the
// current element and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IfEntry *IfTable::InsertAfter()
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return (curr = newElmt)->elmt;
} // IfTable::InsertAfter


IfTable  &IfTable::AppendCopy (IfEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    *newElmt->elmt = elmt;
    newElmt->next = NULL;
    if (last == NULL)
    {
        newElmt->prev = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->prev = last;
        last->next    = newElmt;
        last          = newElmt;
    }
    count++;
    return *this;
} // AppendCopy


IfTable  &IfTable::PrependCopy (IfEntry &elmt)
{
    AsnListElmt *newElmt;
    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    *newElmt->elmt = elmt;
    newElmt->prev = NULL;
    if (first == NULL)
    {
        newElmt->next = NULL;
        first = last  = newElmt;
    }
    else
    {
        newElmt->next = first;
        first->prev   = newElmt;
        first         = newElmt;
    }
    count++;
    return *this;
} // IfTable::PrependCopy


// alloc new list elmt, insert it before the
// current element, copy the given elmt into the new elmt
// and return the component type.
// if the current element is null, the new element
// is placed at the beginning of the list.
IfTable &IfTable::InsertBeforeAndCopy (IfEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    *newElmt->elmt = elmt;

    if (curr == NULL)
    {
        newElmt->next = first;
        newElmt->prev = NULL;
        first = newElmt;
        if (last == NULL)
            last = newElmt;
    }
    else
    {
        newElmt->next = curr;
        newElmt->prev = curr->prev;
        curr->prev = newElmt;
        if (curr == first)
            first = newElmt;
        else
            newElmt->prev->next = newElmt;
    }
    count++;
    return *this;
} // IfTable::InsertBeforeAndCopy


// alloc new list elmt, insert it after the
// current element, copy given elmt in to new elmt
//  and return the component type
// if the current element is null, the new element
// is placed at the end of the list.
IfTable  &IfTable::InsertAfterAndCopy (IfEntry &elmt)
{
    AsnListElmt *newElmt;

    newElmt  = new AsnListElmt;
    newElmt->elmt = new IfEntry;
    *newElmt->elmt = elmt;
    if (curr == NULL)
    {
        newElmt->prev = last;
        newElmt->next = NULL;
        last = newElmt;
        if (first == NULL)
            first = newElmt;
    }
    else
    {
        newElmt->prev = curr;
        newElmt->next = curr->next;
        curr->next = newElmt;
        if (curr == last)
            last = newElmt;
        else
            newElmt->next->prev = newElmt;
    }
    count++;
    return *this;
} // IfTable::InsertAfterAndCopy


// remove current element from list if current element is not NULL 
// The new current element will be the next element.
// If the current element is the last element in the list
// the second but last element will become the new current element.
void IfTable::RemoveCurrFromList()
{
    AsnListElmt *del_elmt;

    if (curr != NULL)
    {
        del_elmt = curr;
        count--;

        if (count == 0)
            first = last = curr = NULL;
        else if (curr == first)
        {
            curr = first= first->next;
            first->prev = NULL;
        }
        else if (curr == last)
        {
            curr = last = last->prev;
            last->next = NULL;
        }
        else
        {
            curr->prev->next = curr->next;
            curr->next->prev = curr->prev;
        }

        delete del_elmt->elmt;
        delete del_elmt;
    }
}


AsnLen IfTable::BEncContent (BUF_TYPE b)
{
    AsnListElmt *currElmt;
    AsnLen elmtLen;
    AsnLen totalLen = 0;
    for (currElmt = last; currElmt != NULL; currElmt = currElmt->prev)
    {
      BEncEocIfNec (b);
        elmtLen = currElmt->elmt->BEncContent (b);
    elmtLen += BEncConsLen (b, elmtLen);

    elmtLen += BEncTag1 (b, UNIV, CONS, SEQ_TAG_CODE);
        totalLen += elmtLen;
    }
    return totalLen;
} // IfTable::BEncContent


void  IfTable::BDecContent (BUF_TYPE b, AsnTag /*tag0*/, AsnLen elmtLen0,
                                  AsnLen &bytesDecoded, ENV_TYPE env)
{
    IfEntry *listElmt;
    AsnTag tag1;
    AsnLen listBytesDecoded = 0;
    AsnLen elmtLen1;

    while ((listBytesDecoded < elmtLen0) || (elmtLen0 == INDEFINITE_LEN))
    {
        tag1 = BDecTag (b, listBytesDecoded, env);
        if ((tag1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
        {
            BDEC_2ND_EOC_OCTET (b, listBytesDecoded, env);
            break;
        }
        if ((tag1 != MAKE_TAG_ID (UNIV, CONS, SEQ_TAG_CODE)))
        {
            Asn1Error << "Unexpected Tag" << endl;
            longjmp (env, -200);
        }

        elmtLen1 = BDecLen (b, listBytesDecoded, env);
        listElmt = Append();
        listElmt->BDecContent (b, tag1, elmtLen1, listBytesDecoded, env);
    }

    bytesDecoded += listBytesDecoded;
} // IfTable::BDecContent