text: /*HEADER****************************************************************
  *
  * Copyright (c) 2008-2009 Freescale Semiconductor;
  * All Rights Reserved
  *
  * Copyright (c) 2004-2009 Embedded Access Inc.;
  * All Rights Reserved
  *
  * Copyright (c) 1989-2008 ARC International;
  * All Rights Reserved
  *
  ***************************************************************************** 
  *
  * THIS SOFTWARE IS PROVIDED BY FREESCALE "AS IS" AND ANY EXPRESSED OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL FREESCALE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  *
  ***************************************************************************** 
  *
  * Comments:  This file was generated by "gawk -f def2c.awk" script.
  *
  *END*******************************************************************/
  
  #include <rtcsrtos.h>
  #include <rtcs.h>
  #include "snmpcfg.h"
  #include "asn1.h"
  #include "snmp.h"
  
  
  #if RTCSCFG_ENABLE_SNMP && RTCSCFG_ENABLE_IP4
  
  extern RTCSMIB_NODE MIBNODE_mgmt;
  
  extern RTCSMIB_NODE MIBNODE_mib2;
  extern const RTCSMIB_NODE MIBNODE_system;
  extern const RTCSMIB_NODE MIBNODE_interfaces;
  extern const RTCSMIB_NODE MIBNODE_ip;
  extern const RTCSMIB_NODE MIBNODE_icmp;
  extern const RTCSMIB_NODE MIBNODE_tcp;
  extern const RTCSMIB_NODE MIBNODE_udp;
  extern const RTCSMIB_NODE MIBNODE_transmission;
  extern const RTCSMIB_NODE MIBNODE_snmp;
  extern const RTCSMIB_NODE MIBNODE_sysDescr;
  extern const RTCSMIB_NODE MIBNODE_sysObjectID;
  extern const RTCSMIB_NODE MIBNODE_sysUpTime;
  extern const RTCSMIB_NODE MIBNODE_sysContact;
  extern const RTCSMIB_NODE MIBNODE_sysName;
  extern const RTCSMIB_NODE MIBNODE_sysLocation;
  extern const RTCSMIB_NODE MIBNODE_sysServices;
  extern const RTCSMIB_NODE MIBNODE_ifNumber;
  extern const RTCSMIB_NODE MIBNODE_ifTable;
  extern const RTCSMIB_NODE MIBNODE_ifEntry;
  extern const RTCSMIB_NODE MIBNODE_ifIndex;
  extern const RTCSMIB_NODE MIBNODE_ifDescr;
  extern const RTCSMIB_NODE MIBNODE_ifType;
  extern const RTCSMIB_NODE MIBNODE_ifMtu;
  extern const RTCSMIB_NODE MIBNODE_ifSpeed;
  extern const RTCSMIB_NODE MIBNODE_ifPhysAddress;
  extern const RTCSMIB_NODE MIBNODE_ifAdminStatus;
  extern const RTCSMIB_NODE MIBNODE_ifOperStatus;
  extern const RTCSMIB_NODE MIBNODE_ifLastChange;
  extern const RTCSMIB_NODE MIBNODE_ifInOctets;
  extern const RTCSMIB_NODE MIBNODE_ifInUcastPkts;
  extern const RTCSMIB_NODE MIBNODE_ifInNUcastPkts;
  extern const RTCSMIB_NODE MIBNODE_ifInDiscards;
  extern const RTCSMIB_NODE MIBNODE_ifInErrors;
  extern const RTCSMIB_NODE MIBNODE_ifInUnknownProtos;
  extern const RTCSMIB_NODE MIBNODE_ifOutOctets;
  extern const RTCSMIB_NODE MIBNODE_ifOutUcastPkts;
  extern const RTCSMIB_NODE MIBNODE_ifOutNUcastPkts;
  extern const RTCSMIB_NODE MIBNODE_ifOutDiscards;
  extern const RTCSMIB_NODE MIBNODE_ifOutErrors;
  extern const RTCSMIB_NODE MIBNODE_ifOutQLen;
  extern const RTCSMIB_NODE MIBNODE_ifSpecific;
  extern const RTCSMIB_NODE MIBNODE_ipForwarding;
  extern const RTCSMIB_NODE MIBNODE_ipDefaultTTL;
  extern const RTCSMIB_NODE MIBNODE_ipInReceives;
  extern const RTCSMIB_NODE MIBNODE_ipInHdrErrors;
  extern const RTCSMIB_NODE MIBNODE_ipInAddrErrors;
  extern const RTCSMIB_NODE MIBNODE_ipForwDatagrams;
  extern const RTCSMIB_NODE MIBNODE_ipInUnknownProtos;
  extern const RTCSMIB_NODE MIBNODE_ipInDiscards;
  extern const RTCSMIB_NODE MIBNODE_ipInDelivers;
  extern const RTCSMIB_NODE MIBNODE_ipOutRequests;
  extern const RTCSMIB_NODE MIBNODE_ipOutDiscards;
  extern const RTCSMIB_NODE MIBNODE_ipOutNoRoutes;
  extern const RTCSMIB_NODE MIBNODE_ipReasmTimeout;
  extern const RTCSMIB_NODE MIBNODE_ipReasmReqds;
  extern const RTCSMIB_NODE MIBNODE_ipReasmOKs;
  extern const RTCSMIB_NODE MIBNODE_ipReasmFails;
  extern const RTCSMIB_NODE MIBNODE_ipFragOKs;
  extern const RTCSMIB_NODE MIBNODE_ipFragFails;
  extern const RTCSMIB_NODE MIBNODE_ipFragCreates;
  extern const RTCSMIB_NODE MIBNODE_ipAddrTable;
  extern const RTCSMIB_NODE MIBNODE_ipAddrEntry;
  extern const RTCSMIB_NODE MIBNODE_ipAdEntAddr;
  extern const RTCSMIB_NODE MIBNODE_ipAdEntIfIndex;
  extern const RTCSMIB_NODE MIBNODE_ipAdEntNetMask;
  extern const RTCSMIB_NODE MIBNODE_ipAdEntBcastAddr;
  extern const RTCSMIB_NODE MIBNODE_ipAdEntReasmMaxSize;
  extern const RTCSMIB_NODE MIBNODE_ipRouteTable;
  extern const RTCSMIB_NODE MIBNODE_ipRouteEntry;
  extern const RTCSMIB_NODE MIBNODE_ipRouteDest;
  extern const RTCSMIB_NODE MIBNODE_ipRouteIfIndex;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMetric1;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMetric2;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMetric3;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMetric4;
  extern const RTCSMIB_NODE MIBNODE_ipRouteNextHop;
  extern const RTCSMIB_NODE MIBNODE_ipRouteType;
  extern const RTCSMIB_NODE MIBNODE_ipRouteProto;
  extern const RTCSMIB_NODE MIBNODE_ipRouteAge;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMask;
  extern const RTCSMIB_NODE MIBNODE_ipRouteMetric5;
  extern const RTCSMIB_NODE MIBNODE_ipRouteInfo;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaTable;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaEntry;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaIfIndex;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaPhysAddress;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaNetAddress;
  extern const RTCSMIB_NODE MIBNODE_ipNetToMediaType;
  extern const RTCSMIB_NODE MIBNODE_ipRoutingDiscards;
  extern const RTCSMIB_NODE MIBNODE_icmpInMsgs;
  extern const RTCSMIB_NODE MIBNODE_icmpInErrors;
  extern const RTCSMIB_NODE MIBNODE_icmpInDestUnreachs;
  extern const RTCSMIB_NODE MIBNODE_icmpInTimeExcds;
  extern const RTCSMIB_NODE MIBNODE_icmpInParmProbs;
  extern const RTCSMIB_NODE MIBNODE_icmpInSrcQuenchs;
  extern const RTCSMIB_NODE MIBNODE_icmpInRedirects;
  extern const RTCSMIB_NODE MIBNODE_icmpInEchos;
  extern const RTCSMIB_NODE MIBNODE_icmpInEchoReps;
  extern const RTCSMIB_NODE MIBNODE_icmpInTimestamps;
  extern const RTCSMIB_NODE MIBNODE_icmpInTimestampReps;
  extern const RTCSMIB_NODE MIBNODE_icmpInAddrMasks;
  extern const RTCSMIB_NODE MIBNODE_icmpInAddrMaskReps;
  extern const RTCSMIB_NODE MIBNODE_icmpOutMsgs;
  extern const RTCSMIB_NODE MIBNODE_icmpOutErrors;
  extern const RTCSMIB_NODE MIBNODE_icmpOutDestUnreachs;
  extern const RTCSMIB_NODE MIBNODE_icmpOutTimeExcds;
  extern const RTCSMIB_NODE MIBNODE_icmpOutParmProbs;
  extern const RTCSMIB_NODE MIBNODE_icmpOutSrcQuenchs;
  extern const RTCSMIB_NODE MIBNODE_icmpOutRedirects;
  extern const RTCSMIB_NODE MIBNODE_icmpOutEchos;
  extern const RTCSMIB_NODE MIBNODE_icmpOutEchoReps;
  extern const RTCSMIB_NODE MIBNODE_icmpOutTimestamps;
  extern const RTCSMIB_NODE MIBNODE_icmpOutTimestampReps;
  extern const RTCSMIB_NODE MIBNODE_icmpOutAddrMasks;
  extern const RTCSMIB_NODE MIBNODE_icmpOutAddrMaskReps;
  extern const RTCSMIB_NODE MIBNODE_tcpRtoAlgorithm;
  extern const RTCSMIB_NODE MIBNODE_tcpRtoMin;
  extern const RTCSMIB_NODE MIBNODE_tcpRtoMax;
  extern const RTCSMIB_NODE MIBNODE_tcpMaxConn;
  extern const RTCSMIB_NODE MIBNODE_tcpActiveOpens;
  extern const RTCSMIB_NODE MIBNODE_tcpPassiveOpens;
  extern const RTCSMIB_NODE MIBNODE_tcpAttemptFails;
  extern const RTCSMIB_NODE MIBNODE_tcpEstabResets;
  extern const RTCSMIB_NODE MIBNODE_tcpCurrEstab;
  extern const RTCSMIB_NODE MIBNODE_tcpInSegs;
  extern const RTCSMIB_NODE MIBNODE_tcpOutSegs;
  extern const RTCSMIB_NODE MIBNODE_tcpRetransSegs;
  extern const RTCSMIB_NODE MIBNODE_tcpConnTable;
  extern const RTCSMIB_NODE MIBNODE_tcpConnEntry;
  extern const RTCSMIB_NODE MIBNODE_tcpConnState;
  extern const RTCSMIB_NODE MIBNODE_tcpConnLocalAddress;
  extern const RTCSMIB_NODE MIBNODE_tcpConnLocalPort;
  extern const RTCSMIB_NODE MIBNODE_tcpConnRemAddress;
  extern const RTCSMIB_NODE MIBNODE_tcpConnRemPort;
  extern const RTCSMIB_NODE MIBNODE_tcpInErrs;
  extern const RTCSMIB_NODE MIBNODE_tcpOutRsts;
  extern const RTCSMIB_NODE MIBNODE_udpInDatagrams;
  extern const RTCSMIB_NODE MIBNODE_udpNoPorts;
  extern const RTCSMIB_NODE MIBNODE_udpInErrors;
  extern const RTCSMIB_NODE MIBNODE_udpOutDatagrams;
  extern const RTCSMIB_NODE MIBNODE_udpTable;
  extern const RTCSMIB_NODE MIBNODE_udpEntry;
  extern const RTCSMIB_NODE MIBNODE_udpLocalAddress;
  extern const RTCSMIB_NODE MIBNODE_udpLocalPort;
  extern const RTCSMIB_NODE MIBNODE_snmpInPkts;
  extern const RTCSMIB_NODE MIBNODE_snmpOutPkts;
  extern const RTCSMIB_NODE MIBNODE_snmpInBadVersions;
  extern const RTCSMIB_NODE MIBNODE_snmpInBadCommunityNames;
  extern const RTCSMIB_NODE MIBNODE_snmpInBadCommunityUses;
  extern const RTCSMIB_NODE MIBNODE_snmpInASNParseErrs;
  extern const RTCSMIB_NODE MIBNODE_snmpInTooBigs;
  extern const RTCSMIB_NODE MIBNODE_snmpInNoSuchNames;
  extern const RTCSMIB_NODE MIBNODE_snmpInBadValues;
  extern const RTCSMIB_NODE MIBNODE_snmpInReadOnlys;
  extern const RTCSMIB_NODE MIBNODE_snmpInGenErrs;
  extern const RTCSMIB_NODE MIBNODE_snmpInTotalReqVars;
  extern const RTCSMIB_NODE MIBNODE_snmpInTotalSetVars;
  extern const RTCSMIB_NODE MIBNODE_snmpInGetRequests;
  extern const RTCSMIB_NODE MIBNODE_snmpInGetNexts;
  extern const RTCSMIB_NODE MIBNODE_snmpInSetRequests;
  extern const RTCSMIB_NODE MIBNODE_snmpInGetResponses;
  extern const RTCSMIB_NODE MIBNODE_snmpInTraps;
  extern const RTCSMIB_NODE MIBNODE_snmpOutTooBigs;
  extern const RTCSMIB_NODE MIBNODE_snmpOutNoSuchNames;
  extern const RTCSMIB_NODE MIBNODE_snmpOutBadValues;
  extern const RTCSMIB_NODE MIBNODE_snmpOutGenErrs;
  extern const RTCSMIB_NODE MIBNODE_snmpOutGetRequests;
  extern const RTCSMIB_NODE MIBNODE_snmpOutGetNexts;
  extern const RTCSMIB_NODE MIBNODE_snmpOutSetRequests;
  extern const RTCSMIB_NODE MIBNODE_snmpOutGetResponses;
  extern const RTCSMIB_NODE MIBNODE_snmpOutTraps;
  extern const RTCSMIB_NODE MIBNODE_snmpEnableAuthenTraps;
  
  extern const RTCSMIB_VALUE MIBVALUE_mib2;
  extern const RTCSMIB_VALUE MIBVALUE_system;
  extern const RTCSMIB_VALUE MIBVALUE_interfaces;
  extern const RTCSMIB_VALUE MIBVALUE_ip;
  extern const RTCSMIB_VALUE MIBVALUE_icmp;
  extern const RTCSMIB_VALUE MIBVALUE_tcp;
  extern const RTCSMIB_VALUE MIBVALUE_udp;
  extern const RTCSMIB_VALUE MIBVALUE_transmission;
  extern const RTCSMIB_VALUE MIBVALUE_snmp;
  extern const RTCSMIB_VALUE MIBVALUE_sysDescr;
  extern const RTCSMIB_VALUE MIBVALUE_sysObjectID;
  extern const RTCSMIB_VALUE MIBVALUE_sysUpTime;
  extern const RTCSMIB_VALUE MIBVALUE_sysContact;
  extern const RTCSMIB_VALUE MIBVALUE_sysName;
  extern const RTCSMIB_VALUE MIBVALUE_sysLocation;
  extern const RTCSMIB_VALUE MIBVALUE_sysServices;
  extern const RTCSMIB_VALUE MIBVALUE_ifNumber;
  extern const RTCSMIB_VALUE MIBVALUE_ifTable;
  extern const RTCSMIB_VALUE MIBVALUE_ifEntry;
  extern const RTCSMIB_VALUE MIBVALUE_ifIndex;
  extern const RTCSMIB_VALUE MIBVALUE_ifDescr;
  extern const RTCSMIB_VALUE MIBVALUE_ifType;
  extern const RTCSMIB_VALUE MIBVALUE_ifMtu;
  extern const RTCSMIB_VALUE MIBVALUE_ifSpeed;
  extern const RTCSMIB_VALUE MIBVALUE_ifPhysAddress;
  extern const RTCSMIB_VALUE MIBVALUE_ifAdminStatus;
  extern const RTCSMIB_VALUE MIBVALUE_ifOperStatus;
  extern const RTCSMIB_VALUE MIBVALUE_ifLastChange;
  extern const RTCSMIB_VALUE MIBVALUE_ifInOctets;
  extern const RTCSMIB_VALUE MIBVALUE_ifInUcastPkts;
  extern const RTCSMIB_VALUE MIBVALUE_ifInNUcastPkts;
  extern const RTCSMIB_VALUE MIBVALUE_ifInDiscards;
  extern const RTCSMIB_VALUE MIBVALUE_ifInErrors;
  extern const RTCSMIB_VALUE MIBVALUE_ifInUnknownProtos;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutOctets;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutUcastPkts;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutNUcastPkts;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutDiscards;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutErrors;
  extern const RTCSMIB_VALUE MIBVALUE_ifOutQLen;
  extern const RTCSMIB_VALUE MIBVALUE_ifSpecific;
  extern const RTCSMIB_VALUE MIBVALUE_ipForwarding;
  extern const RTCSMIB_VALUE MIBVALUE_ipDefaultTTL;
  extern const RTCSMIB_VALUE MIBVALUE_ipInReceives;
  extern const RTCSMIB_VALUE MIBVALUE_ipInHdrErrors;
  extern const RTCSMIB_VALUE MIBVALUE_ipInAddrErrors;
  extern const RTCSMIB_VALUE MIBVALUE_ipForwDatagrams;
  extern const RTCSMIB_VALUE MIBVALUE_ipInUnknownProtos;
  extern const RTCSMIB_VALUE MIBVALUE_ipInDiscards;
  extern const RTCSMIB_VALUE MIBVALUE_ipInDelivers;
  extern const RTCSMIB_VALUE MIBVALUE_ipOutRequests;
  extern const RTCSMIB_VALUE MIBVALUE_ipOutDiscards;
  extern const RTCSMIB_VALUE MIBVALUE_ipOutNoRoutes;
  extern const RTCSMIB_VALUE MIBVALUE_ipReasmTimeout;
  extern const RTCSMIB_VALUE MIBVALUE_ipReasmReqds;
  extern const RTCSMIB_VALUE MIBVALUE_ipReasmOKs;
  extern const RTCSMIB_VALUE MIBVALUE_ipReasmFails;
  extern const RTCSMIB_VALUE MIBVALUE_ipFragOKs;
  extern const RTCSMIB_VALUE MIBVALUE_ipFragFails;
  extern const RTCSMIB_VALUE MIBVALUE_ipFragCreates;
  extern const RTCSMIB_VALUE MIBVALUE_ipAddrTable;
  extern const RTCSMIB_VALUE MIBVALUE_ipAddrEntry;
  extern const RTCSMIB_VALUE MIBVALUE_ipAdEntAddr;
  extern const RTCSMIB_VALUE MIBVALUE_ipAdEntIfIndex;
  extern const RTCSMIB_VALUE MIBVALUE_ipAdEntNetMask;
  extern const RTCSMIB_VALUE MIBVALUE_ipAdEntBcastAddr;
  extern const RTCSMIB_VALUE MIBVALUE_ipAdEntReasmMaxSize;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteTable;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteEntry;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteDest;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteIfIndex;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric1;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric2;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric3;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric4;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteNextHop;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteType;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteProto;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteAge;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMask;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteMetric5;
  extern const RTCSMIB_VALUE MIBVALUE_ipRouteInfo;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaTable;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaEntry;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaIfIndex;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaPhysAddress;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaNetAddress;
  extern const RTCSMIB_VALUE MIBVALUE_ipNetToMediaType;
  extern const RTCSMIB_VALUE MIBVALUE_ipRoutingDiscards;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInMsgs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInErrors;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInDestUnreachs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInTimeExcds;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInParmProbs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInSrcQuenchs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInRedirects;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInEchos;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInEchoReps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInTimestamps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInTimestampReps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInAddrMasks;
  extern const RTCSMIB_VALUE MIBVALUE_icmpInAddrMaskReps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutMsgs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutErrors;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutDestUnreachs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimeExcds;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutParmProbs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutSrcQuenchs;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutRedirects;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutEchos;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutEchoReps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimestamps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutTimestampReps;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMasks;
  extern const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMaskReps;
  extern const RTCSMIB_VALUE MIBVALUE_tcpRtoAlgorithm;
  extern const RTCSMIB_VALUE MIBVALUE_tcpRtoMin;
  extern const RTCSMIB_VALUE MIBVALUE_tcpRtoMax;
  extern const RTCSMIB_VALUE MIBVALUE_tcpMaxConn;
  extern const RTCSMIB_VALUE MIBVALUE_tcpActiveOpens;
  extern const RTCSMIB_VALUE MIBVALUE_tcpPassiveOpens;
  extern const RTCSMIB_VALUE MIBVALUE_tcpAttemptFails;
  extern const RTCSMIB_VALUE MIBVALUE_tcpEstabResets;
  extern const RTCSMIB_VALUE MIBVALUE_tcpCurrEstab;
  extern const RTCSMIB_VALUE MIBVALUE_tcpInSegs;
  extern const RTCSMIB_VALUE MIBVALUE_tcpOutSegs;
  extern const RTCSMIB_VALUE MIBVALUE_tcpRetransSegs;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnTable;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnEntry;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnState;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnLocalAddress;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnLocalPort;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnRemAddress;
  extern const RTCSMIB_VALUE MIBVALUE_tcpConnRemPort;
  extern const RTCSMIB_VALUE MIBVALUE_tcpInErrs;
  extern const RTCSMIB_VALUE MIBVALUE_tcpOutRsts;
  extern const RTCSMIB_VALUE MIBVALUE_udpInDatagrams;
  extern const RTCSMIB_VALUE MIBVALUE_udpNoPorts;
  extern const RTCSMIB_VALUE MIBVALUE_udpInErrors;
  extern const RTCSMIB_VALUE MIBVALUE_udpOutDatagrams;
  extern const RTCSMIB_VALUE MIBVALUE_udpTable;
  extern const RTCSMIB_VALUE MIBVALUE_udpEntry;
  extern const RTCSMIB_VALUE MIBVALUE_udpLocalAddress;
  extern const RTCSMIB_VALUE MIBVALUE_udpLocalPort;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInPkts;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutPkts;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInBadVersions;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityNames;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityUses;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInASNParseErrs;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInTooBigs;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInNoSuchNames;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInBadValues;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInReadOnlys;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInGenErrs;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInTotalReqVars;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInTotalSetVars;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInGetRequests;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInGetNexts;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInSetRequests;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInGetResponses;
  extern const RTCSMIB_VALUE MIBVALUE_snmpInTraps;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutTooBigs;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutNoSuchNames;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutBadValues;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutGenErrs;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetRequests;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetNexts;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutSetRequests;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutGetResponses;
  extern const RTCSMIB_VALUE MIBVALUE_snmpOutTraps;
  extern const RTCSMIB_VALUE MIBVALUE_snmpEnableAuthenTraps;
  
  boolean MIB_find_ipAddrEntry         (uint_32, pointer, pointer _PTR_);
  boolean MIB_find_ifEntry             (uint_32, pointer, pointer _PTR_);
  boolean MIB_find_udpEntry            (uint_32, pointer, pointer _PTR_);
  boolean MIB_find_ipRouteEntry        (uint_32, pointer, pointer _PTR_);
  boolean MIB_find_tcpConnEntry        (uint_32, pointer, pointer _PTR_);
  boolean MIB_find_ipNetToMediaEntry   (uint_32, pointer, pointer _PTR_);
  
  static boolean MIB_instance_ipAddrEntry         (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  static boolean MIB_instance_ifEntry             (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  static boolean MIB_instance_udpEntry            (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  static boolean MIB_instance_ipRouteEntry        (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  static boolean MIB_instance_tcpConnEntry        (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  static boolean MIB_instance_ipNetToMediaEntry   (RTCSMIB_WALK_PTR, uint_32, boolean (_CODE_PTR_)(uint_32, pointer, pointer _PTR_), boolean _PTR_, pointer _PTR_);
  
  static uint_32 MIB_set_sysContact          (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_sysName             (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_sysLocation         (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ifAdminStatus       (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipForwarding        (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipDefaultTTL        (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteDest         (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteIfIndex      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMetric1      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMetric2      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMetric3      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMetric4      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteNextHop      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteType         (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteAge          (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMask         (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipRouteMetric5      (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipNetToMediaIfIndex (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipNetToMediaPhysAddress(pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipNetToMediaNetAddress(pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_ipNetToMediaType    (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_tcpConnState        (pointer, uchar_ptr, uint_32);
  static uint_32 MIB_set_snmpEnableAuthenTraps(pointer, uchar_ptr, uint_32);
  
  RTCSMIB_NODE MIBNODE_mib2 = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
     (RTCSMIB_NODE_PTR)&MIBNODE_mgmt,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_system = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,
     (RTCSMIB_NODE_PTR)&MIBNODE_sysDescr,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_interfaces = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifNumber,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ip = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipForwarding,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmp = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInMsgs,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcp = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoAlgorithm,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udp = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_transmission,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpInDatagrams,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_transmission = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmp = {
     11,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInPkts,
     (RTCSMIB_NODE_PTR)&MIBNODE_mib2,
  
     0,
     NULL,
     NULL, 0, NULL, NULL
  };
  
  const RTCSMIB_NODE MIBNODE_sysDescr = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysObjectID,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysDescr,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_sysObjectID = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysUpTime,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_OBJECT,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysObjectID,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_sysUpTime = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysContact,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_TimeTicks,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysUpTime,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_sysContact = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysName,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysContact,
     MIB_set_sysContact
  };
  
  const RTCSMIB_NODE MIBNODE_sysName = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysLocation,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysName,
     MIB_set_sysName
  };
  
  const RTCSMIB_NODE MIBNODE_sysLocation = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_sysServices,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysLocation,
     MIB_set_sysLocation
  };
  
  const RTCSMIB_NODE MIBNODE_sysServices = {
     7,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_system,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_sysServices,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifNumber = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifTable,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifNumber,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifTable = {
     2,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_interfaces,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifIndex,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifTable,
  
     0,
     MIB_find_ifEntry,
     MIB_instance_ifEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifIndex = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifDescr,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifIndex,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifDescr = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifType,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifDescr,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifType = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifMtu,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifType,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifMtu = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifSpeed,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifMtu,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifSpeed = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifPhysAddress,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Gauge,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifSpeed,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifPhysAddress = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifAdminStatus,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifPhysAddress,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifAdminStatus = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOperStatus,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifAdminStatus,
     MIB_set_ifAdminStatus
  };
  
  const RTCSMIB_NODE MIBNODE_ifOperStatus = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifLastChange,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOperStatus,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifLastChange = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInOctets,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_TimeTicks,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifLastChange,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInOctets = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInUcastPkts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInOctets,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInUcastPkts = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInNUcastPkts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInUcastPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInNUcastPkts = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInDiscards,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInNUcastPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInDiscards = {
     13,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInDiscards,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInErrors = {
     14,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifInUnknownProtos,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifInUnknownProtos = {
     15,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutOctets,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifInUnknownProtos,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutOctets = {
     16,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutUcastPkts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutOctets,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutUcastPkts = {
     17,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutNUcastPkts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutUcastPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutNUcastPkts = {
     18,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutDiscards,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutNUcastPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutDiscards = {
     19,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutDiscards,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutErrors = {
     20,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifOutQLen,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifOutQLen = {
     21,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ifSpecific,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_Gauge,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifOutQLen,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ifSpecific = {
     22,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ifEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ifEntry, ASN1_TYPE_OBJECT,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ifSpecific,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipForwarding = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipDefaultTTL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipForwarding,
     MIB_set_ipForwarding
  };
  
  const RTCSMIB_NODE MIBNODE_ipDefaultTTL = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInReceives,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipDefaultTTL,
     MIB_set_ipDefaultTTL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInReceives = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInHdrErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInReceives,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInHdrErrors = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInAddrErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInHdrErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInAddrErrors = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipForwDatagrams,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInAddrErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipForwDatagrams = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInUnknownProtos,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipForwDatagrams,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInUnknownProtos = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInDiscards,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInUnknownProtos,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInDiscards = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipInDelivers,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInDiscards,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipInDelivers = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipOutRequests,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipInDelivers,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipOutRequests = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipOutDiscards,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutRequests,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipOutDiscards = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipOutNoRoutes,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutDiscards,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipOutNoRoutes = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmTimeout,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipOutNoRoutes,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipReasmTimeout = {
     13,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmReqds,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmTimeout,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipReasmReqds = {
     14,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmOKs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmReqds,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipReasmOKs = {
     15,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipReasmFails,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmOKs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipReasmFails = {
     16,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipFragOKs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipReasmFails,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipFragOKs = {
     17,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipFragFails,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragOKs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipFragFails = {
     18,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipFragCreates,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragFails,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipFragCreates = {
     19,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrTable,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipFragCreates,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAddrTable = {
     20,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteTable,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAddrTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAddrEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntAddr,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrTable,
  
     0,
     MIB_find_ipAddrEntry,
     MIB_instance_ipAddrEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAddrEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAdEntAddr = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntIfIndex,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipAddrEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntAddr,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAdEntIfIndex = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntNetMask,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntIfIndex,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAdEntNetMask = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntBcastAddr,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipAddrEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntNetMask,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAdEntBcastAddr = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAdEntReasmMaxSize,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntBcastAddr,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipAdEntReasmMaxSize = {
     5,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipAddrEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipAddrEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipAdEntReasmMaxSize,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteTable = {
     21,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaTable,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteDest,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteTable,
  
     0,
     MIB_find_ipRouteEntry,
     MIB_instance_ipRouteEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteDest = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteIfIndex,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteDest,
     MIB_set_ipRouteDest
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteIfIndex = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric1,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteIfIndex,
     MIB_set_ipRouteIfIndex
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMetric1 = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric2,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric1,
     MIB_set_ipRouteMetric1
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMetric2 = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric3,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric2,
     MIB_set_ipRouteMetric2
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMetric3 = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric4,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric3,
     MIB_set_ipRouteMetric3
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMetric4 = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteNextHop,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric4,
     MIB_set_ipRouteMetric4
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteNextHop = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteType,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteNextHop,
     MIB_set_ipRouteNextHop
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteType = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteProto,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteType,
     MIB_set_ipRouteType
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteProto = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteAge,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteProto,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteAge = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMask,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteAge,
     MIB_set_ipRouteAge
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMask = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteMetric5,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMask,
     MIB_set_ipRouteMask
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteMetric5 = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteInfo,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteMetric5,
     MIB_set_ipRouteMetric5
  };
  
  const RTCSMIB_NODE MIBNODE_ipRouteInfo = {
     13,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRouteEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_ipRouteEntry, ASN1_TYPE_OBJECT,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRouteInfo,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaTable = {
     22,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipRoutingDiscards,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaIfIndex,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaTable,
  
     0,
     MIB_find_ipNetToMediaEntry,
     MIB_instance_ipNetToMediaEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaIfIndex = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaPhysAddress,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipNetToMediaEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaIfIndex,
     MIB_set_ipNetToMediaIfIndex
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaPhysAddress = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaNetAddress,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipNetToMediaEntry, ASN1_TYPE_OCTET,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaPhysAddress,
     MIB_set_ipNetToMediaPhysAddress
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaNetAddress = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaType,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipNetToMediaEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaNetAddress,
     MIB_set_ipNetToMediaNetAddress
  };
  
  const RTCSMIB_NODE MIBNODE_ipNetToMediaType = {
     4,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ipNetToMediaEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_ipNetToMediaEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipNetToMediaType,
     MIB_set_ipNetToMediaType
  };
  
  const RTCSMIB_NODE MIBNODE_ipRoutingDiscards = {
     23,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_ip,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_ipRoutingDiscards,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInMsgs = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInMsgs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInErrors = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInDestUnreachs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInDestUnreachs = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimeExcds,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInDestUnreachs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInTimeExcds = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInParmProbs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimeExcds,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInParmProbs = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInSrcQuenchs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInParmProbs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInSrcQuenchs = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInRedirects,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInSrcQuenchs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInRedirects = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInEchos,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInRedirects,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInEchos = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInEchoReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInEchos,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInEchoReps = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimestamps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInEchoReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInTimestamps = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInTimestampReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimestamps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInTimestampReps = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInAddrMasks,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInTimestampReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInAddrMasks = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpInAddrMaskReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInAddrMasks,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpInAddrMaskReps = {
     13,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutMsgs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpInAddrMaskReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutMsgs = {
     14,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutMsgs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutErrors = {
     15,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutDestUnreachs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutDestUnreachs = {
     16,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimeExcds,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutDestUnreachs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutTimeExcds = {
     17,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutParmProbs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimeExcds,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutParmProbs = {
     18,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutSrcQuenchs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutParmProbs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutSrcQuenchs = {
     19,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutRedirects,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutSrcQuenchs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutRedirects = {
     20,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutEchos,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutRedirects,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutEchos = {
     21,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutEchoReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutEchos,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutEchoReps = {
     22,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimestamps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutEchoReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutTimestamps = {
     23,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutTimestampReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimestamps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutTimestampReps = {
     24,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutAddrMasks,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutTimestampReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutAddrMasks = {
     25,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_icmpOutAddrMaskReps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutAddrMasks,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_icmpOutAddrMaskReps = {
     26,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_icmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_icmpOutAddrMaskReps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpRtoAlgorithm = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoMin,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoAlgorithm,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpRtoMin = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpRtoMax,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoMin,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpRtoMax = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpMaxConn,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRtoMax,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpMaxConn = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpActiveOpens,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpMaxConn,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpActiveOpens = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpPassiveOpens,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpActiveOpens,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpPassiveOpens = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpAttemptFails,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpPassiveOpens,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpAttemptFails = {
     7,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpEstabResets,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpAttemptFails,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpEstabResets = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpCurrEstab,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpEstabResets,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpCurrEstab = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpInSegs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Gauge,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpCurrEstab,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpInSegs = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpOutSegs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpInSegs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpOutSegs = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpRetransSegs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpOutSegs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpRetransSegs = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnTable,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpRetransSegs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnTable = {
     13,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpInErrs,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnState,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnTable,
  
     0,
     MIB_find_tcpConnEntry,
     MIB_instance_tcpConnEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnState = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnLocalAddress,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnState,
     MIB_set_tcpConnState
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnLocalAddress = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnLocalPort,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_tcpConnEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnLocalAddress,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnLocalPort = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnRemAddress,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnLocalPort,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnRemAddress = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnRemPort,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_tcpConnEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnRemAddress,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpConnRemPort = {
     5,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpConnEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_tcpConnEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpConnRemPort,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpInErrs = {
     14,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_tcpOutRsts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpInErrs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_tcpOutRsts = {
     15,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_tcp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_tcpOutRsts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpInDatagrams = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udpNoPorts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpInDatagrams,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpNoPorts = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udpInErrors,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpNoPorts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpInErrors = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udpOutDatagrams,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpInErrors,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpOutDatagrams = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udpTable,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpOutDatagrams,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpTable = {
     5,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,
     (RTCSMIB_NODE_PTR)&MIBNODE_udp,
  
     0,
     NULL,
     MIB_instance_zero, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpTable,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpEntry = {
     1,
  
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpLocalAddress,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpTable,
  
     0,
     MIB_find_udpEntry,
     MIB_instance_udpEntry, ASN1_TYPE_SEQUENCE,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpEntry,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpLocalAddress = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_udpLocalPort,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_udpEntry, ASN1_TYPE_IpAddress,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpLocalAddress,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_udpLocalPort = {
     2,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_udpEntry,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_udpEntry, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_udpLocalPort,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInPkts = {
     1,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutPkts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutPkts = {
     2,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadVersions,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutPkts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInBadVersions = {
     3,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadCommunityNames,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadVersions,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInBadCommunityNames = {
     4,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadCommunityUses,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadCommunityNames,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInBadCommunityUses = {
     5,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInASNParseErrs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadCommunityUses,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInASNParseErrs = {
     6,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTooBigs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInASNParseErrs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInTooBigs = {
     8,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInNoSuchNames,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTooBigs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInNoSuchNames = {
     9,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInBadValues,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInNoSuchNames,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInBadValues = {
     10,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInReadOnlys,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInBadValues,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInReadOnlys = {
     11,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGenErrs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInReadOnlys,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInGenErrs = {
     12,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTotalReqVars,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGenErrs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInTotalReqVars = {
     13,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTotalSetVars,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTotalReqVars,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInTotalSetVars = {
     14,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetRequests,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTotalSetVars,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInGetRequests = {
     15,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetNexts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetRequests,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInGetNexts = {
     16,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInSetRequests,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetNexts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInSetRequests = {
     17,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInGetResponses,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInSetRequests,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInGetResponses = {
     18,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpInTraps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInGetResponses,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpInTraps = {
     19,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutTooBigs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpInTraps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutTooBigs = {
     20,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutNoSuchNames,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutTooBigs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutNoSuchNames = {
     21,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutBadValues,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutNoSuchNames,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutBadValues = {
     22,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGenErrs,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutBadValues,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutGenErrs = {
     24,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetRequests,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGenErrs,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutGetRequests = {
     25,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetNexts,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetRequests,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutGetNexts = {
     26,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutSetRequests,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetNexts,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutSetRequests = {
     27,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutGetResponses,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutSetRequests,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutGetResponses = {
     28,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpOutTraps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutGetResponses,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpOutTraps = {
     29,
  
     (RTCSMIB_NODE_PTR)&MIBNODE_snmpEnableAuthenTraps,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ,
     NULL,
     MIB_instance_zero, ASN1_TYPE_Counter,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpOutTraps,
     NULL
  };
  
  const RTCSMIB_NODE MIBNODE_snmpEnableAuthenTraps = {
     30,
  
     NULL,
     NULL,
     (RTCSMIB_NODE_PTR)&MIBNODE_snmp,
  
     RTCSMIB_ACCESS_READ | RTCSMIB_ACCESS_WRITE,
     NULL,
     MIB_instance_zero, ASN1_TYPE_INTEGER,
     (RTCSMIB_VALUE_PTR)&MIBVALUE_snmpEnableAuthenTraps,
     MIB_set_snmpEnableAuthenTraps
  };
  
  
  static boolean MIB_instance_ipAddrEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uchar   ipAdEntAddr[4];
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[3])) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.ipAdEntAddr[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipAdEntAddr[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipAdEntAddr[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipAdEntAddr[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipAdEntAddr[3])) return FALSE;
           if(index.ipAdEntAddr[3] < 255)
              index.ipAdEntAddr[3]++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.ipAdEntAddr[0] = 0;
        index.ipAdEntAddr[1] = 0;
        index.ipAdEntAddr[2] = 0;
        index.ipAdEntAddr[3] = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipAdEntAddr[3])) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  static boolean MIB_instance_ifEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uint_32 ifIndex;
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read32(mib, &index.ifIndex)) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.ifIndex = 0;
        } else {
           if (!RTCSMIB_id_read32(mib, &index.ifIndex)) return FALSE;
           if(index.ifIndex < 0xffffffff) // 4294967295
              index.ifIndex++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.ifIndex = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write32 (mib, index.ifIndex)) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  static boolean MIB_instance_udpEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uchar   udpLocalAddress[4];
        uint_32 udpLocalPort;
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[3])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read32(mib, &index.udpLocalPort)) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.udpLocalAddress[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.udpLocalAddress[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.udpLocalAddress[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.udpLocalAddress[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.udpLocalAddress[3])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.udpLocalPort = 0;
        } else {
           if (!RTCSMIB_id_read32(mib, &index.udpLocalPort)) return FALSE;
           if(index.udpLocalPort < 0xffffffff) // 4294967295
              index.udpLocalPort++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.udpLocalAddress[0] = 0;
        index.udpLocalAddress[1] = 0;
        index.udpLocalAddress[2] = 0;
        index.udpLocalAddress[3] = 0;
        index.udpLocalPort = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.udpLocalAddress[3])) return FALSE;
        if (!RTCSMIB_id_write32 (mib, index.udpLocalPort)) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  static boolean MIB_instance_ipRouteEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uchar   ipRouteDest[4];
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[3])) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.ipRouteDest[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipRouteDest[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipRouteDest[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipRouteDest[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipRouteDest[3])) return FALSE;
           if(index.ipRouteDest[3] < 255)
              index.ipRouteDest[3]++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.ipRouteDest[0] = 0;
        index.ipRouteDest[1] = 0;
        index.ipRouteDest[2] = 0;
        index.ipRouteDest[3] = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipRouteDest[3])) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  static boolean MIB_instance_tcpConnEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uchar   tcpConnLocalAddress[4];
        uint_32 tcpConnLocalPort;
        uchar   tcpConnRemAddress[4];
        uint_32 tcpConnRemPort;
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[3])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read32(mib, &index.tcpConnLocalPort)) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[3])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read32(mib, &index.tcpConnRemPort)) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.tcpConnLocalAddress[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnLocalAddress[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnLocalAddress[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnLocalAddress[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnLocalAddress[3])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnLocalPort = 0;
        } else {
           if (!RTCSMIB_id_read32(mib, &index.tcpConnLocalPort)) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnRemAddress[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnRemAddress[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnRemAddress[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnRemAddress[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.tcpConnRemAddress[3])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.tcpConnRemPort = 0;
        } else {
           if (!RTCSMIB_id_read32(mib, &index.tcpConnRemPort)) return FALSE;
           if(index.tcpConnRemPort < 0xffffffff) // 4294967295
              index.tcpConnRemPort++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.tcpConnLocalAddress[0] = 0;
        index.tcpConnLocalAddress[1] = 0;
        index.tcpConnLocalAddress[2] = 0;
        index.tcpConnLocalAddress[3] = 0;
        index.tcpConnLocalPort = 0;
        index.tcpConnRemAddress[0] = 0;
        index.tcpConnRemAddress[1] = 0;
        index.tcpConnRemAddress[2] = 0;
        index.tcpConnRemAddress[3] = 0;
        index.tcpConnRemPort = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnLocalAddress[3])) return FALSE;
        if (!RTCSMIB_id_write32 (mib, index.tcpConnLocalPort)) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.tcpConnRemAddress[3])) return FALSE;
        if (!RTCSMIB_id_write32 (mib, index.tcpConnRemPort)) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  static boolean MIB_instance_ipNetToMediaEntry
     (
        RTCSMIB_WALK_PTR     mib,
        uint_32              op,
        boolean (_CODE_PTR_  find)(uint_32, pointer, pointer _PTR_),
        boolean _PTR_        found,
        pointer _PTR_        instance
     )
  { /* Body */
     struct {
        uint_32 ipNetToMediaIfIndex;
        uchar   ipNetToMediaNetAddress[4];
     } index;
  
     *found = FALSE;
     *instance = NULL;
  
     switch (op) {
  
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
  
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read32(mib, &index.ipNetToMediaIfIndex)) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[0])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[1])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[2])) return FALSE;
        if (mib->inlen == 0) break;
        if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[3])) return FALSE;
        if (mib->inlen != 0) break;
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        if (mib->inlen == 0) {
           index.ipNetToMediaIfIndex = 0;
        } else {
           if (!RTCSMIB_id_read32(mib, &index.ipNetToMediaIfIndex)) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipNetToMediaNetAddress[0] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[0])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipNetToMediaNetAddress[1] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[1])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipNetToMediaNetAddress[2] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[2])) return FALSE;
        } /* Endif */
        if (mib->inlen == 0) {
           index.ipNetToMediaNetAddress[3] = 0;
        } else {
           if (!RTCSMIB_id_read8(mib, &index.ipNetToMediaNetAddress[3])) return FALSE;
           if(index.ipNetToMediaNetAddress[3] < 255)
              index.ipNetToMediaNetAddress[3]++;
        } /* Endif */
        *found = find(op, &index, instance);
        break;
  
     case RTCSMIB_OP_GETFIRST:
        index.ipNetToMediaIfIndex = 0;
        index.ipNetToMediaNetAddress[0] = 0;
        index.ipNetToMediaNetAddress[1] = 0;
        index.ipNetToMediaNetAddress[2] = 0;
        index.ipNetToMediaNetAddress[3] = 0;
        *found = find(RTCSMIB_OP_GETNEXT, &index, instance);
        break;
     } /* Endswitch */
  
     if (*found && (op != RTCSMIB_OP_SET)) {
        if (!RTCSMIB_id_write32 (mib, index.ipNetToMediaIfIndex)) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[0])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[1])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[2])) return FALSE;
        if (!RTCSMIB_id_write8  (mib, index.ipNetToMediaNetAddress[3])) return FALSE;
     } /* Endif */
  
     return TRUE;
  } /* Endbody */
  
  
  #endif
  
  
  /********************************************************/
  
  #if RTCSCFG_ENABLE_SNMP && RTCSCFG_ENABLE_IP4
  
  #include <rtcs_prv.h>
  #include "tcpip.h"
  #include "ip_prv.h"
  #include "arp_prv.h"
  #include "tcp_prv.h"
  #include "udp_prv.h"
  
  extern boolean MIB_find_ifEntry(uint_32, pointer, pointer _PTR_);
  extern uint_32 MIB_get_ifIndex (pointer interface);
  extern uint_32 MIB_get_sysUpTime(pointer);
  
  static uchar IpAddress[4];
  
  static uint_32 MIB_get_snmpInPkts(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->COMMON.ST_RX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutPkts(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->COMMON.ST_TX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInBadVersions(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_BAD_VERSION);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInBadCommunityNames(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_BAD_COMMUNITY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInASNParseErrs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_BAD_PARSE);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInTotalReqVars(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_VAR_GETS);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInTotalSetVars(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_VAR_SETS);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInGetRequests(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_GETREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInGetNexts(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_GETNEXTREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInSetRequests(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_SETREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInGetResponses(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_RESPONSE);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpInTraps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_RX_TRAP);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutTooBigs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_TOOBIG);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutNoSuchNames(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_NOSUCHNAME);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutBadValues(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_BADVALUE);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutGenErrs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_GENERR);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutGetRequests(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_GETREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutGetNexts(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_GETNEXTREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutSetRequests(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_SETREQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutGetResponses(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_RESPONSE);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_snmpOutTraps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_SNMP_STATS
      SNMP_STATS_PTR    SNMP_stats_ptr   = SNMP_get_data();
      return(SNMP_stats_ptr->ST_TX_TRAP);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_udpNoPorts(pointer dummy)
  {
      #if RTCSCFG_ENABLE_UDP_STATS    
      UDP_STATS_PTR    UDP_stats_ptr   = UDP_stats();
      return(UDP_stats_ptr->ST_RX_NO_PORT);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_udpOutDatagrams(pointer dummy)
  {
      #if RTCSCFG_ENABLE_UDP_STATS    
      UDP_STATS_PTR    UDP_stats_ptr   = UDP_stats();
      return(UDP_stats_ptr->COMMON.ST_TX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_tcpActiveOpens(pointer dummy)
  {
      #if RTCSCFG_ENABLE_TCP_STATS
      TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
      return(TCP_stats_ptr->ST_CONN_ACTIVE);
      #else
      return(0);  
      #endif
  }
   
  static uint_32 MIB_get_tcpAttemptFails(pointer dummy)
  {
      #if RTCSCFG_ENABLE_TCP_STATS
      TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
      return(TCP_stats_ptr->ST_CONN_FAILED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_tcpEstabResets(pointer dummy)
  {
      #if RTCSCFG_ENABLE_TCP_STATS
      TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
      return(TCP_stats_ptr->ST_CONN_RESET);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_tcpInSegs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_TCP_STATS
      TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
      return(TCP_stats_ptr->COMMON.ST_RX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_tcpRetransSegs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_TCP_STATS
      TCP_STATS_PTR    TCP_stats_ptr   = TCP_stats();
      return(TCP_stats_ptr->ST_TX_DATA_DUP);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_tcpRtoMin(pointer dummy)
  {
      return(TCP_RTO_MIN);
  }
  
  static uint_32 MIB_get_tcpRtoMax(pointer dummy)
  {
      return(2 * TCP_MSL);
  }
  
  static uint_32 MIB_get_icmpInMsgs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->COMMON.ST_RX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInErrors(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->COMMON.ST_RX_DISCARDED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInDestUnreachs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_DESTUNREACH);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInTimeExcds(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_TIMEEXCEED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInParmProbs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_PARMPROB);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInSrcQuenchs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_SRCQUENCH);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInRedirects(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_REDIRECT);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInEchos(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_ECHO_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInEchoReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_ECHO_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInTimestamps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_TIME_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInTimestampReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_TIME_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInAddrMasks(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_INFO_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpInAddrMaskReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_RX_INFO_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutMsgs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->COMMON.ST_TX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutErrors(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->COMMON.ST_TX_DISCARDED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutDestUnreachs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_DESTUNREACH);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutTimeExcds(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_TIMEEXCEED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutParmProbs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_PARMPROB);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutSrcQuenchs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_SRCQUENCH);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutRedirects(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_REDIRECT);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutEchos(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_ECHO_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutEchoReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_ECHO_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutTimestamps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_TIME_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutTimestampReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_TIME_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutAddrMasks(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_INFO_REQ);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_icmpOutAddrMaskReps(pointer dummy)
  {
      #if RTCSCFG_ENABLE_ICMP_STATS
      ICMP_STATS_PTR    ICMP_stats_ptr   = ICMP_stats();
      return(ICMP_stats_ptr->ST_TX_INFO_REPLY);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipReasmTimeout(pointer dummy)
  {
      return(IPREASM_TTL);
  }
  
  static uint_32 MIB_get_ipInReceives(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->COMMON.ST_RX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipInHdrErrors(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_HDR_ERRORS);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipInAddrErrors(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_ADDR_ERRORS);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipForwDatagrams(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_FORWARDED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipInUnknownProtos(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_NO_PROTO);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipInDiscards(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->COMMON.ST_RX_MISSED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipInDelivers(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_DELIVERED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipOutRequests(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->COMMON.ST_TX_TOTAL);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipOutDiscards(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->COMMON.ST_TX_MISSED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipReasmReqds(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_FRAG_RECVD);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipReasmOKs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_FRAG_REASMD);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipReasmFails(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_RX_FRAG_DISCARDED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipFragOKs(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_TX_FRAG_FRAGD);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipFragFails(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_TX_FRAG_DISCARDED);
      #else
      return(0);  
      #endif
  }
  
  static uint_32 MIB_get_ipFragCreates(pointer dummy)
  {
      #if RTCSCFG_ENABLE_IP_STATS
      IP_STATS_PTR    IP_stats_ptr   = IP_stats();
      return(IP_stats_ptr->ST_TX_FRAG_SENT);
      #else
      return(0);  
      #endif
  }
  
  uint_32 MIB_get_sysUpTime (pointer dummy)
  { /* Body */
     TIME_STRUCT uptime;
     _time_get_elapsed(&uptime);
     return (uptime.SECONDS * 100) + (uptime.MILLISECONDS / 10);
  } /* Endbody */
  
  static uint_32 MIB_set_dispstr
     (
        uchar_ptr _PTR_ dest,
        uchar_ptr       varptr,
        uint_32         varlen
     )
  { /* Body */
     uchar_ptr dispstr = NULL;
  
     /* SIZE for DisplayString in MIB is between 0 to 255 */
     if ((varlen + 1) >= 255)
        return SNMP_ERROR_wrongLength;
  
     if (varlen) {
        dispstr = RTCS_mem_alloc(varlen+1);
        if (!dispstr) {
           return SNMP_ERROR_resourceUnavailable;
        } /* Endif */
        _mem_copy(varptr, dispstr, varlen);
        dispstr[varlen] = '\0';
     } /* Endif */
  
     if (*dest) {
        _mem_free(*dest);
     } /* Endif */
  
     *dest = dispstr;
     return SNMP_ERROR_noError;
  
  } /* Endbody */
  
  static uint_32 MIB_set_sysContact (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysContact.PARAM), varptr, varlen);
  } /* Endbody */
  
  static uint_32 MIB_set_sysName (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysName.PARAM), varptr, varlen);
  } /* Endbody */
  
  static uint_32 MIB_set_sysLocation (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     return MIB_set_dispstr((unsigned char **)(&MIBVALUE_sysLocation.PARAM), varptr, varlen);
  } /* Endbody */
  
  
  struct MIB_get_ifNumber_struct {
     uint_32                 current_index;
     IP_CFG_STRUCT_PTR       IP_cfg_ptr;
     IP_ROUTE_DIRECT_PTR     direct;
  };
  
  static boolean MIB_get_ifNumber_test2
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                  route = node_data;
     struct MIB_get_ifNumber_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        if (testdata->direct == route->DIRECT) {
           testdata->current_index++;
        } /* Endif */
  
        if (testdata->direct->NETIF == route->DIRECT->NETIF) {
           return TRUE;
        }
     } /* Endif */
  
     return FALSE;
  
  } /* Endbody */
  
  static boolean MIB_get_ifNumber_test1
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                  route = node_data;
     struct MIB_get_ifNumber_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        testdata->direct = route->DIRECT;
        IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifNumber_test2,
           testdata);
     } /* Endif */
  
     return FALSE;
  } /* Body */
  
  static uint_32 MIB_get_ifNumber (pointer dummy)
  { /* Body */
     IP_CFG_STRUCT_PTR                IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_get_ifNumber_struct   testdata;
  
     testdata.current_index  = 0;
     testdata.IP_cfg_ptr     = IP_cfg_ptr;
     testdata.direct         = NULL;
  
     IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifNumber_test1, &testdata);
  
     return testdata.current_index;
  
  } /* Endbody */
  
  struct MIB_get_ifif_struct {
     uint_32                 current_index;
     IP_CFG_STRUCT_PTR       IP_cfg_ptr;
     IP_ROUTE_DIRECT_PTR     direct;
     IP_IF_PTR               interface;
     uint_32                 ifindex;
  };
  
  static boolean MIB_get_ifif_test2
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                     route = node_data;
     struct MIB_get_ifif_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        if (testdata->direct == route->DIRECT) {
           testdata->current_index++;
           if (testdata->ifindex == testdata->current_index) {
              testdata->interface = testdata->direct->NETIF;
              return TRUE;
           } /* Endif */
        } /* Endif */
  
        if (testdata->direct->NETIF == route->DIRECT->NETIF) {
           return TRUE;
        }
     } /* Endif */
  
     return FALSE;
  
  } /* Endbody */
  
  static boolean MIB_get_ifif_test1
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                     route = node_data;
     struct MIB_get_ifif_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        testdata->direct = route->DIRECT;
        IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifif_test2,
           testdata);
        if (testdata->interface) {
           return TRUE;
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Body */
  
  static pointer MIB_get_ifif (uint_32 ifindex)
  { /* Body */
     IP_CFG_STRUCT_PTR          IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_get_ifif_struct testdata;
  
     testdata.current_index  = 0;
     testdata.IP_cfg_ptr     = IP_cfg_ptr;
     testdata.direct         = NULL;
     testdata.ifindex        = ifindex;
     testdata.interface      = NULL;
  
     IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifif_test1, &testdata);
  
     return testdata.interface;
  } /* Endbody */
  
  struct MIB_get_ifIndex_struct {
     uint_32                 current_index;
     IP_CFG_STRUCT_PTR       IP_cfg_ptr;
     IP_ROUTE_DIRECT_PTR     direct;
     IP_IF_PTR               interface;
     uint_32                 ifindex;
  };
  
  static boolean MIB_get_ifIndex_test2
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                        route = node_data;
     struct MIB_get_ifIndex_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        if (testdata->direct == route->DIRECT) {
           testdata->current_index++;
           if (testdata->interface == testdata->direct->NETIF) {
              testdata->ifindex = testdata->current_index;
              return TRUE;
           } /* Endif */
        } /* Endif */
  
        if (testdata->direct->NETIF == route->DIRECT->NETIF) {
           return TRUE;
        }
     } /* Endif */
  
     return FALSE;
  
  } /* Endbody */
  
  static boolean MIB_get_ifIndex_test1
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     IP_ROUTE_PTR                        route = node_data;
     struct MIB_get_ifIndex_struct _PTR_ testdata = data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == RTCS_IF_LOCALHOST_PRV)
     {
        testdata->direct = route->DIRECT;
        IPRADIX_walk(&testdata->IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifIndex_test2,
           testdata);
        if (testdata->ifindex) {
           return TRUE;
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Body */
  
  uint_32 MIB_get_ifIndex (pointer interface)
  { /* Body */
     IP_CFG_STRUCT_PTR             IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_get_ifIndex_struct testdata;
  
     testdata.current_index  = 0;
     testdata.IP_cfg_ptr     = IP_cfg_ptr;
     testdata.direct         = NULL;
     testdata.ifindex        = 0;
     testdata.interface      = interface;
  
     IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ifIndex_test1, &testdata);
  
     return testdata.ifindex;
  } /* Endbody */
  
  static uint_32 MIB_get_ifType (pointer interface) {return ((IP_IF_PTR)interface)->SNMP_IF_TYPE;}
  static uint_32 MIB_get_ifMtu  (pointer interface) {return ((IP_IF_PTR)interface)->MTU;}
  
  static uint_32 MIB_get_ifSpeed (pointer interface)
  { /* Body */
     switch (((IP_IF_PTR)interface)->SNMP_IF_TYPE) {
     case IPIFTYPE_ETHERNET:     return 10000000;
     case IPIFTYPE_FASTETHERNET: return 100000000;
     default:                    return 0;
     } /* Endswitch */
  } /* Endbody */
  
  static uchar_ptr MIB_get_ifPhysAddress (pointer interface, uint_32 _PTR_ len)
  { /* Body */
     *len = ((IP_IF_PTR)interface)->DEV_ADDRLEN;
     return ((IP_IF_PTR)interface)->DEV_ADDR;
  } /* Endbody */
  
  #if RTCSCFG_ENABLE_IPIF_STATS
  static uint_32 MIB_get_ifInOctets      (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_OCTETS;}
  static uint_32 MIB_get_ifInUcastPkts   (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_UNICAST;}
  static uint_32 MIB_get_ifInNUcastPkts  (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_RX_MULTICAST + ((IP_IF_PTR)interface)->STATS.ST_RX_BROADCAST;}
  static uint_32 MIB_get_ifInDiscards    (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_RX_MISSED;}
  static uint_32 MIB_get_ifInErrors      (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_RX_ERRORS;}
  static uint_32 MIB_get_ifOutOctets     (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_OCTETS;}
  static uint_32 MIB_get_ifOutUcastPkts  (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_UNICAST;}
  static uint_32 MIB_get_ifOutNUcastPkts (pointer interface) {return ((IP_IF_PTR)interface)->STATS.ST_TX_MULTICAST + ((IP_IF_PTR)interface)->STATS.ST_TX_BROADCAST;}
  static uint_32 MIB_get_ifOutDiscards   (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_TX_MISSED;}
  static uint_32 MIB_get_ifOutErrors     (pointer interface) {return ((IP_IF_PTR)interface)->STATS.COMMON.ST_TX_ERRORS;}
  #else
  static uint_32 MIB_get_ifInOctets      (pointer interface) {return 0;}
  static uint_32 MIB_get_ifInUcastPkts   (pointer interface) {return 0;}
  static uint_32 MIB_get_ifInNUcastPkts  (pointer interface) {return 0;}
  static uint_32 MIB_get_ifInDiscards    (pointer interface) {return 0;}
  static uint_32 MIB_get_ifInErrors      (pointer interface) {return 0;}
  static uint_32 MIB_get_ifOutOctets     (pointer interface) {return 0;}
  static uint_32 MIB_get_ifOutUcastPkts  (pointer interface) {return 0;}
  static uint_32 MIB_get_ifOutNUcastPkts (pointer interface) {return 0;}
  static uint_32 MIB_get_ifOutDiscards   (pointer interface) {return 0;}
  static uint_32 MIB_get_ifOutErrors     (pointer interface) {return 0;}
  #endif
  
  static RTCSMIB_NODE_PTR MIB_get_ifSpecific (pointer interface)
  { /* Body */
     switch (((IP_IF_PTR)interface)->SNMP_IF_TYPE) {
     default: return NULL;
     } /* Endswitch */
  } /* Endbody */
  
  boolean MIB_find_ifEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     uint_32           ifindex = *(uint_32_ptr)index;
     pointer           interface;
  
     if ((op == RTCSMIB_OP_GETNEXT) && (ifindex == 0)) {
        ifindex = 1;
     } /* Endif */
  
     interface = MIB_get_ifif(ifindex);
     if (!interface) {
        return FALSE;
     } /* Endif */
     *(uint_32_ptr)index = ifindex;
     *instance = interface;
     return TRUE;
  
  } /* Endbody */
  
  static uint_32 MIB_set_ifAdminStatus (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     int_32 varval = RTCSMIB_int_read(varptr, varlen);
     switch (varval) {
     case 1:  return SNMP_ERROR_noError;
     case 2:
     case 3:  return SNMP_ERROR_inconsistentValue;
     default: return SNMP_ERROR_wrongValue;
     } /* Endswitch */
  } /* Endbody */
  
  static uint_32 MIB_get_ipForwarding (pointer dummy) {return _IP_forward ? 1 : 2;}
  
  static uint_32 MIB_get_ipDefaultTTL (pointer dummy)
  { /* Body */
     IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
     return IP_cfg_ptr->DEFAULT_TTL;
  } /* Endbody */
  
  static uchar_ptr MIB_get_ipAdEntAddr (pointer ipaddr, uint_32 _PTR_ len)
  { /* Body */
     IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
     htonl(IpAddress, ipaddr_ptr->ADDRESS);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_ipAdEntIfIndex (pointer ipaddr)
  { /* Body */
     IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
     return MIB_get_ifIndex(ipaddr_ptr->NETIF);
  } /* Endbody */
  
  static uchar_ptr MIB_get_ipAdEntNetMask (pointer ipaddr, uint_32 _PTR_ len)
  { /* Body */
     IP_ROUTE_DIRECT_PTR ipaddr_ptr = ipaddr;
     _ip_address         netmask;
  
     if (IP_get_netmask(ipaddr_ptr->NETIF, ipaddr_ptr->ADDRESS, &netmask)) {
        htonl(IpAddress, netmask);
        *len = 4;
        return IpAddress;
     } /* Endif */
  
     htonl(IpAddress, 0xFFFFFFFF);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  struct MIB_get_ipRouteDest_struct {
     _ip_address             netaddr;
     _ip_address             netmask;
     pointer                 iproute;
  };
  
  static boolean MIB_get_ipRouteDest_test
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     struct MIB_get_ipRouteDest_struct _PTR_   testdata = data;
     IP_ROUTE_PTR                              route = node_data;
     IP_ROUTE_INDIRECT_PTR                     indirect;
     IP_ROUTE_DIRECT_PTR                       direct;
  
     if (route && route->DIRECT) {
        direct = route->DIRECT;
        do {
           if (direct == testdata->iproute) {
              testdata->netaddr = route->NODE.IP;
              testdata->netmask = route->NODE.MASK;
              return TRUE;
           } /* Endif */
           direct = direct->NEXT;
        } while (direct != route->DIRECT);
     } /* Endif */
  
     if (route && route->INDIRECT) {
        indirect = route->INDIRECT;
        do {
           if (indirect == testdata->iproute) {
              testdata->netaddr = route->NODE.IP;
              testdata->netmask = route->NODE.MASK;
              return TRUE;
           } /* Endif */
           indirect = indirect->NEXT;
        } while(indirect != route->INDIRECT);
     } /* Endif */
  
     return FALSE;
  } /* Endbody */
  
  
  static uchar_ptr MIB_get_ipRouteDest (pointer iproute, uint_32 _PTR_ len)
  { /* Body */
     IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_get_ipRouteDest_struct   testdata;
  
     testdata.netaddr = INADDR_ANY;
     testdata.iproute = iproute;
  
     IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ipRouteDest_test, &testdata);
  
     htonl(IpAddress, testdata.netaddr);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  
  static uint_32 MIB_get_ipRouteIfIndex (pointer iproute)
  { /* Body */
     IP_ROUTE_DIRECT_PTR                    direct = iproute;
     IP_ROUTE_INDIRECT_PTR                  indirect = iproute;
     IP_IF_PTR                              ip_interface;
     _ip_address                            if_ip;
  
     /* If it is a directly connected route */
     if (((IP_ROUTE_INDIRECT_PTR) iproute)->IS_DIRECT) {
        return MIB_get_ifIndex(direct->NETIF);
     } /* Endif */
  
     /* If it is an indirectly connected route */
     if_ip = IP_route_find(indirect->GATEWAY, IPROUTEOPT_GATE);
     if (if_ip != INADDR_ANY) {
        ip_interface = IP_find_if(if_ip);
        if (ip_interface) {
           return MIB_get_ifIndex(ip_interface);
        } /* Endif */
     } /* Endif */
  
     return 0;
  
  } /* Endbody */
  
  
  static uchar_ptr MIB_get_ipRouteNextHop (pointer iproute, uint_32 _PTR_ len)
  { /* Body */
     IP_ROUTE_INDIRECT_PTR iproute_ptr = iproute;
     htonl(IpAddress, iproute_ptr->GATEWAY);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_ipRouteType (pointer iproute)
  { /* Body */
     IP_ROUTE_INDIRECT_PTR iproute_ptr = iproute;
     if (iproute_ptr->IS_DIRECT)   return 3;
     else                          return 4;
  } /* Endbody */
  
  static uchar_ptr MIB_get_ipRouteMask (pointer iproute, uint_32 _PTR_ len)
  { /* Body */
     IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_get_ipRouteDest_struct   testdata;
  
     testdata.netmask = INADDR_ANY;
     testdata.iproute = iproute;
  
     IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_get_ipRouteDest_test, &testdata);
  
     htonl(IpAddress, testdata.netmask);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_ipNetToMediaIfIndex (pointer arp)
  { /* Body */
     ARP_ENTRY_PTR arp_ptr = arp;
     return MIB_get_ifIndex(arp_ptr->HEAD);
  } /* Endbody */
  
  static uchar_ptr MIB_get_ipNetToMediaPhysAddress (pointer arp, uint_32 _PTR_ len)
  { /* Body */
     ARP_ENTRY_PTR arp_ptr = arp;
     *len = 6;
     return arp_ptr->LADDR;
  } /* Endbody */
  
  static uchar_ptr MIB_get_ipNetToMediaNetAddress (pointer arp, uint_32 _PTR_ len)
  { /* Body */
     ARP_ENTRY_PTR arp_ptr = arp;
     htonl(IpAddress, arp_ptr->PADDR);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  struct MIB_find_ipAddrEntry_struct {
     _ip_address             addr;
     IP_ROUTE_DIRECT_PTR     direct;
     _ip_address             netaddr;
     IP_IF_PTR               localhost;
  };
  
  static boolean MIB_find_ipAddrEntry_test
     (
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
     IP_ROUTE_PTR                              route = node_data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route->DIRECT && route->DIRECT->DESTIF == testdata->localhost) {
        if (route->DIRECT->ADDRESS == testdata->addr) {
           testdata->direct = route->DIRECT;
           return TRUE;
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Endbody */
  
  static boolean MIB_find_ipAddrEntry_walk
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
     IP_ROUTE_PTR                              route = node_data;
  
     /* Check only leaves, which have a DESTIF of LOCALHOST */
     if (route && route->DIRECT &&
        route->DIRECT->DESTIF == testdata->localhost)
     {
        if (route->DIRECT->ADDRESS >= testdata->addr) {
           if (testdata->direct == NULL ||
              route->DIRECT->ADDRESS < testdata->direct->ADDRESS)
           {
              testdata->addr = route->DIRECT->ADDRESS;
              testdata->direct = route->DIRECT;
           } /* Endif */
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Endbody */
  
  boolean MIB_find_ipAddrEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_find_ipAddrEntry_struct  testdata;
  
     struct {
        uchar   ipAdEntAddr[4];
     } _PTR_ realindex = index;
  
     testdata.addr        = ntohl(realindex->ipAdEntAddr);
     testdata.localhost   = RTCS_IF_LOCALHOST_PRV;
     testdata.direct      = NULL;
  
     switch (op) {
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
        IPRADIX_findbest(&IP_cfg_ptr->ROUTE_ROOT.NODE, testdata.addr,
           MIB_find_ipAddrEntry_test, &testdata);
        break;
  
     case RTCSMIB_OP_GETNEXT:
        IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_find_ipAddrEntry_walk, &testdata);
        break;
     } /* Endswitch */
  
     if (!testdata.direct) {
        return FALSE;
     } /* Endif */
  
     htonl(realindex->ipAdEntAddr, testdata.direct->ADDRESS);
     *instance = testdata.direct;
     return TRUE;
  
  } /* Endbody */
  
  static boolean MIB_find_ipRouteEntry_test1
     (
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
     IP_ROUTE_PTR                              route = node_data;
  
     if (route->NODE.IP == testdata->addr) {
        testdata->direct = route->DIRECT;
        if (testdata->direct == NULL) {
           testdata->direct = (IP_ROUTE_DIRECT_PTR)((void _PTR_)route->INDIRECT);
           return TRUE;
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Enbody */
  
  static boolean MIB_find_ipRouteEntry_walk1
     (
        _ip_address    node_ip,
        _ip_address    node_mask,
        pointer        node_data,
        pointer        data
     )
  { /* Body */
     struct MIB_find_ipAddrEntry_struct _PTR_  testdata = data;
     IP_ROUTE_PTR                              route = node_data;
  
     if (route) {
        if (node_ip >= testdata->addr) {
           if (testdata->direct == NULL || node_ip < testdata->netaddr) {
              testdata->netaddr = node_ip;
              testdata->direct = route->DIRECT;
              if (testdata->direct == NULL) {
                 testdata->direct =
                    (IP_ROUTE_DIRECT_PTR)((void _PTR_)route->INDIRECT);
              } /* Endif */
           }  /* Endif */
        } /* Endif */
     } /* Endif */
  
     return FALSE;
  } /* Endbody */
  
  boolean MIB_find_ipRouteEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     IP_CFG_STRUCT_PTR                   IP_cfg_ptr = RTCS_getcfg(IP);
     struct MIB_find_ipAddrEntry_struct  testdata;
     struct {
        uchar   ipRouteDest[4];
     } _PTR_ realindex = index;
  
     testdata.addr = ntohl(realindex->ipRouteDest);
     testdata.direct = NULL;
     testdata.netaddr = INADDR_ANY;
  
     switch (op) {
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
        /* CR 1822 */
        /*
        IPRADIX_findbest(&IP_cfg_ptr->ROUTE_ROOT.NODE, testdata.addr,
           MIB_find_ipRouteEntry_test1, &testdata);
        break;
        */
        /* End CR 1822 */
  
     case RTCSMIB_OP_GETNEXT:
        IPRADIX_walk(&IP_cfg_ptr->ROUTE_ROOT.NODE, MIB_find_ipRouteEntry_walk1, &testdata);
        break;
     } /* Endswitch */
  
     if (!testdata.direct) {
        return FALSE;
     } /* Endif */
  
     htonl(realindex->ipRouteDest, testdata.netaddr);
     *instance = testdata.direct;
     return TRUE;
  
  } /* Endbody */
  
  boolean MIB_find_ipNetToMediaEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     IP_IF_PTR         interface;
     ARP_CFG_PTR       arp_cfg_ptr;
     ARP_ENTRY_PTR     arp_ptr, search_ptr;
     uint_32           ifindex, maxindex, arphash;
     _ip_address       netaddr;
     struct {
        uint_32 ipNetToMediaIfIndex;
        uchar   ipNetToMediaNetAddress[4];
     } _PTR_ realindex = index;
  
     ifindex = realindex->ipNetToMediaIfIndex;
     netaddr = ntohl(realindex->ipNetToMediaNetAddress);
     maxindex = MIB_get_ifNumber(NULL);
  
     arp_ptr = NULL;
     switch (op) {
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
        interface = MIB_get_ifif(ifindex);
        if (!interface) {
           return FALSE;
        } /* Endif */
        arp_cfg_ptr = interface->ARP;
        if (!arp_cfg_ptr) {
           return FALSE;
        } /* Endif */
        for (arp_ptr = arp_cfg_ptr->CACHE[ARPCACHE_HASH(netaddr)];
             arp_ptr;
             arp_ptr = arp_ptr->NEXT) {
           if (arp_ptr->PADDR == netaddr) {
              break;
           } /* Endif */
        } /* Endfor */
        break;
  
     case RTCSMIB_OP_GETNEXT:
        for (; ifindex <= maxindex; ifindex++) {
           interface = MIB_get_ifif(ifindex);
           if (!interface) {
              continue;
           } /* Endif */
           arp_cfg_ptr = interface->ARP;
           if (!arp_cfg_ptr) {
              continue;
           } /* Endif */
  
           for (arphash = 0; arphash < ARPCACHE_SIZE; arphash++) {
              for (search_ptr = arp_cfg_ptr->CACHE[arphash];
                   search_ptr;
                   search_ptr = search_ptr->NEXT) {
                 if (search_ptr->PADDR >= netaddr) {
                    if (arp_ptr == NULL) {
                       arp_ptr = search_ptr;
                    } else if (search_ptr->PADDR < arp_ptr->PADDR) {
                       arp_ptr = search_ptr;
                    } /* Endif */
                 } /* Endif */
              } /* Endfor */
           } /* Endfor */
  
           if (arp_ptr) {
              break;
           } /* Endif */
  
        } /* Endfor */
        break;
  
     } /* Endswitch */
  
     if (!arp_ptr) {
        return FALSE;
     } /* Endif */
  
     realindex->ipNetToMediaIfIndex = ifindex;
     htonl(realindex->ipNetToMediaNetAddress, arp_ptr->PADDR);
     *instance = arp_ptr;
     return TRUE;
  
  } /* Endbody */
  
  uint_32 MIB_set_ipForwarding (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     int_32 varval = RTCSMIB_int_read(varptr, varlen);
     switch (varval) {
     case 1: _IP_forward = TRUE;  return SNMP_ERROR_noError;
     case 2: _IP_forward = FALSE; return SNMP_ERROR_noError;
     default: return SNMP_ERROR_wrongValue;
     } /* Endswitch */
  } /* Endbody */
  
  uint_32 MIB_set_ipDefaultTTL (pointer dummy, uchar_ptr varptr, uint_32 varlen)
  { /* Body */
     IP_CFG_STRUCT_PTR IP_cfg_ptr = RTCS_getcfg(IP);
     int_32            varval = RTCSMIB_int_read(varptr, varlen);
  
     if (varval >= 1 && varval <= 255) {
        IP_cfg_ptr->DEFAULT_TTL = varval;
        return SNMP_ERROR_noError;
     } else {
        return SNMP_ERROR_wrongValue;
     } /* Endif */
  } /* Endbody */
  
  uint_32 MIB_set_ipRouteDest            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteIfIndex         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMetric1         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMetric2         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMetric3         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMetric4         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMetric5         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteNextHop         (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteType            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteAge             (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipRouteMask            (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipNetToMediaIfIndex    (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipNetToMediaPhysAddress(pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipNetToMediaNetAddress (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  uint_32 MIB_set_ipNetToMediaType       (pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  
  static uint_32 MIB_get_tcpPassiveOpens (pointer dummy)
  { /* Body */
  #if RTCSCFG_ENABLE_TCP_STATS
     TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
     TCB_STRUCT_PTR       tcb_ptr;
     uint_32              var;
  
     var = TCP_cfg_ptr->STATS.ST_CONN_PASSIVE;
     for (tcb_ptr = TCP_cfg_ptr->TCBhead;
          tcb_ptr;
          tcb_ptr = tcb_ptr->next) {
        if (tcb_ptr->state == LISTEN) var--;
     } /* Endfor */
     return var;
  #else
     return 0;
  #endif
  } /* Endbody */
  
  static uint_32 MIB_get_tcpCurrEstab (pointer dummy)
  { /* Body */
     TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
     TCB_STRUCT_PTR       tcb_ptr;
     uint_32              var;
  
     var = 0;
     for (tcb_ptr = TCP_cfg_ptr->TCBhead;
          tcb_ptr;
          tcb_ptr = tcb_ptr->next) {
        if (tcb_ptr->state == ESTABLISHED) var++;
     } /* Endfor */
     return var;
  
  } /* Endbody */
  
  static  uint_32 MIB_get_tcpOutSegs (pointer dummy)
  { /* Body */
   #if RTCSCFG_ENABLE_TCP_STATS
    TCP_STATS_PTR TCP_stats_ptr = TCP_stats();
     return TCP_stats_ptr->COMMON.ST_TX_TOTAL - TCP_stats_ptr->ST_TX_DATA_DUP;
  #else
     return 0;
  #endif
  } /* Endbody */
  
  static uint_32 MIB_get_tcpConnState (pointer tcb)
  { /* Body */
     switch (((TCB_STRUCT_PTR)tcb)->state) {
     case LISTEN:         return 2;
     case SYN_SENT:       return 3;
     case SYN_RECEIVED:   return 4;
     case ESTABLISHED:    return 5;
     case FINWAIT_1:      return 6;
     case FINWAIT_2:      return 7;
     case CLOSE_WAIT:     return 8;
     case LAST_ACK:       return 9;
     case CLOSING:        return 10;
     case TIME_WAIT:      return 11;
     default:             return 1;
     } /* Endswitch */
  } /* Endbody */
  
  static uchar_ptr MIB_get_tcpConnLocalAddress (pointer tcb, uint_32 _PTR_ len)
  { /* Body */
     TCB_STRUCT_PTR tcb_ptr = tcb;
     htonl(IpAddress, tcb_ptr->local_host);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_tcpConnLocalPort (pointer tcb)
  { /* Body */
     return ((TCB_STRUCT_PTR)tcb)->local_port;
  } /* Endbody */
  
  static uchar_ptr MIB_get_tcpConnRemAddress (pointer tcb, uint_32 _PTR_ len)
  { /* Body */
     TCB_STRUCT_PTR tcb_ptr = tcb;
     htonl(IpAddress, tcb_ptr->remote_host);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_tcpConnRemPort (pointer tcb)
  { /* Body */
     return ((TCB_STRUCT_PTR)tcb)->remote_port;
  } /* Endbody */
  
  boolean MIB_find_tcpConnEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     TCP_CFG_STRUCT_PTR   TCP_cfg_ptr = RTCS_getcfg(TCP);
     TCB_STRUCT_PTR       tcb_ptr, search_ptr;
     _ip_address          locaddr, remaddr;
     uint_16              locport, remport;
     struct {
        uchar   tcpConnLocalAddress[4];
        uint_32 tcpConnLocalPort;
        uchar   tcpConnRemAddress[4];
        uint_32 tcpConnRemPort;
     } _PTR_ realindex = index;
  
     locaddr = ntohl(realindex->tcpConnLocalAddress);
     locport = realindex->tcpConnLocalPort;
     remaddr = ntohl(realindex->tcpConnRemAddress);
     remport = realindex->tcpConnRemPort;
  
     tcb_ptr = NULL;
     switch (op) {
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
        for (tcb_ptr = TCP_cfg_ptr->TCBhead;
             tcb_ptr;
             tcb_ptr = tcb_ptr->next) {
  
           if ((tcb_ptr->local_host  == locaddr)
            && (tcb_ptr->local_port  == locport)
            && (tcb_ptr->remote_host == remaddr)
            && (tcb_ptr->remote_port == remport)) {
  
              break;
           } /* Endif */
        } /* Endfor */
        break;
  
     case RTCSMIB_OP_GETNEXT:
        for (search_ptr = TCP_cfg_ptr->TCBhead;
             search_ptr;
             search_ptr = search_ptr->next) {
  
           if ( (search_ptr->local_host >  locaddr)
  
            || ((search_ptr->local_host == locaddr)
             && (search_ptr->local_port >  locport))
  
            || ((search_ptr->local_host  == locaddr)
             && (search_ptr->local_port  == locport)
             && (search_ptr->remote_host >  remaddr))
  
            || ((search_ptr->local_host  == locaddr)
             && (search_ptr->local_port  == locport)
             && (search_ptr->remote_host == remaddr)
             && (search_ptr->remote_port >= remport)) ) {
  
              if (tcb_ptr == NULL) {
                 tcb_ptr = search_ptr;
              } else if ( (search_ptr->local_host <  tcb_ptr->local_host)
  
                      || ((search_ptr->local_host == tcb_ptr->local_host)
                       && (search_ptr->local_port <  tcb_ptr->local_port))
  
                      || ((search_ptr->local_host  == tcb_ptr->local_host)
                       && (search_ptr->local_port  == tcb_ptr->local_port)
                       && (search_ptr->remote_host <  tcb_ptr->remote_host))
  
                      || ((search_ptr->local_host  == tcb_ptr->local_host)
                       && (search_ptr->local_port  == tcb_ptr->local_port)
                       && (search_ptr->remote_host == tcb_ptr->remote_host)
                       && (search_ptr->remote_port <  tcb_ptr->remote_port)) ) {
                 tcb_ptr = search_ptr;
              } /* Endif */
           } /* Endif */
        } /* Endfor */
        break;
  
     } /* Endswitch */
  
     if (!tcb_ptr) {
        return FALSE;
     } /* Endif */
  
     htonl(realindex->tcpConnLocalAddress, tcb_ptr->local_host);
     realindex->tcpConnLocalPort = tcb_ptr->local_port;
     htonl(realindex->tcpConnRemAddress, tcb_ptr->remote_host);
     realindex->tcpConnRemPort = tcb_ptr->remote_port;
     *instance = tcb_ptr;
     return TRUE;
  
  } /* Endbody */
  
  static uint_32 MIB_set_tcpConnState(pointer dummy, uchar_ptr varptr, uint_32 varlen) {return SNMP_ERROR_inconsistentValue;}
  
  static uint_32 MIB_get_udpInDatagrams (pointer dummy)
  { /* Body */
  #if RTCSCFG_ENABLE_UDP_STATS
     UDP_STATS_PTR UDP_stats_ptr = UDP_stats();
     return UDP_stats_ptr->COMMON.ST_RX_TOTAL - UDP_stats_ptr->COMMON.ST_RX_DISCARDED;
  #else
     return 0;
  #endif
  } /* Endbody */
  
  static uint_32 MIB_get_udpInErrors (pointer dummy)
  { /* Body */
   #if RTCSCFG_ENABLE_UDP_STATS
    UDP_STATS_PTR UDP_stats_ptr = UDP_stats();
     return UDP_stats_ptr->COMMON.ST_RX_DISCARDED - UDP_stats_ptr->ST_RX_NO_PORT;
  #else
     return 0;
  #endif
  } /* Endbody */
  
  static uchar_ptr MIB_get_udpLocalAddress (pointer ucb, uint_32 _PTR_ len)
  { /* Body */
     UCB_STRUCT_PTR ucb_ptr = ucb;
     htonl(IpAddress, ucb_ptr->IPADDR);
     *len = 4;
     return IpAddress;
  } /* Endbody */
  
  static uint_32 MIB_get_udpLocalPort (pointer ucb)
  { /* Body */
     return ((UCB_STRUCT_PTR)ucb)->PORT;
  } /* Endbody */
  
  boolean MIB_find_udpEntry
     (
        uint_32        op,
        pointer        index,
        pointer _PTR_  instance
     )
  { /* Body */
     UDP_CFG_STRUCT_PTR   UDP_cfg_ptr = RTCS_getcfg(UDP);
     UCB_STRUCT_PTR       ucb_ptr, search_ptr;
     _ip_address          locaddr;
     uint_16              locport;
     struct {
        uchar   udpLocalAddress[4];
        uint_32 udpLocalPort;
     } _PTR_ realindex = index;
  
     locaddr = ntohl(realindex->udpLocalAddress);
     locport = realindex->udpLocalPort;
  
     ucb_ptr = NULL;
     switch (op) {
     case RTCSMIB_OP_GET:
     case RTCSMIB_OP_SET:
        RTCS_LIST_SEARCH(UDP_cfg_ptr->OPEN_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   == locport)) {
              ucb_ptr = search_ptr;
              break;
           } /* Endif */
        } /* End SEARCH */
  
        RTCS_LIST_SEARCH(UDP_cfg_ptr->LBOUND_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   == locport)) {
              ucb_ptr = search_ptr;
              break;
           } /* Endif */
        } /* End SEARCH */
  
        RTCS_LIST_SEARCH(UDP_cfg_ptr->BOUND_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   == locport)) {
              ucb_ptr = search_ptr;
              break;
           } /* Endif */
        } /* End SEARCH */
        break;
     case RTCSMIB_OP_GETNEXT:
        RTCS_LIST_SEARCH(UDP_cfg_ptr->OPEN_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR >  locaddr)
           || ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   >= locport))) {
              if (ucb_ptr == NULL) {
                 ucb_ptr = search_ptr;
              } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                     || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                      && (search_ptr->PORT   <  ucb_ptr->PORT))) {
                 ucb_ptr = search_ptr;
              } /* Endif */
           } /* Endif */
        } /* End SEARCH */
  
        RTCS_LIST_SEARCH(UDP_cfg_ptr->LBOUND_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR >  locaddr)
           || ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   >= locport))) {
              if (ucb_ptr == NULL) {
                 ucb_ptr = search_ptr;
              } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                     || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                      && (search_ptr->PORT   <  ucb_ptr->PORT))) {
                 ucb_ptr = search_ptr;
              } /* Endif */
           } /* Endif */
        } /* End SEARCH */
  
        RTCS_LIST_SEARCH(UDP_cfg_ptr->BOUND_UCB_HEAD, search_ptr) {
           if ((search_ptr->IPADDR >  locaddr)
           || ((search_ptr->IPADDR == locaddr)
            && (search_ptr->PORT   >= locport))) {
              if (ucb_ptr == NULL) {
                 ucb_ptr = search_ptr;
              } else if ((search_ptr->IPADDR <  ucb_ptr->IPADDR)
                     || ((search_ptr->IPADDR == ucb_ptr->IPADDR)
                      && (search_ptr->PORT   <  ucb_ptr->PORT))) {
                 ucb_ptr = search_ptr;
              } /* Endif */
           } /* Endif */
        } /* End SEARCH */
  
        break;
     } /* Endswitch */
  
     if (!ucb_ptr) {
        return FALSE;
     } /* Endif */
  
     htonl(realindex->udpLocalAddress, ucb_ptr->IPADDR);
     realindex->udpLocalPort = ucb_ptr->PORT;
     *instance = ucb_ptr;
     return TRUE;
  
  } /* Endbody */
  
  uint_32 MIB_set_snmpEnableAuthenTraps
     (
        pointer     dummy,
        uchar_ptr   varptr,
        uint_32     varlen
     )
  { /* Body */
     /* CR 850 */
     int_32 varval = RTCSMIB_int_read(varptr, varlen);
     /* End CR 850 */
     switch (varval) {
     case 1:  return SNMP_ERROR_inconsistentValue;
     case 2:  return SNMP_ERROR_noError;
     default: return SNMP_ERROR_wrongValue;
     } /* Endswitch */
  } /* Endbody */
  
  /****************************************************************************/
  
  const RTCSMIB_VALUE MIBVALUE_mib2 = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  /* system */
  const RTCSMIB_VALUE MIBVALUE_system = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysDescr = {
      RTCSMIB_NODETYPE_DISPSTR_PTR,
      (void _PTR_)SNMPCFG_SYSDESCR
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysObjectID = {
      RTCSMIB_NODETYPE_OID_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysUpTime = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_sysUpTime
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysContact = {
      RTCSMIB_NODETYPE_DISPSTR_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysName = {
      RTCSMIB_NODETYPE_DISPSTR_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysLocation = {
      RTCSMIB_NODETYPE_DISPSTR_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_sysServices = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)SNMPCFG_SYSSERVICES
  };
  
  /* interfaces */
  const RTCSMIB_VALUE MIBVALUE_interfaces = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifNumber = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifNumber
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifIndex = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifDescr = {
      RTCSMIB_NODETYPE_DISPSTR_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifType = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifType
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifMtu = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifMtu
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifSpeed = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifSpeed
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifPhysAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ifPhysAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifAdminStatus = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)1
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOperStatus = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)1
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifLastChange = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInOctets = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInOctets
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInUcastPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInUcastPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInNUcastPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInNUcastPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInDiscards = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInDiscards
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifInErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifInUnknownProtos = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutOctets = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutOctets
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutUcastPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutUcastPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutNUcastPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutNUcastPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutDiscards = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutDiscards
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ifOutErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifOutQLen = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ifSpecific = {
      RTCSMIB_NODETYPE_OID_FN,
      (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ifSpecific
  };
  
  /* IP */
  const RTCSMIB_VALUE MIBVALUE_ip = {
      RTCSMIB_NODETYPE_INT_CONST,
      (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ifSpecific
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipForwarding = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ipForwarding
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipDefaultTTL = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_OID_FN_PTR)MIB_get_ipDefaultTTL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInReceives = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInReceives
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInHdrErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInHdrErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInAddrErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInAddrErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipForwDatagrams = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipForwDatagrams
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInUnknownProtos = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInUnknownProtos
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInDelivers = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInDelivers
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipOutRequests = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipOutRequests
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipOutDiscards = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipOutDiscards
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipOutNoRoutes = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipReasmTimeout = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmTimeout
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipReasmReqds = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmReqds
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipReasmOKs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmOKs
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipReasmFails = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipReasmFails
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipFragOKs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragOKs
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipFragFails = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragFails
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipFragCreates = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipFragCreates
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAddrTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAddrEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAdEntAddr = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipAdEntAddr
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAdEntIfIndex = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipAdEntIfIndex
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAdEntNetMask = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipAdEntNetMask
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAdEntBcastAddr = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)1
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipAdEntReasmMaxSize = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)65535
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteDest = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteDest
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteIfIndex = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipRouteIfIndex
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMetric1 = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMetric2 = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMetric3 = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMetric4 = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteNextHop = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteNextHop
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteType = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipRouteType
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteProto = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)2
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteAge = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMask = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipRouteMask
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteMetric5 = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRouteInfo = {
      RTCSMIB_NODETYPE_OID_PTR,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaIfIndex = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaIfIndex
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaPhysAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaPhysAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaNetAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_ipNetToMediaNetAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaType = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)3
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipNetToMediaEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipRoutingDiscards = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmp = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInMsgs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInReceives
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInDestUnreachs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInDestUnreachs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInTimeExcds = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimeExcds
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInParmProbs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInParmProbs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInSrcQuenchs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInSrcQuenchs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInRedirects = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInRedirects
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInEchos = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInEchos
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInEchoReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInEchoReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInTimestamps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimestamps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInTimestampReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInTimestampReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInAddrMasks = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInAddrMasks
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpInAddrMaskReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpInAddrMaskReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutMsgs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutMsgs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutDestUnreachs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutDestUnreachs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutTimeExcds = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimeExcds
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutParmProbs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutParmProbs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutSrcQuenchs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutSrcQuenchs
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutRedirects = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutRedirects
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutEchos = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutEchos
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutEchoReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutEchoReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutTimestamps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimestamps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutTimestampReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutTimestampReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMasks = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutAddrMasks
  };
  
  const RTCSMIB_VALUE MIBVALUE_icmpOutAddrMaskReps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_icmpOutAddrMaskReps
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcp = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpRtoAlgorithm = {
      RTCSMIB_NODETYPE_UINT_CONST,
      (void _PTR_)4
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpRtoMin = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRtoMin
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpRtoMax = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRtoMax 
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpMaxConn = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpActiveOpens = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpActiveOpens
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpPassiveOpens = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpPassiveOpens
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpAttemptFails = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpAttemptFails
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpEstabResets = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpEstabResets
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpCurrEstab = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpCurrEstab
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpInSegs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpInSegs
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpOutSegs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpOutSegs
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpRetransSegs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpRetransSegs
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnState = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnState
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnLocalAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_tcpConnLocalAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnLocalPort = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnLocalPort
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnRemAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_tcpConnRemAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnRemPort = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_tcpConnRemPort
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpConnEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpInErrs = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_tcpOutRsts = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_udp = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpInDatagrams = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpInDatagrams
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpNoPorts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpNoPorts
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpInErrors = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpInErrors
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpOutDatagrams = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpOutDatagrams
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpLocalAddress = {
      RTCSMIB_NODETYPE_OCTSTR_FN,
      (void _PTR_)(RTCSMIB_OCTSTR_FN_PTR)MIB_get_udpLocalAddress
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpLocalPort = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_udpLocalPort
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpTable = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_udpEntry = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_transmission = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmp = {
      RTCSMIB_NODETYPE_INT_CONST,
      NULL
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutPkts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutPkts
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInBadVersions = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInBadVersions
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityNames = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInBadCommunityNames
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInBadCommunityUses = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInASNParseErrs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInASNParseErrs
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInTooBigs = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInNoSuchNames = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInBadValues = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInReadOnlys = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInGenErrs = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInTotalReqVars = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTotalReqVars
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInTotalSetVars = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTotalSetVars
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInGetRequests = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetRequests
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInGetNexts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetNexts
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInSetRequests = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInSetRequests
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInGetResponses = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInGetResponses
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpInTraps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpInTraps
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutTooBigs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutTooBigs
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutNoSuchNames = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutNoSuchNames
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutBadValues = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutBadValues
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutGenErrs = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGenErrs
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutGetRequests = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetRequests
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutGetNexts = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetNexts
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutSetRequests = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutSetRequests
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutGetResponses = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutGetResponses
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpOutTraps = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_snmpOutTraps
  };
  
  const RTCSMIB_VALUE MIBVALUE_snmpEnableAuthenTraps = {
      RTCSMIB_NODETYPE_UINT_CONST,
      NULL  
  };
  
  const RTCSMIB_VALUE MIBVALUE_ipInDiscards = {
      RTCSMIB_NODETYPE_UINT_FN,
      (void _PTR_)(RTCSMIB_UINT_FN_PTR)MIB_get_ipInDiscards
  };
  
  #endif /* RTCSCFG_ENABLE_SNMP  && RTCSCFG_ENABLE_IP4*/
  
  /****************************************************************************/
   
  void MIB1213_init(void)
  {
  #if RTCSCFG_ENABLE_SNMP && RTCSCFG_ENABLE_IP4
     RTCSMIB_mib_add(&MIBNODE_mib2);
  #endif
  }
  
  /* EOF */
  