Cisco-IOS-XE-qfp-stats-oper

This module contains a collection of YANG definitions for QFP statistics operational data. Copyright (c) 2019-2020 by Cisco Syst...

  • Version: 2020-07-01

    Cisco-IOS-XE-qfp-stats-oper@2020-07-01


    
      module Cisco-IOS-XE-qfp-stats-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XE-qfp-stats-oper";
    
        prefix qfp-stats-ios-xe-oper;
    
        import Cisco-IOS-XE-common-types {
          prefix common-types-ios-xe;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import cisco-semver {
          prefix cisco-semver;
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
         Customer Service
    
         Postal: 170 W Tasman Drive
         San Jose, CA 95134
    
         Tel: +1 1800 553-NETS
    
         E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
         for QFP statistics operational data.
         Copyright (c) 2019-2020 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2020-07-01" {
          description "Use extended location";
          reference
            "2.0.0";
    
        }
    
        revision "2020-03-01" {
          description "Initial revision";
          reference
            "1.0.0";
    
        }
    
        cisco-semver:module-version "2.0.0";
        cisco-semver:module-version "1.0.0";
    
        container qfp-stats-oper-data {
          config false;
          description
            "QFP statistics operational data";
          list location {
            key "fru slot bay chassis node";
            description
              "A list of data provider locations";
            leaf fru {
              type common-types-ios-xe:fru-type;
              description
                "Field replaceable unit (FRU) type";
            }
    
            leaf slot {
              type int16;
              description "Slot number";
            }
    
            leaf bay {
              type int16;
              description "Bay number";
            }
    
            leaf chassis {
              type int16;
              description "Chassis number";
            }
    
            leaf node {
              type uint16;
              description "Node number";
            }
    
            container datapath-qfp-stats {
              presence "datapath-qfp-stats";
              description
                "Datapath Quantum Flow Processor(QFP) statistics";
              leaf discontinuity-time {
                type yang:date-and-time;
                description
                  "The time on the most recent occasion at which these
    counters have suffered a discontinuity. If no such discontinuities
    have occurred since the last re-initialization of the local
    management subsystem, then this is the set to unix time start.";
              }
    
              leaf uidb-not-cfgd-pkts {
                type uint64;
                description
                  "Interface not configured packets";
              }
    
              leaf uidb-not-cfgd-octets {
                type uint64;
                description
                  "Interface not configured octets";
              }
    
              leaf bad-uidb-idx-pkts {
                type uint64;
                description
                  "Bad interface index packets";
              }
    
              leaf bad-uidb-idx-octets {
                type uint64;
                description
                  "Bad interface index octets";
              }
    
              leaf bad-uidb-sub-idx-pkts {
                type uint64;
                description
                  "Bad interface sub index packets";
              }
    
              leaf bad-uidb-sub-idx-octets {
                type uint64;
                description
                  "Bad interface sub index octets";
              }
    
              leaf unknown-encap-pkts {
                type uint64;
                description
                  "Unknown encapsulation packets";
              }
    
              leaf unknown-encap-octets {
                type uint64;
                description
                  "Unknown encapsulation octets";
              }
    
              leaf inv-l2-hdr-pkts {
                type uint64;
                description
                  "Invalid layer 2 header packets";
              }
    
              leaf inv-l2-hdr-octets {
                type uint64;
                description
                  "Invalid layer 2 header octets";
              }
    
              leaf bad-len-pkts {
                type uint64;
                description "Bad length packets";
              }
    
              leaf bad-len-octets {
                type uint64;
                description "Bad length octets";
              }
    
              leaf tcp-badfrag-pkts {
                type uint64;
                description
                  "TCP bad fragment packets";
              }
    
              leaf tcp-badfrag-octets {
                type uint64;
                description
                  "TCP bad fragment octets";
              }
    
              leaf ipv4-acl-pkts {
                type uint64;
                description
                  "IPv4 access control list (ACL) packets";
              }
    
              leaf ipv4-acl-octets {
                type uint64;
                description
                  "IPv4 access control list (ACL) octets";
              }
    
              leaf ipv4-acl-lookup-miss-pkts {
                type uint64;
                description
                  "IPv4 access control list (ACL) lookup miss packets";
              }
    
              leaf ipv4-acl-lookup-miss-octets {
                type uint64;
                description
                  "IPv4 access control list (ACL) lookup miss octets";
              }
    
              leaf bad-ip-checksum-pkts {
                type uint64;
                description
                  "Bad IP checksum packets";
              }
    
              leaf bad-ip-checksum-octets {
                type uint64;
                description
                  "Bad IP checksum octets";
              }
    
              leaf ip-format-err-pkts {
                type uint64;
                description
                  "IP format error packets";
              }
    
              leaf ip-format-err-octets {
                type uint64;
                description
                  "IP format error octets";
              }
    
              leaf ip-bad-options-pkts {
                type uint64;
                description
                  "IP bad options packets";
              }
    
              leaf ip-bad-options-octets {
                type uint64;
                description
                  "IP bad options octets";
              }
    
              leaf ipv4-martian-pkts {
                type uint64;
                description
                  "IPv4 martian packets";
              }
    
              leaf ipv4-martian-octets {
                type uint64;
                description
                  "IPv4 martian octets";
              }
    
              leaf mpass-err-pkts {
                type uint64;
                description
                  "Multi pass error packets";
              }
    
              leaf mpass-err-octets {
                type uint64;
                description
                  "Multi pass error octets";
              }
    
              leaf ipv4-pbr-pkts {
                type uint64;
                description
                  "IPv4 policy based routing (PBR) packets";
              }
    
              leaf ipv4-pbr-octets {
                type uint64;
                description
                  "IPv4 policy based routing (PBR) octets";
              }
    
              leaf inv-hdr-err-pkts {
                type uint64;
                description
                  "Invalid header error packets";
              }
    
              leaf inv-hdr-err-octets {
                type uint64;
                description
                  "Invalid header error octets";
              }
    
              leaf punt-err-pkts {
                type uint64;
                description "Punt error packets";
              }
    
              leaf punt-err-octets {
                type uint64;
                description "Punt error octets";
              }
    
              leaf inject-err-pkts {
                type uint64;
                description
                  "Inject error packets";
              }
    
              leaf inject-err-octets {
                type uint64;
                description
                  "Inject error octets";
              }
    
              leaf ipv4-no-route-pkts {
                type uint64;
                description
                  "IPv4 no route packets";
              }
    
              leaf ipv4-no-route-octets {
                type uint64;
                description
                  "IPv4 no route octets";
              }
    
              leaf qos-policing-pkts {
                type uint64;
                description
                  "Quality of service (QoS) policing packets";
              }
    
              leaf qos-policing-octets {
                type uint64;
                description
                  "Quality of service (QoS) policing octets";
              }
    
              leaf qos-actions-pkts {
                type uint64;
                description
                  "Quality of service (QoS) actions packets";
              }
    
              leaf qos-actions-octets {
                type uint64;
                description
                  "Quality of service (QoS) actions octets";
              }
    
              leaf null-jib-hdr-tbl-pkts {
                type uint64;
                description
                  "Null JIB header table packets";
              }
    
              leaf null-jib-hdr-tbl-octets {
                type uint64;
                description
                  "Null JIB header table octets";
              }
    
              leaf tail-drop-pkts {
                type uint64;
                description "Tail drop packets";
              }
    
              leaf tail-drop-octets {
                type uint64;
                description "Tail drop octets";
              }
    
              leaf wred-pkts {
                type uint64;
                description
                  "Weighted random early detection (WRED) packets";
              }
    
              leaf wred-octets {
                type uint64;
                description
                  "Weighted random early detection (WRED) octets";
              }
    
              leaf invalid-queue-pkts {
                type uint64;
                description
                  "Invalid queue packets";
              }
    
              leaf invalid-queue-octets {
                type uint64;
                description
                  "Invalid queue octets";
              }
    
              leaf invalid-wred-pkts {
                type uint64;
                description
                  "Invalid weighted random early detection (WRED) packets";
              }
    
              leaf invalid-wred-octets {
                type uint64;
                description
                  "Invalid weighted random early detection (WRED) octets";
              }
    
              leaf mpls-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) packets";
              }
    
              leaf mpls-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) octets";
              }
    
              leaf ipv6-truncatedpkts-pkts {
                type uint64;
                description
                  "IPv6 truncated packets";
              }
    
              leaf ipv6-truncatedpkts-octets {
                type uint64;
                description
                  "IPv6 truncated packets octets";
              }
    
              leaf ipv6-formaterr-pkts {
                type uint64;
                description
                  "IPv6 format error packets";
              }
    
              leaf ipv6-formaterr-octets {
                type uint64;
                description
                  "IPv6 format error octets";
              }
    
              leaf ipv6-badsource-pkts {
                type uint64;
                description
                  "IPv6 bad source address packets";
              }
    
              leaf ipv6-badsource-octets {
                type uint64;
                description
                  "IPv6 bad source address octets";
              }
    
              leaf ipv6-badhop-pkts {
                type uint64;
                description
                  "IPv6 bad hop count packets";
              }
    
              leaf ipv6-badhop-octets {
                type uint64;
                description
                  "IPv6 bad hop count octets";
              }
    
              leaf ipv6-toobigpacket-pkts {
                type uint64;
                description
                  "IPv6 packet too big packets";
              }
    
              leaf ipv6-toobigpacket-octets {
                type uint64;
                description
                  "IPv6 packet too big octets";
              }
    
              leaf ipv6-no-route-pkts {
                type uint64;
                description
                  "IPv6 no route packets";
              }
    
              leaf ipv6-no-route-octets {
                type uint64;
                description
                  "IPv6 no route octets";
              }
    
              leaf ipv6-acl-lookup-miss-pkts {
                type uint64;
                description
                  "IPv6 access control list (ACL) lookup miss packets";
              }
    
              leaf ipv6-acl-lookup-miss-octets {
                type uint64;
                description
                  "IPv6 access control list (ACL) lookup miss octets";
              }
    
              leaf ipv6-acl-pkts {
                type uint64;
                description
                  "IPv6 access control list (ACL) packets";
              }
    
              leaf ipv6-acl-octets {
                type uint64;
                description
                  "IPv6 access control list (ACL) octets";
              }
    
              leaf ip-acl-err-pkts {
                type uint64;
                description
                  "IP access control list (ACL) error packets";
              }
    
              leaf ip-acl-err-octets {
                type uint64;
                description
                  "IP access control list (ACL) error octets";
              }
    
              leaf mac-acl-pkts {
                type uint64;
                description
                  "MAC access control list (ACL) packets";
              }
    
              leaf mac-acl-octets {
                type uint64;
                description
                  "MAC access control list (ACL) octets";
              }
    
              leaf mac-acl-lookup-miss-pkts {
                type uint64;
                description
                  "MAC access control list (ACL) lookup miss packets";
              }
    
              leaf mac-acl-lookup-miss-octets {
                type uint64;
                description
                  "MAC access control list (ACL) lookup miss octets";
              }
    
              leaf ipv4mc-no-route-pkts {
                type uint64;
                description
                  "IPv4 multicast no route packets";
              }
    
              leaf ipv4mc-no-route-octets {
                type uint64;
                description
                  "IPv4 multicast no route octets";
              }
    
              leaf unknown-ext-header-pkts {
                type uint64;
                description
                  "Unknown extension header packets";
              }
    
              leaf unknown-ext-header-octets {
                type uint64;
                description
                  "Unknown extension header octets";
              }
    
              leaf ipv4mc-rpf-failed-pkts {
                type uint64;
                description
                  "IPv4 multicast reverse path forwarding failed packets";
              }
    
              leaf ipv4mc-rpf-failed-octets {
                type uint64;
                description
                  "IPv4 multicast reverse path forwarding failed octets";
              }
    
              leaf ipv4mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "IPv4 multicast invalid replica record packets";
              }
    
              leaf ipv4mc-invalid-replica-record-octets {
                type uint64;
                description
                  "IPv4 multicast invalid replica record octets";
              }
    
              leaf ipv4mc-ttl-threshold-chk-failed-pkts {
                type uint64;
                description
                  "IPv4 multicast time to live (TTL) threshold check failed packets";
              }
    
              leaf ipv4mc-ttl-threshold-chk-failed-octets {
                type uint64;
                description
                  "IPv4 multicast time to live (TTL) threshold check failed octets";
              }
    
              leaf ipv4mc-extra-replicae-pkts {
                type uint64;
                description
                  "IPv4 multicast extra replica packets";
              }
    
              leaf ipv4mc-extra-replicae-octets {
                type uint64;
                description
                  "IPv4 multicast extra replica octets";
              }
    
              leaf ipv4-mtr-pkts {
                type uint64;
                description
                  "IPv4 multi topology routing packets";
              }
    
              leaf ipv4-mtr-octets {
                type uint64;
                description
                  "IPv4 multi topology routing octets";
              }
    
              leaf internal-ctl-pkts {
                type uint64;
                description
                  "Internal control packets";
              }
    
              leaf internal-ctl-octets {
                type uint64;
                description
                  "Internal control octets";
              }
    
              leaf bad-dist-fifo-pkts {
                type uint64;
                description
                  "Bad distribution first in first out (FIFO) packets";
              }
    
              leaf bad-dist-fifo-octets {
                type uint64;
                description
                  "Bad distribution first in first out (FIFO) octets";
              }
    
              leaf frfab-wred-drop-pkts {
                type uint64;
                description
                  "Frame Relay weighted random early detection (WRED) drop packets";
              }
    
              leaf frfab-wred-drop-octets {
                type uint64;
                description
                  "Frame Relay weighted random early detection (WRED) drop octets";
              }
    
              leaf firewall-nonsession-pkts {
                type uint64;
                description
                  "Firewall no session packets";
              }
    
              leaf firewall-nonsession-octets {
                type uint64;
                description
                  "Firewall no session octets";
              }
    
              leaf firewall-invalid-zone-pkts {
                type uint64;
                description
                  "Firewall invalid zone packets";
              }
    
              leaf firewall-invalid-zone-octets {
                type uint64;
                description
                  "Firewall invalid zone octets";
              }
    
              leaf firewall-backpressure-pkts {
                type uint64;
                description
                  "Firewall backpressure packets";
              }
    
              leaf firewall-backpressure-octets {
                type uint64;
                description
                  "Firewall backpressure octets";
              }
    
              leaf firewall-l4-insp-pkts {
                type uint64;
                description
                  "Firewall layer 4 insp packets";
              }
    
              leaf firewall-l4-insp-octets {
                type uint64;
                description
                  "Firewall layer 4 insp octets";
              }
    
              leaf ip-frag-err-pkts {
                type uint64;
                description
                  "IP fragments error packets";
              }
    
              leaf ip-frag-err-octets {
                type uint64;
                description
                  "IP fragments error octets";
              }
    
              leaf no-gpm-memory-err-pkts {
                type uint64;
                description
                  "No global packet memory memory error packets";
              }
    
              leaf no-gpm-memory-err-octets {
                type uint64;
                description
                  "No global packet memory memory error octets";
              }
    
              leaf for-us-pkts {
                type uint64;
                description "For us packets";
              }
    
              leaf for-us-octets {
                type uint64;
                description "For us octets";
              }
    
              leaf ipsec-input-pkts {
                type uint64;
                description
                  "IPSEC input packets";
              }
    
              leaf ipsec-input-octets {
                type uint64;
                description "IPSEC input octets";
              }
    
              leaf ipsec-ike-indicate-pkts {
                type uint64;
                description
                  "IPSEC IKE indicate packets";
              }
    
              leaf ipsec-ike-indicate-octets {
                type uint64;
                description
                  "IPSEC IKE indicate octets";
              }
    
              leaf ipsec-invalid-sa-pkts {
                type uint64;
                description
                  "IPSEC invalid security association (SA) packets";
              }
    
              leaf ipsec-invalid-sa-octets {
                type uint64;
                description
                  "IPSEC invalid security association (SA) octets";
              }
    
              leaf ipsec-tail-drop-pkts {
                type uint64;
                description
                  "IPSEC tail drop packets";
              }
    
              leaf ipsec-tail-drop-octets {
                type uint64;
                description
                  "IPSEC tail drop octets";
              }
    
              leaf layer2-no-route-pkts {
                type uint64;
                description
                  "Layer 2 no route packets";
              }
    
              leaf layer2-no-route-octets {
                type uint64;
                description
                  "Layer 2 no route octets";
              }
    
              leaf icmp-pkts {
                type uint64;
                description "ICMP packets";
              }
    
              leaf icmp-octets {
                type uint64;
                description "ICMP octets";
              }
    
              leaf ip-ttl-exceeded-pkts {
                type uint64;
                description
                  "IP time to live (TTL) exceeded packets";
              }
    
              leaf ip-ttl-exceeded-octets {
                type uint64;
                description
                  "IP time to live (TTL) exceeded octets";
              }
    
              leaf tunnel-bad-gre-checksum-pkts {
                type uint64;
                description
                  "Tunnel bad generic route encapsulation (GRE) checksum packets";
              }
    
              leaf tunnel-bad-gre-checksum-octets {
                type uint64;
                description
                  "Tunnel bad generic route encapsulation (GRE) checksum octets";
              }
    
              leaf tunnel-misconfiguration-pkts {
                type uint64;
                description
                  "Tunnel misconfiguration packets";
              }
    
              leaf tunnel-misconfiguration-octets {
                type uint64;
                description
                  "Tunnel misconfiguration octets";
              }
    
              leaf gre-bad-options-pkts {
                type uint64;
                description
                  "Generic route encapsulation (GRE) bad options packets";
              }
    
              leaf gre-bad-options-octets {
                type uint64;
                description
                  "Generic route encapsulation (GRE) bad options octets";
              }
    
              leaf frag-tail-drop-pkts {
                type uint64;
                description
                  "Fragments tail drop packets";
              }
    
              leaf frag-tail-drop-octets {
                type uint64;
                description
                  "Fragments tail drop octets";
              }
    
              leaf unconfigured-fia-pkts {
                type uint64;
                description
                  "Unconfigured feature invocation array (FIA) packets";
              }
    
              leaf unconfigured-fia-octets {
                type uint64;
                description
                  "Unconfigured feature invocation array (FIA) octets";
              }
    
              leaf ipv4-fpm-pkts {
                type uint64;
                description
                  "IPv4 flexible packet match packets";
              }
    
              leaf ipv4-fpm-octets {
                type uint64;
                description
                  "IPv4 flexible packet match octets";
              }
    
              leaf nat-in2out-pkts {
                type uint64;
                description
                  "NAT in to out packets";
              }
    
              leaf nat-in2out-octets {
                type uint64;
                description
                  "NAT in to out octets";
              }
    
              leaf nat-out2in-pkts {
                type uint64;
                description
                  "NAT out to in packets";
              }
    
              leaf nat-out2in-octets {
                type uint64;
                description
                  "NAT out to in octets";
              }
    
              leaf pa-walk-err-pkts {
                type uint64;
                description
                  "Packet abstraction walk error packets";
              }
    
              leaf pa-walk-err-octets {
                type uint64;
                description
                  "Packet abstraction walk error octets";
              }
    
              leaf ipv4-routing-err-pkts {
                type uint64;
                description
                  "IPv4 routing error packets";
              }
    
              leaf ipv4-routing-err-octets {
                type uint64;
                description
                  "IPv4 routing error octets";
              }
    
              leaf ipv6-routing-err-pkts {
                type uint64;
                description
                  "IPv6 routing error packets";
              }
    
              leaf ipv6-routing-err-octets {
                type uint64;
                description
                  "IPv6 routing error octets";
              }
    
              leaf mpass-invalid-fs-vector-pkts {
                type uint64;
                description
                  "Multi pass invalid fs vector packets";
              }
    
              leaf mpass-invalid-fs-vector-octets {
                type uint64;
                description
                  "Multi pass invalid fs vector octets";
              }
    
              leaf reass-drop-pkts {
                type uint64;
                description
                  "Reassembly drop packets";
              }
    
              leaf reass-drop-octets {
                type uint64;
                description
                  "Reassembly drop octets";
              }
    
              leaf reass-frag-too-big-pkts {
                type uint64;
                description
                  "Reassembly fragments too big packets";
              }
    
              leaf reass-frag-too-big-octets {
                type uint64;
                description
                  "Reassembly fragments too big octets";
              }
    
              leaf reass-no-frag-info-pkts {
                type uint64;
                description
                  "Reassembly no fragments information packets";
              }
    
              leaf reass-no-frag-info-octets {
                type uint64;
                description
                  "Reassembly no fragments information octets";
              }
    
              leaf reass-no-frag-info-low-pkts {
                type uint64;
                description
                  "Reassembly no fragments information low packets";
              }
    
              leaf reass-no-frag-info-low-octets {
                type uint64;
                description
                  "Reassembly no fragments information low octets";
              }
    
              leaf reass-bad-len-pkts {
                type uint64;
                description
                  "Reassembly bad length packets";
              }
    
              leaf reass-bad-len-octets {
                type uint64;
                description
                  "Reassembly bad length octets";
              }
    
              leaf reass-too-many-frags-pkts {
                type uint64;
                description
                  "Reassembly too many fragments packets";
              }
    
              leaf reass-too-many-frags-octets {
                type uint64;
                description
                  "Reassembly too many fragments octets";
              }
    
              leaf reass-no-frags-left-pkts {
                type uint64;
                description
                  "Reassembly no fragments left packets";
              }
    
              leaf reass-no-frags-left-octets {
                type uint64;
                description
                  "Reassembly no fragments left octets";
              }
    
              leaf reass-overlap-pkts {
                type uint64;
                description
                  "Reassembly overlap packets";
              }
    
              leaf reass-overlap-octets {
                type uint64;
                description
                  "Reassembly overlap octets";
              }
    
              leaf reass-timeout-pkts {
                type uint64;
                description
                  "Reassembly timeout packets";
              }
    
              leaf reass-timeout-octets {
                type uint64;
                description
                  "Reassembly timeout octets";
              }
    
              leaf no-mem-pkts {
                type uint64;
                description "No memory packets";
              }
    
              leaf no-mem-octets {
                type uint64;
                description "No memory octets";
              }
    
              leaf vfr-err-pkts {
                type uint64;
                description
                  "Virtual forwarding and routing (VFR) error packets";
              }
    
              leaf vfr-err-octets {
                type uint64;
                description
                  "Virtual forwarding and routing (VFR) error octets";
              }
    
              leaf vfr-tail-drop-pkts {
                type uint64;
                description
                  "Virtual forwarding and routing (VFR) tail drop packets";
              }
    
              leaf vfr-tail-drop-octets {
                type uint64;
                description
                  "Virtual forwarding and routing (VFR) tail drop octets";
              }
    
              leaf iphc-pkts {
                type uint64;
                description
                  "IP header compression packets";
              }
    
              leaf iphc-octets {
                type uint64;
                description
                  "IP header compression octets";
              }
    
              leaf multilink-cfg-pkts {
                type uint64;
                description
                  "Multilink configuration packets";
              }
    
              leaf multilink-cfg-octets {
                type uint64;
                description
                  "Multilink configuration octets";
              }
    
              leaf mlp-pkts {
                type uint64;
                description
                  "Multilink protocol (MLP) packets";
              }
    
              leaf mlp-octets {
                type uint64;
                description
                  "Multilink protocol (MLP) octets";
              }
    
              leaf min-tu-pkts {
                type uint64;
                description
                  "Minimum transfer unit packets";
              }
    
              leaf min-tu-octets {
                type uint64;
                description
                  "Minimum transfer unit octets";
              }
    
              leaf max-tu-pkts {
                type uint64;
                description
                  "Maximum transfer unit packets";
              }
    
              leaf max-tu-octets {
                type uint64;
                description
                  "Maximum transfer unit octets";
              }
    
              leaf ipv4-unclassified-pkts {
                type uint64;
                description
                  "IPv4 unclassified packets";
              }
    
              leaf ipv4-unclassified-octets {
                type uint64;
                description
                  "IPv4 unclassified octets";
              }
    
              leaf ipv6-unclassified-pkts {
                type uint64;
                description
                  "IPv6 unclassified packets";
              }
    
              leaf ipv6-unclassified-octets {
                type uint64;
                description
                  "IPv6 unclassified octets";
              }
    
              leaf ipv4-no-adj-pkts {
                type uint64;
                description
                  "IPv4 no adjacency packets";
              }
    
              leaf ipv4-no-adj-octets {
                type uint64;
                description
                  "IPv4 no adjacency octets";
              }
    
              leaf ipv4-null0-pkts {
                type uint64;
                description "IPv4 null0 packets";
              }
    
              leaf ipv4-null0-octets {
                type uint64;
                description "IPv4 null0 octets";
              }
    
              leaf ipv6-null0-pkts {
                type uint64;
                description "IPv6 null0 packets";
              }
    
              leaf ipv6-null0-octets {
                type uint64;
                description "IPv6 null0 octets";
              }
    
              leaf mpls-mismatch-linktype-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) mismatch linktype packets";
              }
    
              leaf mpls-mismatch-linktype-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) mismatch linktype octets";
              }
    
              leaf mpls-frag-req-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) fragments request packets";
              }
    
              leaf mpls-frag-req-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) fragments request octets";
              }
    
              leaf choice-oce-pkts {
                type uint64;
                description
                  "Choice output chain element (OCE) packets";
              }
    
              leaf choice-oce-octets {
                type uint64;
                description
                  "Choice output chain element (OCE) octets";
              }
    
              leaf unsupported-oce-pkts {
                type uint64;
                description
                  "Unsupported output chain element (OCE) packets";
              }
    
              leaf unsupported-oce-octets {
                type uint64;
                description
                  "Unsupported output chain element (OCE) octets";
              }
    
              leaf attn-invalid-spid-pkts {
                type uint64;
                description
                  "Attention protocol invalid sync point identifier packets";
              }
    
              leaf attn-invalid-spid-octets {
                type uint64;
                description
                  "Attention protocol invalid sync point identifier octets";
              }
    
              leaf inv-common-preamble-pkts {
                type uint64;
                description
                  "Invalid common preamble packets";
              }
    
              leaf inv-common-preamble-octets {
                type uint64;
                description
                  "Invalid common preamble octets";
              }
    
              leaf ext-drop-path-pkts {
                type uint64;
                description
                  "Extension drop path packets";
              }
    
              leaf ext-drop-path-octets {
                type uint64;
                description
                  "Extension drop path octets";
              }
    
              leaf frr-oce-no-backup-pkts {
                type uint64;
                description
                  "Fast reroute (FRR) output chain element (OCE) no backup packets";
              }
    
              leaf frr-oce-no-backup-octets {
                type uint64;
                description
                  "Fast reroute (FRR) output chain element (OCE) no backup octets";
              }
    
              leaf frr-oce-invalid-state-pkts {
                type uint64;
                description
                  "Fast reroute (FRR) output chain element (OCE) invalid state packets";
              }
    
              leaf frr-oce-invalid-state-octets {
                type uint64;
                description
                  "Fast reroute (FRR) output chain element (OCE) invalid state octets";
              }
    
              leaf bqs-oor-pkts {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources packets";
              }
    
              leaf bqs-oor-octets {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources octets";
              }
    
              leaf ess-bad-sess-uidb-pkts {
                type uint64;
                description
                  "Edge switching services bad session interface packets";
              }
    
              leaf ess-bad-sess-uidb-octets {
                type uint64;
                description
                  "Edge switching services bad session interface octets";
              }
    
              leaf ess-pktsb-missed-pkts {
                type uint64;
                description
                  "Edge switching services packet sub block missed packets";
              }
    
              leaf ess-pktsb-missed-octets {
                type uint64;
                description
                  "Edge switching services packet sub block missed octets";
              }
    
              leaf ess-unsup-pkt-type-pkts {
                type uint64;
                description
                  "Edge switching services unsupported packet type packets";
              }
    
              leaf ess-unsup-pkt-type-octets {
                type uint64;
                description
                  "Edge switching services unsupported packet type octets";
              }
    
              leaf ess-no-encap-info-pkts {
                type uint64;
                description
                  "Edge switching services no encapsulation information packets";
              }
    
              leaf ess-no-encap-info-octets {
                type uint64;
                description
                  "Edge switching services no encapsulation information octets";
              }
    
              leaf ess-inv-switch-mode-pkts {
                type uint64;
                description
                  "Edge switching services invalid switch mode packets";
              }
    
              leaf ess-inv-switch-mode-octets {
                type uint64;
                description
                  "Edge switching services invalid switch mode octets";
              }
    
              leaf inv-ppp-cp-pkt-pkts {
                type uint64;
                description
                  "Invalid PPP control protocol packets";
              }
    
              leaf inv-ppp-cp-pkt-octets {
                type uint64;
                description
                  "Invalid PPP control protocol packet octets";
              }
    
              leaf ppp-cxt-missed-pkts {
                type uint64;
                description
                  "PPP context missed packets";
              }
    
              leaf ppp-cxt-missed-octets {
                type uint64;
                description
                  "PPP context missed octets";
              }
    
              leaf ess-unbound-session-pkts {
                type uint64;
                description
                  "Edge switching services unbound session packets";
              }
    
              leaf ess-unbound-session-octets {
                type uint64;
                description
                  "Edge switching services unbound session octets";
              }
    
              leaf ess-pi-inv-subtype-pkts {
                type uint64;
                description
                  "Edge switching services platform independent invalid subtype packets";
              }
    
              leaf ess-pi-inv-subtype-octets {
                type uint64;
                description
                  "Edge switching services platform independent invalid subtype octets";
              }
    
              leaf ess-pi-state-err-pkts {
                type uint64;
                description
                  "Edge switching services platform independent state error packets";
              }
    
              leaf ess-pi-state-err-octets {
                type uint64;
                description
                  "Edge switching services platform independent state error octets";
              }
    
              leaf ess-inject-bad-hdr-pkts {
                type uint64;
                description
                  "Edge switching services inject bad header packets";
              }
    
              leaf ess-inject-bad-hdr-octets {
                type uint64;
                description
                  "Edge switching services inject bad header octets";
              }
    
              leaf ess-l2-hdr-too-big-pkts {
                type uint64;
                description
                  "Edge switching services layer 2 header too big packets";
              }
    
              leaf ess-l2-hdr-too-big-octets {
                type uint64;
                description
                  "Edge switching services layer 2 header too big octets";
              }
    
              leaf pppox-unconfigured-pkts {
                type uint64;
                description
                  "PPP over any protocol (PPPoX) unconfigured packets";
              }
    
              leaf pppox-unconfigured-octets {
                type uint64;
                description
                  "PPP over any protocol (PPPoX) unconfigured octets";
              }
    
              leaf pppoe-pkt-inv-hdr-pkts {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) packet invalid header packets";
              }
    
              leaf pppoe-pkt-inv-hdr-octets {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) packet invalid header octets";
              }
    
              leaf pppoe-pkt-bad-len-pkts {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) packet bad length packets";
              }
    
              leaf pppoe-pkt-bad-len-octets {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) packet bad length octets";
              }
    
              leaf pppoe-no-session-pkts {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) no session packets";
              }
    
              leaf pppoe-no-session-octets {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) no session octets";
              }
    
              leaf pppoe-inv-encap-info-pkts {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) invalid encapsulation information packets";
              }
    
              leaf pppoe-inv-encap-info-octets {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) invalid encapsulation information octets";
              }
    
              leaf ess-cac-pkts {
                type uint64;
                description
                  "Edge switching services call admission control packets";
              }
    
              leaf ess-cac-octets {
                type uint64;
                description
                  "Edge switching services call admission control octets";
              }
    
              leaf l2tp-unconfigured-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) unconfigured packets";
              }
    
              leaf l2tp-unconfigured-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) unconfigured octets";
              }
    
              leaf l2tp-pkt-inv-hdr-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet invalid header packets";
              }
    
              leaf l2tp-pkt-inv-hdr-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet invalid header octets";
              }
    
              leaf l2tp-pkt-bad-len-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet bad length packets";
              }
    
              leaf l2tp-pkt-bad-len-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet bad length octets";
              }
    
              leaf l2tp-no-session-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) no session packets";
              }
    
              leaf l2tp-no-session-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) no session octets";
              }
    
              leaf l2tp-pktsb-missed-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet sub block missed packets";
              }
    
              leaf l2tp-pktsb-missed-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) packet sub block missed octets";
              }
    
              leaf l2tp-security-check-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) security check packets";
              }
    
              leaf l2tp-security-check-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) security check octets";
              }
    
              leaf l2tp-bad-udp-chksum-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) bad UDP checksum packets";
              }
    
              leaf l2tp-bad-udp-chksum-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) bad UDP checksum octets";
              }
    
              leaf l2tp-ooo-rx-pkt-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) ooo receive packets";
              }
    
              leaf l2tp-ooo-rx-pkt-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) ooo receive packet octets";
              }
    
              leaf l2tp-exceed-tx-mtu-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) exceed transmit mtu packets";
              }
    
              leaf l2tp-exceed-tx-mtu-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) exceed transmit mtu octets";
              }
    
              leaf ipsec-output-pkts {
                type uint64;
                description
                  "IPSEC output packets";
              }
    
              leaf ipsec-output-octets {
                type uint64;
                description
                  "IPSEC output octets";
              }
    
              leaf ipsec-ted-indicate-pkts {
                type uint64;
                description
                  "IPSEC tunnel end point discovery (TED) indicate packets";
              }
    
              leaf ipsec-ted-indicate-octets {
                type uint64;
                description
                  "IPSEC tunnel end point discovery (TED) indicate octets";
              }
    
              leaf ipsec-deny-drop-pkts {
                type uint64;
                description
                  "IPSEC deny drop packets";
              }
    
              leaf ipsec-deny-drop-octets {
                type uint64;
                description
                  "IPSEC deny drop octets";
              }
    
              leaf l2tp-cxt-missed-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) context missed packets";
              }
    
              leaf l2tp-cxt-missed-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) context missed octets";
              }
    
              leaf l2tp-tx-seq-missed-pkts {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) transmit sequence missed packets";
              }
    
              leaf l2tp-tx-seq-missed-octets {
                type uint64;
                description
                  "Layer 2 tunnelling protocol (L2TP) transmit sequence missed octets";
              }
    
              leaf disabled-pkts {
                type uint64;
                description "Disabled packets";
              }
    
              leaf disabled-octets {
                type uint64;
                description "Disabled octets";
              }
    
              leaf ipv6-no-adj-pkts {
                type uint64;
                description
                  "IPv6 no adjacency packets";
              }
    
              leaf ipv6-no-adj-octets {
                type uint64;
                description
                  "IPv6 no adjacency octets";
              }
    
              leaf not-enabled-pkts {
                type uint64;
                description
                  "Not enabled packets";
              }
    
              leaf not-enabled-octets {
                type uint64;
                description "Not enabled octets";
              }
    
              leaf special-multicast-obj-pkts {
                type uint64;
                description
                  "Special multicast object packets";
              }
    
              leaf special-multicast-obj-octets {
                type uint64;
                description
                  "Special multicast object octets";
              }
    
              leaf illegal-obj-pkts {
                type uint64;
                description
                  "Illegal object packets";
              }
    
              leaf illegal-obj-octets {
                type uint64;
                description
                  "Illegal object octets";
              }
    
              leaf unresolved-pkts {
                type uint64;
                description "Unresolved packets";
              }
    
              leaf unresolved-octets {
                type uint64;
                description "Unresolved octets";
              }
    
              leaf discard-pkts {
                type uint64;
                description "Discard packets";
              }
    
              leaf discard-octets {
                type uint64;
                description "Discard octets";
              }
    
              leaf ipv6mc-no-route-pkts {
                type uint64;
                description
                  "IPv6 multicast no route packets";
              }
    
              leaf ipv6mc-no-route-octets {
                type uint64;
                description
                  "IPv6 multicast no route octets";
              }
    
              leaf ipv6mc-rpf-failed-pkts {
                type uint64;
                description
                  "IPv6 multicast reverse path forwarding failed packets";
              }
    
              leaf ipv6mc-rpf-failed-octets {
                type uint64;
                description
                  "IPv6 multicast reverse path forwarding failed octets";
              }
    
              leaf ipv6mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "IPv6 multicast invalid replica record packets";
              }
    
              leaf ipv6mc-invalid-replica-record-octets {
                type uint64;
                description
                  "IPv6 multicast invalid replica record octets";
              }
    
              leaf ipv6mc-ttl-threshold-chk-failed-pkts {
                type uint64;
                description
                  "IPv6 multicast time to live (TTL) threshold check failed packets";
              }
    
              leaf ipv6mc-ttl-threshold-chk-failed-octets {
                type uint64;
                description
                  "IPv6 multicast time to live (TTL) threshold check failed octets";
              }
    
              leaf ipv6mc-extra-replica-pkts {
                type uint64;
                description
                  "IPv6 multicast extra replica packets";
              }
    
              leaf ipv6mc-extra-replica-octets {
                type uint64;
                description
                  "IPv6 multicast extra replica octets";
              }
    
              leaf layer2-switching-pkts {
                type uint64;
                description
                  "Layer 2 switching packets";
              }
    
              leaf layer2-switching-octets {
                type uint64;
                description
                  "Layer 2 switching octets";
              }
    
              leaf internal-intf-err-pkts {
                type uint64;
                description
                  "Internal interface error packets";
              }
    
              leaf internal-intf-err-octets {
                type uint64;
                description
                  "Internal interface error octets";
              }
    
              leaf sbc-police-punt-pkts {
                type uint64;
                description
                  "Session border controller (SBC) police punt packets";
              }
    
              leaf sbc-police-punt-octets {
                type uint64;
                description
                  "Session border controller (SBC) police punt octets";
              }
    
              leaf sbc-uidb-pkts {
                type uint64;
                description
                  "Session border controller (SBC) interface packets";
              }
    
              leaf sbc-uidb-octets {
                type uint64;
                description
                  "Session border controller (SBC) interface octets";
              }
    
              leaf sbc-sess-pkts {
                type uint64;
                description
                  "Session border controller (SBC) session packets";
              }
    
              leaf sbc-sess-octets {
                type uint64;
                description
                  "Session border controller (SBC) session octets";
              }
    
              leaf sbc-mmoh-invalid-replica-record-pkts {
                type uint64;
                description
                  "Session border controller (SBC) music on hold invalid replica record packets";
              }
    
              leaf sbc-mmoh-invalid-replica-record-octets {
                type uint64;
                description
                  "Session border controller (SBC) music on hold invalid replica record octets";
              }
    
              leaf mpls-ipv6-frag-req-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) IPv6 fragments request packets";
              }
    
              leaf mpls-ipv6-frag-req-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) IPv6 fragments request octets";
              }
    
              leaf sw-mac-filter-pkts {
                type uint64;
                description
                  "Software MAC filter packets";
              }
    
              leaf sw-mac-filter-octets {
                type uint64;
                description
                  "Software MAC filter octets";
              }
    
              leaf tunnel-bad-pim-checksum-pkts {
                type uint64;
                description
                  "Tunnel bad protocol independent multicast (PIM) checksum packets";
              }
    
              leaf tunnel-bad-pim-checksum-octets {
                type uint64;
                description
                  "Tunnel bad protocol independent multicast (PIM) checksum octets";
              }
    
              leaf tunnel-unsupported-config-pkts {
                type uint64;
                description
                  "Tunnel unsupported config packets";
              }
    
              leaf tunnel-unsupported-config-octets {
                type uint64;
                description
                  "Tunnel unsupported config octets";
              }
    
              leaf firewall-no-forwarding-pkts {
                type uint64;
                description
                  "Firewall no forwarding packets";
              }
    
              leaf firewall-no-forwarding-octets {
                type uint64;
                description
                  "Firewall no forwarding octets";
              }
    
              leaf erspan-pkts {
                type uint64;
                description
                  "Extended reach SPAN (ERSPAN) packets";
              }
    
              leaf erspan-octets {
                type uint64;
                description
                  "Extended reach SPAN (ERSPAN) octets";
              }
    
              leaf ipv4-urpf-null-path-list-pkts {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding null path list packets";
              }
    
              leaf ipv4-urpf-null-path-list-octets {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding null path list octets";
              }
    
              leaf mpls-unclassified-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) unclassified packets";
              }
    
              leaf mpls-unclassified-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) unclassified octets";
              }
    
              leaf mpls-eos-invalid-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) end of stack invalid packets";
              }
    
              leaf mpls-eos-invalid-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) end of stack invalid octets";
              }
    
              leaf glean-adj-unsupport-linktype-pkts {
                type uint64;
                description
                  "Glean adjacency unsupported linktype packets";
              }
    
              leaf glean-adj-unsupport-linktype-octets {
                type uint64;
                description
                  "Glean adjacency unsupported linktype octets";
              }
    
              leaf mpls-label-oce-ptr-null-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) pointer null packets";
              }
    
              leaf mpls-label-oce-ptr-null-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) pointer null octets";
              }
    
              leaf mpls-label-oce-invalid-label-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) invalid label packets";
              }
    
              leaf mpls-label-oce-invalid-label-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) invalid label octets";
              }
    
              leaf mpls-label-oce-unsupport-linktype-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) unsupported linktype packets";
              }
    
              leaf mpls-label-oce-unsupport-linktype-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) label output chain element (OCE) unsupported linktype octets";
              }
    
              leaf lookup-oce-should-drop-pkts {
                type uint64;
                description
                  "Lookup output chain element (OCE) should drop packets";
              }
    
              leaf lookup-oce-should-drop-octets {
                type uint64;
                description
                  "Lookup output chain element (OCE) should drop octets";
              }
    
              leaf lookup-oce-unsupport-linktype-pkts {
                type uint64;
                description
                  "Lookup output chain element (OCE) unsupported linktype packets";
              }
    
              leaf lookup-oce-unsupport-linktype-octets {
                type uint64;
                description
                  "Lookup output chain element (OCE) unsupported linktype octets";
              }
    
              leaf unsupport-linktype-no-route-pkts {
                type uint64;
                description
                  "Unsupported linktype no route packets";
              }
    
              leaf unsupport-linktype-no-route-octets {
                type uint64;
                description
                  "Unsupported linktype no route octets";
              }
    
              leaf unsupport-linktype-null0-pkts {
                type uint64;
                description
                  "Unsupported linktype null0 packets";
              }
    
              leaf unsupport-linktype-null0-octets {
                type uint64;
                description
                  "Unsupported linktype null0 octets";
              }
    
              leaf sr-te-remote-error-pkts {
                type uint64;
                description
                  "Segment routing traffic engineering (TE) remote error packets";
              }
    
              leaf sr-te-remote-error-octets {
                type uint64;
                description
                  "Segment routing traffic engineering (TE) remote error octets";
              }
    
              leaf ipv4-pop-pipe-php-ttl-expire-pkts {
                type uint64;
                description
                  "IPv4 pop pipe penultimate hop pop time to live (TTL) expire packets";
              }
    
              leaf ipv4-pop-pipe-php-ttl-expire-octets {
                type uint64;
                description
                  "IPv4 pop pipe penultimate hop pop time to live (TTL) expire octets";
              }
    
              leaf ipv4-pop-unf-uhp-ttl-expire-pkts {
                type uint64;
                description
                  "IPv4 pop uniform ultimate hop pop time to live (TTL) expire packets";
              }
    
              leaf ipv4-pop-unf-uhp-ttl-expire-octets {
                type uint64;
                description
                  "IPv4 pop uniform ultimate hop pop time to live (TTL) expire octets";
              }
    
              leaf ipv4-pop-unf-php-ttl-expire-pkts {
                type uint64;
                description
                  "IPv4 pop uniform penultimate hop pop time to live (TTL) expire packets";
              }
    
              leaf ipv4-pop-unf-php-ttl-expire-octets {
                type uint64;
                description
                  "IPv4 pop uniform penultimate hop pop time to live (TTL) expire octets";
              }
    
              leaf mpls-pop-pipe-ttl-expire-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop pipe time to live (TTL) expire packets";
              }
    
              leaf mpls-pop-pipe-ttl-expire-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop pipe time to live (TTL) expire octets";
              }
    
              leaf mpls-pop-unf-uhp-ttl-expire-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop uniform ultimate hop pop time to live (TTL) expire packets";
              }
    
              leaf mpls-pop-unf-uhp-ttl-expire-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop uniform ultimate hop pop time to live (TTL) expire octets";
              }
    
              leaf mpls-pop-unf-php-ttl-expire-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop uniform penultimate hop pop time to live (TTL) expire packets";
              }
    
              leaf mpls-pop-unf-php-ttl-expire-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) pop uniform penultimate hop pop time to live (TTL) expire octets";
              }
    
              leaf label-pop-unsupport-linktype-pkts {
                type uint64;
                description
                  "Label pop unsupported linktype packets";
              }
    
              leaf label-pop-unsupport-linktype-octets {
                type uint64;
                description
                  "Label pop unsupported linktype octets";
              }
    
              leaf mpls-no-route-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) no route packets";
              }
    
              leaf mpls-no-route-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) no route octets";
              }
    
              leaf mpls-icmp-invalid-hdr-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) ICMP invalid header packets";
              }
    
              leaf mpls-icmp-invalid-hdr-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) ICMP invalid header octets";
              }
    
              leaf mpls-sanity-echo-req-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) sanity echo request packets";
              }
    
              leaf mpls-sanity-echo-req-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) sanity echo request octets";
              }
    
              leaf mpls-sanity-drop-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) sanity drop packets";
              }
    
              leaf mpls-sanity-drop-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) sanity drop octets";
              }
    
              leaf ess-unprov-session-pkts {
                type uint64;
                description
                  "Edge switching services unprovisioned session packets";
              }
    
              leaf ess-unprov-session-octets {
                type uint64;
                description
                  "Edge switching services unprovisioned session octets";
              }
    
              leaf firewall-policy-pkts {
                type uint64;
                description
                  "Firewall policy packets";
              }
    
              leaf firewall-policy-octets {
                type uint64;
                description
                  "Firewall policy octets";
              }
    
              leaf firewall-l4-pkts {
                type uint64;
                description
                  "Firewall layer 4 packets";
              }
    
              leaf firewall-l4-octets {
                type uint64;
                description
                  "Firewall layer 4 octets";
              }
    
              leaf firewall-l7-pkts {
                type uint64;
                description
                  "Firewall layer 7 packets";
              }
    
              leaf firewall-l7-octets {
                type uint64;
                description
                  "Firewall layer 7 octets";
              }
    
              leaf firewall-no-new-sessions-pkts {
                type uint64;
                description
                  "Firewall no new sessions packets";
              }
    
              leaf firewall-no-new-sessions-octets {
                type uint64;
                description
                  "Firewall no new sessions octets";
              }
    
              leaf firewall-not-initiator-pkts {
                type uint64;
                description
                  "Firewall not initiator packets";
              }
    
              leaf firewall-not-initiator-octets {
                type uint64;
                description
                  "Firewall not initiator octets";
              }
    
              leaf firewall-not-from-init-pkts {
                type uint64;
                description
                  "Firewall not from init packets";
              }
    
              leaf firewall-not-from-init-octets {
                type uint64;
                description
                  "Firewall not from init octets";
              }
    
              leaf gen-pkt-replication-pkts {
                type uint64;
                description
                  "Gen packet replication packets";
              }
    
              leaf gen-pkt-replication-octets {
                type uint64;
                description
                  "Gen packet replication octets";
              }
    
              leaf esf-l4r-bad-config-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect bad config packets";
              }
    
              leaf esf-l4r-bad-config-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect bad config octets";
              }
    
              leaf esf-l4r-trans-unavail-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect trans unavailable packets";
              }
    
              leaf esf-l4r-trans-unavail-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect trans unavailable octets";
              }
    
              leaf esf-pbhk-bad-config-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key bad config packets";
              }
    
              leaf esf-pbhk-bad-config-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key bad config octets";
              }
    
              leaf esf-pbhk-unalloc-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle
    host key not allocated packets";
              }
    
              leaf esf-pbhk-unalloc-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle
    host key not allocated octets";
              }
    
              leaf esf-pbhk-port-unavail-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key port unavailable packets";
              }
    
              leaf esf-pbhk-port-unavail-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key port unavailable octets";
              }
    
              leaf esf-pbhk-port-notfound-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle
    host key port not found packets";
              }
    
              leaf esf-pbhk-port-notfound-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle
    host key port not found octets";
              }
    
              leaf esf-pbhk-port-removed-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key port removed packets";
              }
    
              leaf esf-pbhk-port-removed-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) port-bundle host key port removed octets";
              }
    
              leaf mpls-no-adj-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) no adjacency packets";
              }
    
              leaf mpls-no-adj-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) no adjacency octets";
              }
    
              leaf ipv4-adj-drop-pkts {
                type uint64;
                description
                  "IPv4 adjacency drop packets";
              }
    
              leaf ipv4-adj-drop-octets {
                type uint64;
                description
                  "IPv4 adjacency drop octets";
              }
    
              leaf ipv6-adj-drop-pkts {
                type uint64;
                description
                  "IPv6 adjacency drop packets";
              }
    
              leaf ipv6-adj-drop-octets {
                type uint64;
                description
                  "IPv6 adjacency drop octets";
              }
    
              leaf mpls-adj-drop-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) adjacency drop packets";
              }
    
              leaf mpls-adj-drop-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) adjacency drop octets";
              }
    
              leaf bad-adj-pkts {
                type uint64;
                description
                  "Bad adjacency packets";
              }
    
              leaf bad-adj-octets {
                type uint64;
                description
                  "Bad adjacency octets";
              }
    
              leaf punt-policer-drop-pkts {
                type uint64;
                description
                  "Punt policer drop packets";
              }
    
              leaf punt-policer-drop-octets {
                type uint64;
                description
                  "Punt policer drop octets";
              }
    
              leaf punt-global-policer-drop-pkts {
                type uint64;
                description
                  "Punt global policer drop packets";
              }
    
              leaf punt-global-policer-drop-octets {
                type uint64;
                description
                  "Punt global policer drop octets";
              }
    
              leaf esf-tc-drop-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) traffic classification drop packets";
              }
    
              leaf esf-tc-drop-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) traffic classification drop octets";
              }
    
              leaf esf-drl-drop-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) dynamic rate limit drop packets";
              }
    
              leaf esf-drl-drop-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) dynamic rate limit drop octets";
              }
    
              leaf ess-ipsub-drop-pkts {
                type uint64;
                description
                  "Edge switching services IP subscriber drop packets";
              }
    
              leaf ess-ipsub-drop-octets {
                type uint64;
                description
                  "Edge switching services IP subscriber drop octets";
              }
    
              leaf ess-ipsub-fsol-drop-pkts {
                type uint64;
                description
                  "Edge switching services IP subscriber first sign of
    life drop packets";
              }
    
              leaf ess-ipsub-fsol-drop-octets {
                type uint64;
                description
                  "Edge switching services IP subscriber first sign of
    life drop octets";
              }
    
              leaf ess-ipsub-classifier-drop-pkts {
                type uint64;
                description
                  "Edge switching services IP subscriber classifier drop packets";
              }
    
              leaf ess-ipsub-classifier-drop-octets {
                type uint64;
                description
                  "Edge switching services IP subscriber classifier drop octets";
              }
    
              leaf ess-ipsub-ka-drop-pkts {
                type uint64;
                description
                  "Edge switching services IP subscriber keepalive drop packets";
              }
    
              leaf ess-ipsub-ka-drop-octets {
                type uint64;
                description
                  "Edge switching services IP subscriber keepalive drop octets";
              }
    
              leaf oam-loopback-pkts {
                type uint64;
                description
                  "Operations, administration and management (OAM) loopback packets";
              }
    
              leaf oam-loopback-octets {
                type uint64;
                description
                  "Operations, administration and management (OAM) loopback octets";
              }
    
              leaf unconfigured-ipv4-fia-pkts {
                type uint64;
                description
                  "Unconfigured IPv4 feature invocation array (FIA) packets";
              }
    
              leaf unconfigured-ipv4-fia-octets {
                type uint64;
                description
                  "Unconfigured IPv4 feature invocation array (FIA) octets";
              }
    
              leaf unconfigured-ipv6-fia-pkts {
                type uint64;
                description
                  "Unconfigured IPv6 feature invocation array (FIA) packets";
              }
    
              leaf unconfigured-ipv6-fia-octets {
                type uint64;
                description
                  "Unconfigured IPv6 feature invocation array (FIA) octets";
              }
    
              leaf unconfigured-mpls-fia-pkts {
                type uint64;
                description
                  "Unconfigured multiprotocol label switching (MPLS) feature invocation array (FIA) packets";
              }
    
              leaf unconfigured-mpls-fia-octets {
                type uint64;
                description
                  "Unconfigured multiprotocol label switching (MPLS) feature invocation array (FIA) octets";
              }
    
              leaf smi-disabled-pkts {
                type uint64;
                description
                  "Simple management interface disabled packets";
              }
    
              leaf smi-disabled-octets {
                type uint64;
                description
                  "Simple management interface disabled octets";
              }
    
              leaf oce-drop-adj-pkts {
                type uint64;
                description
                  "Output chain element (OCE) drop adjacency packets";
              }
    
              leaf oce-drop-adj-octets {
                type uint64;
                description
                  "Output chain element (OCE) drop adjacency octets";
              }
    
              leaf internal-pkts {
                type uint64;
                description "Internal packets";
              }
    
              leaf internal-octets {
                type uint64;
                description "Internal octets";
              }
    
              leaf inv-spa-hdr-pkts {
                type uint64;
                description
                  "Invalid shared port adaptor (SPA) header packets";
              }
    
              leaf inv-spa-hdr-octets {
                type uint64;
                description
                  "Invalid shared port adaptor (SPA) header octets";
              }
    
              leaf ppe-exception-pkts {
                type uint64;
                description
                  "Packet processing engine exception packets";
              }
    
              leaf ppe-exception-octets {
                type uint64;
                description
                  "Packet processing engine exception octets";
              }
    
              leaf internal-replication-pkts {
                type uint64;
                description
                  "Internal replication packets";
              }
    
              leaf internal-replication-octets {
                type uint64;
                description
                  "Internal replication octets";
              }
    
              leaf internal-recycle-tail-pkts {
                type uint64;
                description
                  "Internal recycle tail packets";
              }
    
              leaf internal-recycle-tail-octets {
                type uint64;
                description
                  "Internal recycle tail octets";
              }
    
              leaf internal-no-gpm-pkts {
                type uint64;
                description
                  "Internal no global packet memory packets";
              }
    
              leaf internal-no-gpm-octets {
                type uint64;
                description
                  "Internal no global packet memory octets";
              }
    
              leaf internal-no-channel-mem-pkts {
                type uint64;
                description
                  "Internal no channel memory packets";
              }
    
              leaf internal-no-channel-mem-octets {
                type uint64;
                description
                  "Internal no channel memory octets";
              }
    
              leaf ip-sia-hdr-err-pkts {
                type uint64;
                description
                  "IP service insertion architecture (SIA) header error packets";
              }
    
              leaf ip-sia-hdr-err-octets {
                type uint64;
                description
                  "IP service insertion architecture (SIA) header error octets";
              }
    
              leaf ip-sia-hop-limit-exceeded-pkts {
                type uint64;
                description
                  "IP service insertion architecture (SIA) hop limit exceeded packets";
              }
    
              leaf ip-sia-hop-limit-exceeded-octets {
                type uint64;
                description
                  "IP service insertion architecture (SIA) hop limit exceeded octets";
              }
    
              leaf ip-sia-processing-err-pkts {
                type uint64;
                description
                  "IP service insertion architecture (SIA) processing error packets";
              }
    
              leaf ip-sia-processing-err-octets {
                type uint64;
                description
                  "IP service insertion architecture (SIA) processing error octets";
              }
    
              leaf sslvpn-svi-invalid-h-pkts {
                type uint64;
                description
                  "SSL VPN switched virtual interface (SVI) invalid header packets";
              }
    
              leaf sslvpn-svi-invalid-h-octets {
                type uint64;
                description
                  "SSL VPN switched virtual interface (SVI) invalid header octets";
              }
    
              leaf esf-acct-exceed-drop-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) accounting exceed drop packets";
              }
    
              leaf esf-acct-exceed-drop-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) accounting exceed drop octets";
              }
    
              leaf tcp-pkts {
                type uint64;
                description "TCP packets";
              }
    
              leaf tcp-octets {
                type uint64;
                description "TCP octets";
              }
    
              leaf invalid-encap-pkts {
                type uint64;
                description
                  "Invalid encapsulation packets";
              }
    
              leaf invalid-encap-octets {
                type uint64;
                description
                  "Invalid encapsulation octets";
              }
    
              leaf dsp-pkts {
                type uint64;
                description
                  "Digital signal processing (DSP) packets";
              }
    
              leaf dsp-octets {
                type uint64;
                description
                  "Digital signal processing (DSP) octets";
              }
    
              leaf mpls-csc-drop-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) carrier supporting carrier drop packets";
              }
    
              leaf mpls-csc-drop-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) carrier supporting carrier drop octets";
              }
    
              leaf cstp-cdtp-inv-frame-pkts {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol invalid frame packets";
              }
    
              leaf cstp-cdtp-inv-frame-octets {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol invalid frame octets";
              }
    
              leaf cstp-cdtp-no-tunnel-pkts {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol no tunnel packets";
              }
    
              leaf cstp-cdtp-no-tunnel-octets {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol no tunnel octets";
              }
    
              leaf cstp-cdtp-unsup-frame-pkts {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol unsupported frame packets";
              }
    
              leaf cstp-cdtp-unsup-frame-octets {
                type uint64;
                description
                  "Cisco SSL tunneling Protocol Cisco DTLS tunneling Protocol unsupported frame octets";
              }
    
              leaf esf-l4r-trans-sess-limit-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect trans session limit packets";
              }
    
              leaf esf-l4r-trans-sess-limit-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) layer 4 redirect trans session limit octets";
              }
    
              leaf lisp-elig-oce-pkts {
                type uint64;
                description
                  "LISP eligible output chain element (OCE) packets";
              }
    
              leaf lisp-elig-oce-octets {
                type uint64;
                description
                  "LISP eligible output chain element (OCE) octets";
              }
    
              leaf lisp-misconfiguration-pkts {
                type uint64;
                description
                  "LISP misconfiguration packets";
              }
    
              leaf lisp-misconfiguration-octets {
                type uint64;
                description
                  "LISP misconfiguration octets";
              }
    
              leaf lisp-disabled-pkts {
                type uint64;
                description
                  "LISP disabled packets";
              }
    
              leaf lisp-disabled-octets {
                type uint64;
                description
                  "LISP disabled octets";
              }
    
              leaf lisp-decap-failed-pkts {
                type uint64;
                description
                  "LISP deencapsulation failed packets";
              }
    
              leaf lisp-decap-failed-octets {
                type uint64;
                description
                  "LISP deencapsulation failed octets";
              }
    
              leaf lisp-hash-lkup-failed-pkts {
                type uint64;
                description
                  "LISP hash lookup failed packets";
              }
    
              leaf lisp-hash-lkup-failed-octets {
                type uint64;
                description
                  "LISP hash lookup failed octets";
              }
    
              leaf lisp-failed-to-punt-lsb-mismatch-pkts {
                type uint64;
                description
                  "LISP failed to punt lsb mismatch packets";
              }
    
              leaf lisp-failed-to-punt-lsb-mismatch-octets {
                type uint64;
                description
                  "LISP failed to punt lsb mismatch octets";
              }
    
              leaf nat64-v6tov4-pkts {
                type uint64;
                description
                  "NAT64 IPv6 to IPv4 packets";
              }
    
              leaf nat64-v6tov4-octets {
                type uint64;
                description
                  "NAT64 IPv6 to IPv4 octets";
              }
    
              leaf nat64-v4tov6-pkts {
                type uint64;
                description
                  "NAT64 IPv4 to IPv6 packets";
              }
    
              leaf nat64-v4tov6-octets {
                type uint64;
                description
                  "NAT64 IPv4 to IPv6 octets";
              }
    
              leaf tunnel-sec-chk-fail-pkts {
                type uint64;
                description
                  "Tunnel security check fail packets";
              }
    
              leaf tunnel-sec-chk-fail-octets {
                type uint64;
                description
                  "Tunnel security check fail octets";
              }
    
              leaf servicewire-hdr-err-pkts {
                type uint64;
                description
                  "Servicewire header error packets";
              }
    
              leaf servicewire-hdr-err-octets {
                type uint64;
                description
                  "Servicewire header error octets";
              }
    
              leaf servicewire-hop-limit-exceeded-pkts {
                type uint64;
                description
                  "Servicewire hop limit exceeded packets";
              }
    
              leaf servicewire-hop-limit-exceeded-octets {
                type uint64;
                description
                  "Servicewire hop limit exceeded octets";
              }
    
              leaf servicewire-processing-err-pkts {
                type uint64;
                description
                  "Servicewire processing error packets";
              }
    
              leaf servicewire-processing-err-octets {
                type uint64;
                description
                  "Servicewire processing error octets";
              }
    
              leaf l2bd-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) packets";
              }
    
              leaf l2bd-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) octets";
              }
    
              leaf tcp-bp-sslvpn-pkts {
                type uint64;
                description
                  "TCP back pressure SSL VPN packets";
              }
    
              leaf tcp-bp-sslvpn-octets {
                type uint64;
                description
                  "TCP back pressure SSL VPN octets";
              }
    
              leaf evc-efp-egress-filter-pkts {
                type uint64;
                description
                  "Ethernet virtual connection (EVC) ethernet flowpoint (EFP) egress filter packets";
              }
    
              leaf evc-efp-egress-filter-octets {
                type uint64;
                description
                  "Ethernet virtual connection (EVC) ethernet flowpoint (EFP) egress filter octets";
              }
    
              leaf sslvpn-svi-if-err-pkts {
                type uint64;
                description
                  "SSL VPN switched virtual interface (SVI) interface error packets";
              }
    
              leaf sslvpn-svi-if-err-octets {
                type uint64;
                description
                  "SSL VPN switched virtual interface (SVI) interface error octets";
              }
    
              leaf sslvpn-ctx-null-pkts {
                type uint64;
                description
                  "SSL VPN ctx null packets";
              }
    
              leaf sslvpn-ctx-null-octets {
                type uint64;
                description
                  "SSL VPN ctx null octets";
              }
    
              leaf sslvpn-ctx-not-alive-pkts {
                type uint64;
                description
                  "SSL VPN ctx not alive packets";
              }
    
              leaf sslvpn-ctx-not-alive-octets {
                type uint64;
                description
                  "SSL VPN ctx not alive octets";
              }
    
              leaf sslvpn-invalid-pkt-pkts {
                type uint64;
                description
                  "SSL VPN invalid packets";
              }
    
              leaf sslvpn-invalid-pkt-octets {
                type uint64;
                description
                  "SSL VPN invalid packet octets";
              }
    
              leaf sslvpn-socket-wr-err-pkts {
                type uint64;
                description
                  "SSL VPN socket write error packets";
              }
    
              leaf sslvpn-socket-wr-err-octets {
                type uint64;
                description
                  "SSL VPN socket write error octets";
              }
    
              leaf sslvpn-pkt-rc-err-pkts {
                type uint64;
                description
                  "SSL VPN packet return code error packets";
              }
    
              leaf sslvpn-pkt-rc-err-octets {
                type uint64;
                description
                  "SSL VPN packet return code error octets";
              }
    
              leaf sslvpn-null-rc-pkts {
                type uint64;
                description
                  "SSL VPN null return code packets";
              }
    
              leaf sslvpn-null-rc-octets {
                type uint64;
                description
                  "SSL VPN null return code octets";
              }
    
              leaf sslvpn-wrong-pkt-type-pkts {
                type uint64;
                description
                  "SSL VPN wrong packet type packets";
              }
    
              leaf sslvpn-wrong-pkt-type-octets {
                type uint64;
                description
                  "SSL VPN wrong packet type octets";
              }
    
              leaf sslvpn-not-ssl-record-pkts {
                type uint64;
                description
                  "SSL VPN not ssl record packets";
              }
    
              leaf sslvpn-not-ssl-record-octets {
                type uint64;
                description
                  "SSL VPN not ssl record octets";
              }
    
              leaf firewall-syncookie-pkts {
                type uint64;
                description
                  "Firewall syncookie packets";
              }
    
              leaf firewall-syncookie-octets {
                type uint64;
                description
                  "Firewall syncookie octets";
              }
    
              leaf l2bd-mac-security-violation-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security violation packets";
              }
    
              leaf l2bd-mac-security-violation-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security violation octets";
              }
    
              leaf l2bd-src-filter-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) source filter packets";
              }
    
              leaf l2bd-src-filter-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) source filter octets";
              }
    
              leaf l2bd-policy-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) policy packets";
              }
    
              leaf l2bd-policy-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) policy octets";
              }
    
              leaf l2bd-repl-start-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) replication start packets";
              }
    
              leaf l2bd-repl-start-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) replication start octets";
              }
    
              leaf l2bd-repl-end-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) replication end packets";
              }
    
              leaf l2bd-repl-end-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) replication end octets";
              }
    
              leaf l2bd-recycle-tail-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) recycle tail packets";
              }
    
              leaf l2bd-recycle-tail-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) recycle tail octets";
              }
    
              leaf l2bd-static-mac-move-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) static MAC move packets";
              }
    
              leaf l2bd-static-mac-move-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) static MAC move octets";
              }
    
              leaf l2bd-bd-disabled-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) bridge domain disabled packets";
              }
    
              leaf l2bd-bd-disabled-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) bridge domain disabled octets";
              }
    
              leaf l2bd-inject-no-sb-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) inject no sub block packets";
              }
    
              leaf l2bd-inject-no-sb-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) inject no sub block octets";
              }
    
              leaf l2bd-inject-invalid-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) inject invalid packets";
              }
    
              leaf l2bd-inject-invalid-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) inject invalid octets";
              }
    
              leaf l2bd-stp-state-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) spanning tree (STP) state packets";
              }
    
              leaf l2bd-stp-state-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) spanning tree (STP) state octets";
              }
    
              leaf l2bd-storm-ctrl-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) storm ctrl packets";
              }
    
              leaf l2bd-storm-ctrl-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) storm ctrl octets";
              }
    
              leaf sslvpn-coprocessor-err-pkts {
                type uint64;
                description
                  "SSL VPN coprocessor error packets";
              }
    
              leaf sslvpn-coprocessor-err-octets {
                type uint64;
                description
                  "SSL VPN coprocessor error octets";
              }
    
              leaf sslvpn-tail-drop-pkts {
                type uint64;
                description
                  "SSL VPN tail drop packets";
              }
    
              leaf sslvpn-tail-drop-octets {
                type uint64;
                description
                  "SSL VPN tail drop octets";
              }
    
              leaf ecfm-pkts {
                type uint64;
                description
                  "Ethernet connection fault management (ECFM) packets";
              }
    
              leaf ecfm-octets {
                type uint64;
                description
                  "Ethernet connection fault management (ECFM) octets";
              }
    
              leaf ipv4mc-oif-rpf-failed-pkts {
                type uint64;
                description
                  "IPv4 multicast output interface reverse path forwarding failed packets";
              }
    
              leaf ipv4mc-oif-rpf-failed-octets {
                type uint64;
                description
                  "IPv4 multicast output interface reverse path forwarding failed octets";
              }
    
              leaf ipv6mc-oif-rpf-failed-pkts {
                type uint64;
                description
                  "IPv6 multicast output interface reverse path forwarding failed packets";
              }
    
              leaf ipv6mc-oif-rpf-failed-octets {
                type uint64;
                description
                  "IPv6 multicast output interface reverse path forwarding failed octets";
              }
    
              leaf ipv6-pbr-pkts {
                type uint64;
                description
                  "IPv6 policy based routing (PBR) packets";
              }
    
              leaf ipv6-pbr-octets {
                type uint64;
                description
                  "IPv6 policy based routing (PBR) octets";
              }
    
              leaf sslvpn-coprocessor-state-not-set-pkts {
                type uint64;
                description
                  "SSL VPN coprocessor state not set packets";
              }
    
              leaf sslvpn-coprocessor-state-not-set-octets {
                type uint64;
                description
                  "SSL VPN coprocessor state not set octets";
              }
    
              leaf sslvpn-coprocessor-state-reply-not-set-pkts {
                type uint64;
                description
                  "SSL VPN coprocessor state reply not set packets";
              }
    
              leaf sslvpn-coprocessor-state-reply-not-set-octets {
                type uint64;
                description
                  "SSL VPN coprocessor state reply not set octets";
              }
    
              leaf sslvpn-neg-ssl-rec-pad-len-pkts {
                type uint64;
                description
                  "SSL VPN negotiated SSL record pad length packets";
              }
    
              leaf sslvpn-neg-ssl-rec-pad-len-octets {
                type uint64;
                description
                  "SSL VPN negotiated SSL record pad length octets";
              }
    
              leaf sslvpn-inv-ssl-rec-pkts {
                type uint64;
                description
                  "SSL VPN invalid SSL record packets";
              }
    
              leaf sslvpn-inv-ssl-rec-octets {
                type uint64;
                description
                  "SSL VPN invalid SSL record octets";
              }
    
              leaf sslvpn-not-ssl-rec-rc-pkts {
                type uint64;
                description
                  "SSL VPN not SSL record return code packets";
              }
    
              leaf sslvpn-not-ssl-rec-rc-octets {
                type uint64;
                description
                  "SSL VPN not SSL record return code octets";
              }
    
              leaf sslvpn-ssl-rec-not-pkt-pkts {
                type uint64;
                description
                  "SSL VPN SSL record not packets";
              }
    
              leaf sslvpn-ssl-rec-not-pkt-octets {
                type uint64;
                description
                  "SSL VPN SSL record not packet octets";
              }
    
              leaf sslvpn-add-ssl-rec-hdr-err-pkts {
                type uint64;
                description
                  "SSL VPN add SSL record header error packets";
              }
    
              leaf sslvpn-add-ssl-rec-hdr-err-octets {
                type uint64;
                description
                  "SSL VPN add SSL record header error octets";
              }
    
              leaf sslvpn-null-session-pkts {
                type uint64;
                description
                  "SSL VPN null session packets";
              }
    
              leaf sslvpn-null-session-octets {
                type uint64;
                description
                  "SSL VPN null session octets";
              }
    
              leaf sslvpn-invalid-session-pkts {
                type uint64;
                description
                  "SSL VPN invalid session packets";
              }
    
              leaf sslvpn-invalid-session-octets {
                type uint64;
                description
                  "SSL VPN invalid session octets";
              }
    
              leaf sslvpn-empty-pkt-pkts {
                type uint64;
                description
                  "SSL VPN empty packets";
              }
    
              leaf sslvpn-empty-pkt-octets {
                type uint64;
                description
                  "SSL VPN empty packet octets";
              }
    
              leaf ipv4-reass-tail-drop-pkts {
                type uint64;
                description
                  "IPv4 reassembly tail drop packets";
              }
    
              leaf ipv4-reass-tail-drop-octets {
                type uint64;
                description
                  "IPv4 reassembly tail drop octets";
              }
    
              leaf ipv6-reass-tail-drop-pkts {
                type uint64;
                description
                  "IPv6 reassembly tail drop packets";
              }
    
              leaf ipv6-reass-tail-drop-octets {
                type uint64;
                description
                  "IPv6 reassembly tail drop octets";
              }
    
              leaf ipv4mc-nat-in2out-pkts {
                type uint64;
                description
                  "IPv4 multicast NAT in to out packets";
              }
    
              leaf ipv4mc-nat-in2out-octets {
                type uint64;
                description
                  "IPv4 multicast NAT in to out octets";
              }
    
              leaf ipv4mc-nat-out2in-pkts {
                type uint64;
                description
                  "IPv4 multicast NAT out to in packets";
              }
    
              leaf ipv4mc-nat-out2in-octets {
                type uint64;
                description
                  "IPv4 multicast NAT out to in octets";
              }
    
              leaf fia-error-pkts {
                type uint64;
                description
                  "Feature invocation array (FIA) error packets";
              }
    
              leaf fia-error-octets {
                type uint64;
                description
                  "Feature invocation array (FIA) error octets";
              }
    
              leaf firewall-syncookie-max-dst-pkts {
                type uint64;
                description
                  "Firewall syncookie maximum dst packets";
              }
    
              leaf firewall-syncookie-max-dst-octets {
                type uint64;
                description
                  "Firewall syncookie maximum dst octets";
              }
    
              leaf ipv4-urpf-loose-failed-pkts {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding loose failed packets";
              }
    
              leaf ipv4-urpf-loose-failed-octets {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding loose failed octets";
              }
    
              leaf ipv4-urpf-strict-failed-pkts {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding strict failed packets";
              }
    
              leaf ipv4-urpf-strict-failed-octets {
                type uint64;
                description
                  "IPv4 unicast reverse path forwarding strict failed octets";
              }
    
              leaf ipv6-urpf-loose-failed-pkts {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding loose failed packets";
              }
    
              leaf ipv6-urpf-loose-failed-octets {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding loose failed octets";
              }
    
              leaf ipv6-urpf-strict-failed-pkts {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding strict failed packets";
              }
    
              leaf ipv6-urpf-strict-failed-octets {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding strict failed octets";
              }
    
              leaf ipv6-urpf-null-path-list-pkts {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding null path list packets";
              }
    
              leaf ipv6-urpf-null-path-list-octets {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding null path list octets";
              }
    
              leaf ipv6-urpf-no-fib-pkts {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding no fib packets";
              }
    
              leaf ipv6-urpf-no-fib-octets {
                type uint64;
                description
                  "IPv6 unicast reverse path forwarding no fib octets";
              }
    
              leaf unknown-mcast-pkt-type-pkts {
                type uint64;
                description
                  "Unknown multicast packet type packets";
              }
    
              leaf unknown-mcast-pkt-type-octets {
                type uint64;
                description
                  "Unknown multicast packet type octets";
              }
    
              leaf l2v4mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "Layer 2 IPv4 multicast invalid replica record packets";
              }
    
              leaf l2v4mc-invalid-replica-record-octets {
                type uint64;
                description
                  "Layer 2 IPv4 multicast invalid replica record octets";
              }
    
              leaf l2v6mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "Layer 2 IPv6 multicast invalid replica record packets";
              }
    
              leaf l2v6mc-invalid-replica-record-octets {
                type uint64;
                description
                  "Layer 2 IPv6 multicast invalid replica record octets";
              }
    
              leaf l2mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "Layer 2 multicast invalid replica record packets";
              }
    
              leaf l2mc-invalid-replica-record-octets {
                type uint64;
                description
                  "Layer 2 multicast invalid replica record octets";
              }
    
              leaf lsm-invalid-replica-record-pkts {
                type uint64;
                description
                  "Label switch multicast invalid replica record packets";
              }
    
              leaf lsm-invalid-replica-record-octets {
                type uint64;
                description
                  "Label switch multicast invalid replica record octets";
              }
    
              leaf cts-format-pkts {
                type uint64;
                description
                  "Cisco trustsec format packets";
              }
    
              leaf cts-format-octets {
                type uint64;
                description
                  "Cisco trustsec format octets";
              }
    
              leaf cts-not-enable-pkts {
                type uint64;
                description
                  "Cisco trustsec not enable packets";
              }
    
              leaf cts-not-enable-octets {
                type uint64;
                description
                  "Cisco trustsec not enable octets";
              }
    
              leaf idle-packet-pkts {
                type uint64;
                description "Idle packets";
              }
    
              leaf idle-packet-octets {
                type uint64;
                description "Idle packet octets";
              }
    
              leaf mfr-pkts {
                type uint64;
                description
                  "Multilink frame relay packets";
              }
    
              leaf mfr-octets {
                type uint64;
                description
                  "Multilink frame relay octets";
              }
    
              leaf ar-tx-pkts {
                type uint64;
                description
                  "Asymmetric routing transmit packets";
              }
    
              leaf ar-tx-octets {
                type uint64;
                description
                  "Asymmetric routing transmit octets";
              }
    
              leaf ar-rx-pkts {
                type uint64;
                description
                  "Asymmetric routing receive packets";
              }
    
              leaf ar-rx-octets {
                type uint64;
                description
                  "Asymmetric routing receive octets";
              }
    
              leaf ar-standby-pkts {
                type uint64;
                description
                  "Asymmetric routing standby packets";
              }
    
              leaf ar-standby-octets {
                type uint64;
                description
                  "Asymmetric routing standby octets";
              }
    
              leaf ar-fnf-clnup-pkts {
                type uint64;
                description
                  "Asymmetric routing flexible netflow cleanup packets";
              }
    
              leaf ar-fnf-clnup-octets {
                type uint64;
                description
                  "Asymmetric routing flexible netflow cleanup octets";
              }
    
              leaf mac-mcast-ip-nonmcast-pkts {
                type uint64;
                description
                  "MAC multicast IP not multicast packets";
              }
    
              leaf mac-mcast-ip-nonmcast-octets {
                type uint64;
                description
                  "MAC multicast IP not multicast octets";
              }
    
              leaf bfd-pkts {
                type uint64;
                description
                  "Bidirectional fault detection (BFD) packets";
              }
    
              leaf bfd-octets {
                type uint64;
                description
                  "Bidirectional fault detection (BFD) octets";
              }
    
              leaf bundle-oce-pkts {
                type uint64;
                description
                  "Bundle output chain element (OCE) packets";
              }
    
              leaf bundle-oce-octets {
                type uint64;
                description
                  "Bundle output chain element (OCE) octets";
              }
    
              leaf bqs-oor-pri-pkts {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources priority packets";
              }
    
              leaf bqs-oor-pri-octets {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources priority octets";
              }
    
              leaf bqs-oor-pak-pri-pkts {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources packet priority packets";
              }
    
              leaf bqs-oor-pak-pri-octets {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources packet priority octets";
              }
    
              leaf bqs-oor-vital-pkts {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources vital packets";
              }
    
              leaf bqs-oor-vital-octets {
                type uint64;
                description
                  "Buffering, queuing and scheduling out of resources vital octets";
              }
    
              leaf epc-pkts {
                type uint64;
                description
                  "Embedded packet capture packets";
              }
    
              leaf epc-octets {
                type uint64;
                description
                  "Embedded packet capture octets";
              }
    
              leaf lisp-failed-to-punt-dynmaic-eid-config-pkts {
                type uint64;
                description
                  "LISP failed to punt dynamic embedded identifier config packets";
              }
    
              leaf lisp-failed-to-punt-dynmaic-eid-config-octets {
                type uint64;
                description
                  "LISP failed to punt dynamic embedded identifier config octets";
              }
    
              leaf sv-match-fail-pkts {
                type uint64;
                description
                  "SV match fail packets";
              }
    
              leaf sv-match-fail-octets {
                type uint64;
                description
                  "SV match fail octets";
              }
    
              leaf cblbf-null-repllist-pkts {
                type uint64;
                description
                  "Cable bundle flood null replication list packets";
              }
    
              leaf cblbf-null-repllist-octets {
                type uint64;
                description
                  "Cable bundle flood null replication list octets";
              }
    
              leaf cblbf-repl-fail-pkts {
                type uint64;
                description
                  "Cable bundle flood replication fail packets";
              }
    
              leaf cblbf-repl-fail-octets {
                type uint64;
                description
                  "Cable bundle flood replication fail octets";
              }
    
              leaf cblbf-repl-start-pkts {
                type uint64;
                description
                  "Cable bundle flood replication start packets";
              }
    
              leaf cblbf-repl-start-octets {
                type uint64;
                description
                  "Cable bundle flood replication start octets";
              }
    
              leaf cblbf-repl-end-pkts {
                type uint64;
                description
                  "Cable bundle flood replication end packets";
              }
    
              leaf cblbf-repl-end-octets {
                type uint64;
                description
                  "Cable bundle flood replication end octets";
              }
    
              leaf cblbf-recycle-tail-pkts {
                type uint64;
                description
                  "Cable bundle flood recycle tail packets";
              }
    
              leaf cblbf-recycle-tail-octets {
                type uint64;
                description
                  "Cable bundle flood recycle tail octets";
              }
    
              leaf cblbf-fwdint-down-pkts {
                type uint64;
                description
                  "Cable bundle flood forwarding interface down packets";
              }
    
              leaf cblbf-fwdint-down-octets {
                type uint64;
                description
                  "Cable bundle flood forwarding interface down octets";
              }
    
              leaf cable-p2pl-oce-ptr-null-pkts {
                type uint64;
                description
                  "Cable P2PL output chain element (OCE) pointer null packets";
              }
    
              leaf cable-p2pl-oce-ptr-null-octets {
                type uint64;
                description
                  "Cable P2PL output chain element (OCE) pointer null octets";
              }
    
              leaf cable-mc-invalid-replica-record-pkts {
                type uint64;
                description
                  "Cable multicast invalid replica record packets";
              }
    
              leaf cable-mc-invalid-replica-record-octets {
                type uint64;
                description
                  "Cable multicast invalid replica record octets";
              }
    
              leaf no-def-jib-pkts {
                type uint64;
                description
                  "No default JIB packets";
              }
    
              leaf no-def-jib-octets {
                type uint64;
                description
                  "No default JIB octets";
              }
    
              leaf no-inj-jib-pkts {
                type uint64;
                description "No inj JIB packets";
              }
    
              leaf no-inj-jib-octets {
                type uint64;
                description "No inj JIB octets";
              }
    
              leaf onefw-pkts {
                type uint64;
                description "Firewall packets";
              }
    
              leaf onefw-octets {
                type uint64;
                description "Firewall octets";
              }
    
              leaf ccm-tx-pkts {
                type uint64;
                description
                  "CCM transmit packets";
              }
    
              leaf ccm-tx-octets {
                type uint64;
                description
                  "CCM transmit octets";
              }
    
              leaf appnav-sn-pkt-invalid-pkts {
                type uint64;
                description
                  "APPNAV Service Node (SN) packet invalid packets";
              }
    
              leaf appnav-sn-pkt-invalid-octets {
                type uint64;
                description
                  "APPNAV Service Node (SN) packet invalid octets";
              }
    
              leaf appnav-internal-err-pkts {
                type uint64;
                description
                  "APPNAV internal error packets";
              }
    
              leaf appnav-internal-err-octets {
                type uint64;
                description
                  "APPNAV internal error octets";
              }
    
              leaf appnav-badroute-pkts {
                type uint64;
                description
                  "APPNAV bad route packets";
              }
    
              leaf appnav-badroute-octets {
                type uint64;
                description
                  "APPNAV bad route octets";
              }
    
              leaf appnav-notunnel-pkts {
                type uint64;
                description
                  "APPNAV no tunnel packets";
              }
    
              leaf appnav-notunnel-octets {
                type uint64;
                description
                  "APPNAV no tunnel octets";
              }
    
              leaf appnav-nosvcctx-pkts {
                type uint64;
                description
                  "APPNAV no SVC context packets";
              }
    
              leaf appnav-nosvcctx-octets {
                type uint64;
                description
                  "APPNAV no SVC context octets";
              }
    
              leaf appnav-inv-flow-state-pkts {
                type uint64;
                description
                  "APPNAV invalid flow state packets";
              }
    
              leaf appnav-inv-flow-state-octets {
                type uint64;
                description
                  "APPNAV invalid flow state octets";
              }
    
              leaf appnav-unexpected-pkt-pkts {
                type uint64;
                description
                  "APPNAV unexpected packets";
              }
    
              leaf appnav-unexpected-pkt-octets {
                type uint64;
                description
                  "APPNAV unexpected packet octets";
              }
    
              leaf rl2gp-non-tcb-pkts {
                type uint64;
                description
                  "Reverse layer 2 gateway protocol(R-L2GP) non topology change bridge protocol unit (TCB) packets";
              }
    
              leaf rl2gp-non-tcb-octets {
                type uint64;
                description
                  "Reverse layer 2 gateway protocol(R-L2GP) non topology change bridge protocol unit (TCB) octets";
              }
    
              leaf tunnel-pkt-sb-missed-pkts {
                type uint64;
                description
                  "Tunnel packet sub block missed packets";
              }
    
              leaf tunnel-pkt-sb-missed-octets {
                type uint64;
                description
                  "Tunnel packet sub block missed octets";
              }
    
              leaf fhs-pkt-invalid-pkts {
                type uint64;
                description
                  "First hop security packet invalid packets";
              }
    
              leaf fhs-pkt-invalid-octets {
                type uint64;
                description
                  "First hop security packet invalid octets";
              }
    
              leaf fhs-pkt-dropped-pkts {
                type uint64;
                description
                  "First hop security packet dropped packets";
              }
    
              leaf fhs-pkt-dropped-octets {
                type uint64;
                description
                  "First hop security packet dropped octets";
              }
    
              leaf tunnel-sgre-virtual-mac-mismatch-pkts {
                type uint64;
                description
                  "Tunnel secure generic routing encapsulation (sGRE) virtual MAC mismatch packets";
              }
    
              leaf tunnel-sgre-virtual-mac-mismatch-octets {
                type uint64;
                description
                  "Tunnel secure generic routing encapsulation (sGRE) virtual MAC mismatch octets";
              }
    
              leaf tunnel-sgre-unsupported-proto-pkts {
                type uint64;
                description
                  "Tunnel secure generic routing encapsulation (sGRE) unsupported protocol packets";
              }
    
              leaf tunnel-sgre-unsupported-proto-octets {
                type uint64;
                description
                  "Tunnel secure generic routing encapsulation (sGRE) unsupported protocol octets";
              }
    
              leaf mpls-gal-check-non-gal-dropped-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check non generic associated channel label (GAL) dropped packets";
              }
    
              leaf mpls-gal-check-non-gal-dropped-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check non generic associated channel label (GAL) dropped octets";
              }
    
              leaf mpls-gal-check-non-eos-dropped-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check non end of stack dropped packets";
              }
    
              leaf mpls-gal-check-non-eos-dropped-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check non end of stack dropped octets";
              }
    
              leaf mpls-gal-check-invalid-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check invalid packets";
              }
    
              leaf mpls-gal-check-invalid-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) check invalid octets";
              }
    
              leaf mpls-gal-exception-non-eos-dropped-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) exception non end of stack dropped packets";
              }
    
              leaf mpls-gal-exception-non-eos-dropped-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) exception non end of stack dropped octets";
              }
    
              leaf mpls-gal-exception-non-gach-dropped-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) exception non generic associated channel (GACH) dropped packets";
              }
    
              leaf mpls-gal-exception-non-gach-dropped-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) generic associated channel label (GAL) exception non generic associated channel (GACH) dropped octets";
              }
    
              leaf conf-sw-sess-pkts {
                type uint64;
                description
                  "Configuration software session packets";
              }
    
              leaf conf-sw-sess-octets {
                type uint64;
                description
                  "Configuration software session octets";
              }
    
              leaf tunnel-decap-too-many-times-pkts {
                type uint64;
                description
                  "Tunnel deencapsulation too many times packets";
              }
    
              leaf tunnel-decap-too-many-times-octets {
                type uint64;
                description
                  "Tunnel deencapsulation too many times octets";
              }
    
              leaf loadbalance-null0-pkts {
                type uint64;
                description
                  "Load balance null0 packets";
              }
    
              leaf loadbalance-null0-octets {
                type uint64;
                description
                  "Load balance null0 octets";
              }
    
              leaf gpm-tx-len-exceed-pkts {
                type uint64;
                description
                  "Global packet memory transmit length exceed packets";
              }
    
              leaf gpm-tx-len-exceed-octets {
                type uint64;
                description
                  "Global packet memory transmit length exceed octets";
              }
    
              leaf esf-ffr-drop-pkts {
                type uint64;
                description
                  "Edge switching services feature (ESF) ffr drop packets";
              }
    
              leaf esf-ffr-drop-octets {
                type uint64;
                description
                  "Edge switching services feature (ESF) ffr drop octets";
              }
    
              leaf ec-bundle-enq-pkts {
                type uint64;
                description
                  "Etherchannel bundle enqueue packets";
              }
    
              leaf ec-bundle-enq-octets {
                type uint64;
                description
                  "Etherchannel bundle enqueue octets";
              }
    
              leaf ec-link-tx-pkts {
                type uint64;
                description
                  "Etherchannel link transmit packets";
              }
    
              leaf ec-link-tx-octets {
                type uint64;
                description
                  "Etherchannel link transmit octets";
              }
    
              leaf pfrv3-probe-err-pkts {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) probe error packets";
              }
    
              leaf pfrv3-probe-err-octets {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) probe error octets";
              }
    
              leaf ovl-bad-pkt-pkts {
                type uint64;
                description
                  "Overlay bad packets";
              }
    
              leaf ovl-bad-pkt-octets {
                type uint64;
                description
                  "Overlay bad packet octets";
              }
    
              leaf ovl-l2-filter-pkts {
                type uint64;
                description
                  "Overlay layer 2 filter packets";
              }
    
              leaf ovl-l2-filter-octets {
                type uint64;
                description
                  "Overlay layer 2 filter octets";
              }
    
              leaf dpss-pkts {
                type uint64;
                description
                  "Dataplane service set (DPSS) packets";
              }
    
              leaf dpss-octets {
                type uint64;
                description
                  "Dataplane service set (DPSS) octets";
              }
    
              leaf tunnel-invalid-protocol-pkts {
                type uint64;
                description
                  "Tunnel invalid protocol packets";
              }
    
              leaf tunnel-invalid-protocol-octets {
                type uint64;
                description
                  "Tunnel invalid protocol octets";
              }
    
              leaf pfrv3-at-failure-pkts {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) at failure packets";
              }
    
              leaf pfrv3-at-failure-octets {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) at failure octets";
              }
    
              leaf ipv4-mcast-acl-pkts {
                type uint64;
                description
                  "IPv4 multicast access control list (ACL) packets";
              }
    
              leaf ipv4-mcast-acl-octets {
                type uint64;
                description
                  "IPv4 multicast access control list (ACL) octets";
              }
    
              leaf ipv6-mcast-acl-pkts {
                type uint64;
                description
                  "IPv6 multicast access control list (ACL) packets";
              }
    
              leaf ipv6-mcast-acl-octets {
                type uint64;
                description
                  "IPv6 multicast access control list (ACL) octets";
              }
    
              leaf pprl-sbrl-drop-pkts {
                type uint64;
                description
                  "PPRL source based rate limit drop packets";
              }
    
              leaf pprl-sbrl-drop-octets {
                type uint64;
                description
                  "PPRL source based rate limit drop octets";
              }
    
              leaf cbl-req-arl-drop-pkts {
                type uint64;
                description
                  "Cable request ARP drop packets";
              }
    
              leaf cbl-req-arl-drop-octets {
                type uint64;
                description
                  "Cable request ARP drop octets";
              }
    
              leaf cbl-rep-arl-drop-pkts {
                type uint64;
                description
                  "Cable rep ARP drop packets";
              }
    
              leaf cbl-rep-arl-drop-octets {
                type uint64;
                description
                  "Cable rep ARP drop octets";
              }
    
              leaf appnav-acgreloaddelay-pkts {
                type uint64;
                description
                  "APPNAV reload delay packets";
              }
    
              leaf appnav-acgreloaddelay-octets {
                type uint64;
                description
                  "APPNAV reload delay octets";
              }
    
              leaf ngfw-policy-pkts {
                type uint64;
                description
                  "Next generation firewall (NGFW) policy packets";
              }
    
              leaf ngfw-policy-octets {
                type uint64;
                description
                  "Next generation firewall (NGFW) policy octets";
              }
    
              leaf ngfw-divert-pkts {
                type uint64;
                description
                  "Next generation firewall (NGFW) divert packets";
              }
    
              leaf ngfw-divert-octets {
                type uint64;
                description
                  "Next generation firewall (NGFW) divert octets";
              }
    
              leaf pfrv3-blackhole-pkts {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) black hole packets";
              }
    
              leaf pfrv3-blackhole-octets {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) black hole octets";
              }
    
              leaf pppoe-fctl-pkts {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) flow control packets";
              }
    
              leaf pppoe-fctl-octets {
                type uint64;
                description
                  "PPP over Ethernet (PPPoE) flow control octets";
              }
    
              leaf lisp-sfltr-pkts {
                type uint64;
                description
                  "LISP filtering packets";
              }
    
              leaf lisp-sfltr-octets {
                type uint64;
                description
                  "LISP filtering octets";
              }
    
              leaf flowspec-pkts {
                type uint64;
                description "Flowspec packets";
              }
    
              leaf flowspec-octets {
                type uint64;
                description "Flowspec octets";
              }
    
              leaf identity-cft-error-pkts {
                type uint64;
                description
                  "Identity common flow table error packets";
              }
    
              leaf identity-cft-error-octets {
                type uint64;
                description
                  "Identity common flow table error octets";
              }
    
              leaf bad-us-jib-hdr-pkts {
                type uint64;
                description
                  "Bad us JIB header packets";
              }
    
              leaf bad-us-jib-hdr-octets {
                type uint64;
                description
                  "Bad us JIB header octets";
              }
    
              leaf too-many-mpls-lookup-oce-pkts {
                type uint64;
                description
                  "Too many multiprotocol label switching (MPLS) lookup output chain element (OCE) packets";
              }
    
              leaf too-many-mpls-lookup-oce-octets {
                type uint64;
                description
                  "Too many multiprotocol label switching (MPLS) lookup output chain element (OCE) octets";
              }
    
              leaf cable-prereg-not-cm-pkts {
                type uint64;
                description
                  "Cable pre registration not call manager packets";
              }
    
              leaf cable-prereg-not-cm-octets {
                type uint64;
                description
                  "Cable pre registration not call manager octets";
              }
    
              leaf invalid-virtual-id-pkts {
                type uint64;
                description
                  "Invalid virtual identifier packets";
              }
    
              leaf invalid-virtual-id-octets {
                type uint64;
                description
                  "Invalid virtual identifier octets";
              }
    
              leaf flow-queue-failure-id-pkts {
                type uint64;
                description
                  "Flow queue failure identifier packets";
              }
    
              leaf flow-queue-failure-id-octets {
                type uint64;
                description
                  "Flow queue failure identifier octets";
              }
    
              leaf l2es-input-invalid-tag-pkts {
                type uint64;
                description
                  "Layer 2 embedded ethernet switching input invalid tag packets";
              }
    
              leaf l2es-input-invalid-tag-octets {
                type uint64;
                description
                  "Layer 2 embedded ethernet switching input invalid tag octets";
              }
    
              leaf l2es-input-invalid-svi-pkts {
                type uint64;
                description
                  "Layer 2 embedded ethernet switching input invalid switched virtual interface (SVI) packets";
              }
    
              leaf l2es-input-invalid-svi-octets {
                type uint64;
                description
                  "Layer 2 embedded ethernet switching input invalid switched virtual interface (SVI) octets";
              }
    
              leaf svi-output-invalid-l2sb-pkts {
                type uint64;
                description
                  "Switched virtual interface (SVI) output invalid
    layer 2 sub block packets";
              }
    
              leaf svi-output-invalid-l2sb-octets {
                type uint64;
                description
                  "Switched virtual interface (SVI) output invalid
    layer 2 sub block octets";
              }
    
              leaf svi-input-invalid-mac-pkts {
                type uint64;
                description
                  "Switched virtual interface (SVI) input invalid MAC packets";
              }
    
              leaf svi-input-invalid-mac-octets {
                type uint64;
                description
                  "Switched virtual interface (SVI) input invalid MAC octets";
              }
    
              leaf svi-output-recycle-tail-pkts {
                type uint64;
                description
                  "Switched virtual interface (SVI) output recycle tail packets";
              }
    
              leaf svi-output-recycle-tail-octets {
                type uint64;
                description
                  "Switched virtual interface (SVI) output recycle tail octets";
              }
    
              leaf svi-output-repl-pkts {
                type uint64;
                description
                  "Switched virtual interface (SVI) output replication packets";
              }
    
              leaf svi-output-repl-octets {
                type uint64;
                description
                  "Switched virtual interface (SVI) output replication octets";
              }
    
              leaf svi-repl-end-pkts {
                type uint64;
                description
                  "Switched virtual interface (SVI) replication end packets";
              }
    
              leaf svi-repl-end-octets {
                type uint64;
                description
                  "Switched virtual interface (SVI) replication end octets";
              }
    
              leaf cws-ctx-id-not-found-mob-pkts {
                type uint64;
                description
                  "Cisco wire service (CWS) ctx identifier not found mobile packets";
              }
    
              leaf cws-ctx-id-not-found-mob-octets {
                type uint64;
                description
                  "Cisco wire service (CWS) ctx identifier not found mobile octets";
              }
    
              leaf cws-ctx-id-not-found-conn-pkts {
                type uint64;
                description
                  "Cisco wire service (CWS) ctx identifier not found connection packets";
              }
    
              leaf cws-ctx-id-not-found-conn-octets {
                type uint64;
                description
                  "Cisco wire service (CWS) ctx identifier not found connection octets";
              }
    
              leaf l2cp-cfg-action-pkts {
                type uint64;
                description
                  "Layer 2 control process configuration action packets";
              }
    
              leaf l2cp-cfg-action-octets {
                type uint64;
                description
                  "Layer 2 control process configuration action octets";
              }
    
              leaf perf-lic-policer-lo-pkts {
                type uint64;
                description
                  "Performance license policer lo packets";
              }
    
              leaf perf-lic-policer-lo-octets {
                type uint64;
                description
                  "Performance license policer lo octets";
              }
    
              leaf perf-lic-policer-hi-pkts {
                type uint64;
                description
                  "Performance license policer high packets";
              }
    
              leaf perf-lic-policer-hi-octets {
                type uint64;
                description
                  "Performance license policer high octets";
              }
    
              leaf hqf-tx-error-pkts {
                type uint64;
                description
                  "Hierarchical queuing function transmit error packets";
              }
    
              leaf hqf-tx-error-octets {
                type uint64;
                description
                  "Hierarchical queuing function transmit error octets";
              }
    
              leaf cmd-format-pkts {
                type uint64;
                description
                  "Command format packets";
              }
    
              leaf cmd-format-octets {
                type uint64;
                description
                  "Command format octets";
              }
    
              leaf utd-pkts {
                type uint64;
                description
                  "Universal threat defense packets";
              }
    
              leaf utd-octets {
                type uint64;
                description
                  "Universal threat defense octets";
              }
    
              leaf nat66-in2out-pkts {
                type uint64;
                description
                  "NAT66 in to out packets";
              }
    
              leaf nat66-in2out-octets {
                type uint64;
                description
                  "NAT66 in to out octets";
              }
    
              leaf nat66-out2in-pkts {
                type uint64;
                description
                  "NAT66 out to in packets";
              }
    
              leaf nat66-out2in-octets {
                type uint64;
                description
                  "NAT66 out to in octets";
              }
    
              leaf dsa-no-ip-pkts {
                type uint64;
                description
                  "DNS snooping agent no IP packets";
              }
    
              leaf dsa-no-ip-octets {
                type uint64;
                description
                  "DNS snooping agent no IP octets";
              }
    
              leaf cws-inter-error-pkts {
                type uint64;
                description
                  "Cisco wire service (CWS) inter error packets";
              }
    
              leaf cws-inter-error-octets {
                type uint64;
                description
                  "Cisco wire service (CWS) inter error octets";
              }
    
              leaf utd-sn-pkts {
                type uint64;
                description
                  "Universal threat defense Service Node (SN) packets";
              }
    
              leaf utd-sn-octets {
                type uint64;
                description
                  "Universal threat defense Service Node (SN) octets";
              }
    
              leaf mpls-el-invalid-tag-pkts {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) entropy label invalid tag packets";
              }
    
              leaf mpls-el-invalid-tag-octets {
                type uint64;
                description
                  "Multiprotocol label switching (MPLS) entropy label invalid tag octets";
              }
    
              leaf lisp-failed-to-punt-gsmr-enabled-pkts {
                type uint64;
                description
                  "LISP failed to punt generalized solicit map request enabled packets";
              }
    
              leaf lisp-failed-to-punt-gsmr-enabled-octets {
                type uint64;
                description
                  "LISP failed to punt generalized solicit map request enabled octets";
              }
    
              leaf schain-flow-action-pkts {
                type uint64;
                description
                  "Service chain flow action packets";
              }
    
              leaf schain-flow-action-octets {
                type uint64;
                description
                  "Service chain flow action octets";
              }
    
              leaf opendns-pkts {
                type uint64;
                description "OpenDNS packets";
              }
    
              leaf opendns-octets {
                type uint64;
                description "OpenDNS octets";
              }
    
              leaf capwap-err-pkts {
                type uint64;
                description
                  "CAPWAP error packets";
              }
    
              leaf capwap-err-octets {
                type uint64;
                description
                  "CAPWAP error octets";
              }
    
              leaf capwap-no-uidb-pkts {
                type uint64;
                description
                  "CAPWAP no interface packets";
              }
    
              leaf capwap-no-uidb-octets {
                type uint64;
                description
                  "CAPWAP no interface octets";
              }
    
              leaf dtls-err-pkts {
                type uint64;
                description "DTLS error packets";
              }
    
              leaf dtls-err-octets {
                type uint64;
                description "DTLS error octets";
              }
    
              leaf wlclnt-err-pkts {
                type uint64;
                description
                  "Wireless client error packets";
              }
    
              leaf wlclnt-err-octets {
                type uint64;
                description
                  "Wireless client error octets";
              }
    
              leaf wlclnt-fnf-v9-report-pkts {
                type uint64;
                description
                  "Wireless client flexible netflow v9 report packets";
              }
    
              leaf wlclnt-fnf-v9-report-octets {
                type uint64;
                description
                  "Wireless client flexible netflow v9 report octets";
              }
    
              leaf wlclnt-fnf-v9-err-pkts {
                type uint64;
                description
                  "Wireless client flexible netflow v9 error packets";
              }
    
              leaf wlclnt-fnf-v9-err-octets {
                type uint64;
                description
                  "Wireless client flexible netflow v9 error octets";
              }
    
              leaf cgacl-err-pkts {
                type uint64;
                description
                  "CG Access Control List(CGACL) error packets";
              }
    
              leaf cgacl-err-octets {
                type uint64;
                description
                  "CG Access Control List(CGACL) error octets";
              }
    
              leaf cgacl-lookup-miss-pkts {
                type uint64;
                description
                  "CG Access Control List(CGACL) lookup miss packets";
              }
    
              leaf cgacl-lookup-miss-octets {
                type uint64;
                description
                  "CG Access Control List(CGACL) lookup miss octets";
              }
    
              leaf cgacl-match-pkts {
                type uint64;
                description
                  "CG Access Control List(CGACL) match packets";
              }
    
              leaf cgacl-match-octets {
                type uint64;
                description
                  "CG Access Control List(CGACL) match octets";
              }
    
              leaf cgacl-action-pkts {
                type uint64;
                description
                  "CG Access Control List(CGACL) action packets";
              }
    
              leaf cgacl-action-octets {
                type uint64;
                description
                  "CG Access Control List(CGACL) action octets";
              }
    
              leaf cwfrag-err-pkts {
                type uint64;
                description
                  "Cisco wireservice fragment error packets";
              }
    
              leaf cwfrag-err-octets {
                type uint64;
                description
                  "Cisco wireservice fragment error octets";
              }
    
              leaf pathmgr-measurement-err-pkts {
                type uint64;
                description
                  "Path manager measurement error packets";
              }
    
              leaf pathmgr-measurement-err-octets {
                type uint64;
                description
                  "Path manager measurement error octets";
              }
    
              leaf pathmgr-select-err-pkts {
                type uint64;
                description
                  "Path manager select error packets";
              }
    
              leaf pathmgr-select-err-octets {
                type uint64;
                description
                  "Path manager select error octets";
              }
    
              leaf capwap-reass-frag-consm-pkts {
                type uint64;
                description
                  "CAPWAP reassembly fragments consumed packets";
              }
    
              leaf capwap-reass-frag-consm-octets {
                type uint64;
                description
                  "CAPWAP reassembly fragments consumed octets";
              }
    
              leaf capwap-reass-alloc-err-pkts {
                type uint64;
                description
                  "CAPWAP reassembly allocation error packets";
              }
    
              leaf capwap-reass-alloc-err-octets {
                type uint64;
                description
                  "CAPWAP reassembly allocation error octets";
              }
    
              leaf capwap-reass-frag-err-pkts {
                type uint64;
                description
                  "CAPWAP reassembly fragments error packets";
              }
    
              leaf capwap-reass-frag-err-octets {
                type uint64;
                description
                  "CAPWAP reassembly fragments error octets";
              }
    
              leaf redistrib-err-bad-dst-pkts {
                type uint64;
                description
                  "Redistribution error bad dst packets";
              }
    
              leaf redistrib-err-bad-dst-octets {
                type uint64;
                description
                  "Redistribution error bad dst octets";
              }
    
              leaf redistrib-err-sb-trans-fail-pkts {
                type uint64;
                description
                  "Redistribution error sub block trans fail packets";
              }
    
              leaf redistrib-err-sb-trans-fail-octets {
                type uint64;
                description
                  "Redistribution error sub block trans fail octets";
              }
    
              leaf redistrib-err-ph-alc-fail-pkts {
                type uint64;
                description
                  "Redistribution error ph allocation fail packets";
              }
    
              leaf redistrib-err-ph-alc-fail-octets {
                type uint64;
                description
                  "Redistribution error ph allocation fail octets";
              }
    
              leaf redistrib-err-not-sup-pkts {
                type uint64;
                description
                  "Redistribution error not sup packets";
              }
    
              leaf redistrib-err-not-sup-octets {
                type uint64;
                description
                  "Redistribution error not sup octets";
              }
    
              leaf redistrib-fifo-tail-drop-pkts {
                type uint64;
                description
                  "Redistribution first in first out (FIFO) tail drop packets";
              }
    
              leaf redistrib-fifo-tail-drop-octets {
                type uint64;
                description
                  "Redistribution first in first out (FIFO) tail drop octets";
              }
    
              leaf redistrib-no-credits-pkts {
                type uint64;
                description
                  "Redistribution no credits packets";
              }
    
              leaf redistrib-no-credits-octets {
                type uint64;
                description
                  "Redistribution no credits octets";
              }
    
              leaf max-indirect-exceeded-pkts {
                type uint64;
                description
                  "Maximum indirect exceeded packets";
              }
    
              leaf max-indirect-exceeded-octets {
                type uint64;
                description
                  "Maximum indirect exceeded octets";
              }
    
              leaf punt-intf-drop-pkts {
                type uint64;
                description
                  "Punt interface drop packets";
              }
    
              leaf punt-intf-drop-octets {
                type uint64;
                description
                  "Punt interface drop octets";
              }
    
              leaf srh-pkt-truncated-in-gpm-pkts {
                type uint64;
                description
                  "Segment routing header packet truncated in global packet memory packets";
              }
    
              leaf srh-pkt-truncated-in-gpm-octets {
                type uint64;
                description
                  "Segment routing header packet truncated in global packet memory octets";
              }
    
              leaf srh-invalid-extension-pkts {
                type uint64;
                description
                  "Segment routing header invalid extension packets";
              }
    
              leaf srh-invalid-extension-octets {
                type uint64;
                description
                  "Segment routing header invalid extension octets";
              }
    
              leaf swport-pkts {
                type uint64;
                description
                  "Switch port packets";
              }
    
              leaf swport-octets {
                type uint64;
                description "Switch port octets";
              }
    
              leaf swport-disabled-pkts {
                type uint64;
                description
                  "Switch port disabled packets";
              }
    
              leaf swport-disabled-octets {
                type uint64;
                description
                  "Switch port disabled octets";
              }
    
              leaf swport-sanity-check-pkts {
                type uint64;
                description
                  "Switch port sanity check packets";
              }
    
              leaf swport-sanity-check-octets {
                type uint64;
                description
                  "Switch port sanity check octets";
              }
    
              leaf swport-vp-state-pkts {
                type uint64;
                description
                  "Switch port virtual port state packets";
              }
    
              leaf swport-vp-state-octets {
                type uint64;
                description
                  "Switch port virtual port state octets";
              }
    
              leaf swport-mac-conflict-pkts {
                type uint64;
                description
                  "Switch port MAC conflict packets";
              }
    
              leaf swport-mac-conflict-octets {
                type uint64;
                description
                  "Switch port MAC conflict octets";
              }
    
              leaf swport-stby-pkts {
                type uint64;
                description
                  "Switch port standby packets";
              }
    
              leaf swport-stby-octets {
                type uint64;
                description
                  "Switch port standby octets";
              }
    
              leaf swport-tx-stby-pkts {
                type uint64;
                description
                  "Switch port transmit standby packets";
              }
    
              leaf swport-tx-stby-octets {
                type uint64;
                description
                  "Switch port transmit standby octets";
              }
    
              leaf switch-l2m-pkts {
                type uint64;
                description
                  "Switch layer 2 multicast packets";
              }
    
              leaf switch-l2m-octets {
                type uint64;
                description
                  "Switch layer 2 multicast octets";
              }
    
              leaf switch-l2m-igmp-pkts {
                type uint64;
                description
                  "Switch layer 2 multicast internet group management protocol (IGMP) packets";
              }
    
              leaf switch-l2m-igmp-octets {
                type uint64;
                description
                  "Switch layer 2 multicast internet group management protocol (IGMP) octets";
              }
    
              leaf switch-l2m-mld-pkts {
                type uint64;
                description
                  "Switch layer 2 multicast mld packets";
              }
    
              leaf switch-l2m-mld-octets {
                type uint64;
                description
                  "Switch layer 2 multicast mld octets";
              }
    
              leaf switch-l2m-lookup-miss-pkts {
                type uint64;
                description
                  "Switch layer 2 multicast lookup miss packets";
              }
    
              leaf switch-l2m-lookup-miss-octets {
                type uint64;
                description
                  "Switch layer 2 multicast lookup miss octets";
              }
    
              leaf switch-l2m-sanity-check-pkts {
                type uint64;
                description
                  "Switch layer 2 multicast sanity check packets";
              }
    
              leaf switch-l2m-sanity-check-octets {
                type uint64;
                description
                  "Switch layer 2 multicast sanity check octets";
              }
    
              leaf bier-invalid-replica-record-pkts {
                type uint64;
                description
                  "Bit index explicit replication (BIER) invalid replica record packets";
              }
    
              leaf bier-invalid-replica-record-octets {
                type uint64;
                description
                  "Bit index explicit replication (BIER) invalid replica record octets";
              }
    
              leaf bier-snaity-pkts {
                type uint64;
                description
                  "Bit index explicit replication (BIER) sanity packets";
              }
    
              leaf bier-snaity-octets {
                type uint64;
                description
                  "Bit index explicit replication (BIER) sanity octets";
              }
    
              leaf cable-oob-us-sess-invalid-pkts {
                type uint64;
                description
                  "Cable out of band us session invalid packets";
              }
    
              leaf cable-oob-us-sess-invalid-octets {
                type uint64;
                description
                  "Cable out of band us session invalid octets";
              }
    
              leaf cable-oob-us-src-id-invalid-pkts {
                type uint64;
                description
                  "Cable out of band us source identifier invalid packets";
              }
    
              leaf cable-oob-us-src-id-invalid-octets {
                type uint64;
                description
                  "Cable out of band us source identifier invalid octets";
              }
    
              leaf cable-oob-us-pkt-invalid-pkts {
                type uint64;
                description
                  "Cable out of band us packet invalid packets";
              }
    
              leaf cable-oob-us-pkt-invalid-octets {
                type uint64;
                description
                  "Cable out of band us packet invalid octets";
              }
    
              leaf cbl-oob-null-repllist-pkts {
                type uint64;
                description
                  "Cable out of band null replication list packets";
              }
    
              leaf cbl-oob-null-repllist-octets {
                type uint64;
                description
                  "Cable out of band null replication list octets";
              }
    
              leaf cbl-oob-repl-fail-pkts {
                type uint64;
                description
                  "Cable out of band replication fail packets";
              }
    
              leaf cbl-oob-repl-fail-octets {
                type uint64;
                description
                  "Cable out of band replication fail octets";
              }
    
              leaf cbl-oob-add-hdr-fail-pkts {
                type uint64;
                description
                  "Cable out of band add header fail packets";
              }
    
              leaf cbl-oob-add-hdr-fail-octets {
                type uint64;
                description
                  "Cable out of band add header fail octets";
              }
    
              leaf cbl-oob-repl-end-pkts {
                type uint64;
                description
                  "Cable out of band replication end packets";
              }
    
              leaf cbl-oob-repl-end-octets {
                type uint64;
                description
                  "Cable out of band replication end octets";
              }
    
              leaf cbl-oob-recycle-tail-pkts {
                type uint64;
                description
                  "Cable out of band recycle tail packets";
              }
    
              leaf cbl-oob-recycle-tail-octets {
                type uint64;
                description
                  "Cable out of band recycle tail octets";
              }
    
              leaf cbl-oob-repl-uidb-invalid-pkts {
                type uint64;
                description
                  "Cable out of band replication interface invalid packets";
              }
    
              leaf cbl-oob-repl-uidb-invalid-octets {
                type uint64;
                description
                  "Cable out of band replication interface invalid octets";
              }
    
              leaf cbl-oob-repl-sess-invalid-pkts {
                type uint64;
                description
                  "Cable out of band replication session invalid packets";
              }
    
              leaf cbl-oob-repl-sess-invalid-octets {
                type uint64;
                description
                  "Cable out of band replication session invalid octets";
              }
    
              leaf cbl-oob-null-repl-info-pkts {
                type uint64;
                description
                  "Cable out of band null replication information packets";
              }
    
              leaf cbl-oob-null-repl-info-octets {
                type uint64;
                description
                  "Cable out of band null replication information octets";
              }
    
              leaf nid-vlan-mismatch-pkts {
                type uint64;
                description
                  "Network interface device VLAN mismatch packets";
              }
    
              leaf nid-vlan-mismatch-octets {
                type uint64;
                description
                  "Network interface device VLAN mismatch octets";
              }
    
              leaf pfrv3-loop-pkts {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) loop packets";
              }
    
              leaf pfrv3-loop-octets {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) loop octets";
              }
    
              leaf dialer-list-pkts {
                type uint64;
                description
                  "Dialer list packets";
              }
    
              leaf dialer-list-octets {
                type uint64;
                description "Dialer list octets";
              }
    
              leaf udp-pkts {
                type uint64;
                description "UDP packets";
              }
    
              leaf udp-octets {
                type uint64;
                description "UDP octets";
              }
    
              leaf tunnel-l2tpv3oipv6-cookie-mismatch-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) cookie mismatch packets";
              }
    
              leaf tunnel-l2tpv3oipv6-cookie-mismatch-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) cookie mismatch octets";
              }
    
              leaf tunnel-l2tpv3oipv6-minmtu-error-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) minimum maximum transfer unit error packets";
              }
    
              leaf tunnel-l2tpv3oipv6-minmtu-error-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) minimum maximum transfer unit error octets";
              }
    
              leaf tunnel-l2tpv3oipv6-cookieflag-error-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over
    IPv6 (L2TPv3oIPv6) cookie flag error packets";
              }
    
              leaf tunnel-l2tpv3oipv6-cookieflag-error-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over
    IPv6 (L2TPv3oIPv6) cookie flag error octets";
              }
    
              leaf tunnel-l2tpv3oipv6-mac-mismatch-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) MAC mismatch packets";
              }
    
              leaf tunnel-l2tpv3oipv6-mac-mismatch-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) MAC mismatch octets";
              }
    
              leaf tunnel-l2tpv3oipv6-vlanid-mismatch-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) VLAN identifier mismatch packets";
              }
    
              leaf tunnel-l2tpv3oipv6-vlanid-mismatch-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) VLAN identifier mismatch octets";
              }
    
              leaf tunnel-l2tpv3oipv6-unsupported-proto-pkts {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) unsupported protocol packets";
              }
    
              leaf tunnel-l2tpv3oipv6-unsupported-proto-octets {
                type uint64;
                description
                  "Tunnel layer 2 tunneling protocol version 3 over IPv6 (L2TPv3oIPv6) unsupported protocol octets";
              }
    
              leaf pfrv3-stickiness-pkts {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) stickiness packets";
              }
    
              leaf pfrv3-stickiness-octets {
                type uint64;
                description
                  "Performance routing version 4 (pFRv3) stickiness octets";
              }
    
              leaf cbl-sid-exceed-pkts {
                type uint64;
                description
                  "Cable service identifier exceed packets";
              }
    
              leaf cbl-sid-exceed-octets {
                type uint64;
                description
                  "Cable service identifier exceed octets";
              }
    
              leaf sdwan-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) packets";
              }
    
              leaf sdwan-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) octets";
              }
    
              leaf sdwan-generic-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) generic packets";
              }
    
              leaf sdwan-generic-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) generic octets";
              }
    
              leaf sdwan-implicit-acl-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) implicit access control list (ACL) packets";
              }
    
              leaf sdwan-implicit-acl-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) implicit access control list (ACL) octets";
              }
    
              leaf sdwan-acl-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) access control list (ACL) packets";
              }
    
              leaf sdwan-acl-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) access control list (ACL) octets";
              }
    
              leaf sdwan-bfd-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) bidirectional fault detection (BFD) packets";
              }
    
              leaf sdwan-bfd-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) bidirectional fault detection (BFD) octets";
              }
    
              leaf sdwan-app-route-policy-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) app route policy packets";
              }
    
              leaf sdwan-app-route-policy-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) app route policy octets";
              }
    
              leaf sdwan-data-policy-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) data policy packets";
              }
    
              leaf sdwan-data-policy-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) data policy octets";
              }
    
              leaf sdwan-interface-policy-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) interface policy packets";
              }
    
              leaf sdwan-interface-policy-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) interface policy octets";
              }
    
              leaf sdwan-tunnel-lkup-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) tunnel lookup packets";
              }
    
              leaf sdwan-tunnel-lkup-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) tunnel lookup octets";
              }
    
              leaf sdwan-tloc-ext-pkts {
                type uint64;
                description
                  "Software defined WAN (SDWAN) tunnel locator extension packets";
              }
    
              leaf sdwan-tloc-ext-octets {
                type uint64;
                description
                  "Software defined WAN (SDWAN) tunnel locator extension octets";
              }
    
              leaf tunnel-vxlan-mismatch-pkts {
                type uint64;
                description
                  "Tunnel VxLAN mismatch packets";
              }
    
              leaf tunnel-vxlan-mismatch-octets {
                type uint64;
                description
                  "Tunnel VxLAN mismatch octets";
              }
    
              leaf l2bd-mac-security-move-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security move packets";
              }
    
              leaf l2bd-mac-security-move-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security move octets";
              }
    
              leaf l2bd-mac-security-unknown-pkts {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security unknown packets";
              }
    
              leaf l2bd-mac-security-unknown-octets {
                type uint64;
                description
                  "Layer 2 Bridge Domain (L2BD) MAC security unknown octets";
              }
    
              leaf dapr-noroute-pkts {
                type uint64;
                description
                  "Dynamic application policy routing no route packets";
              }
    
              leaf dapr-noroute-octets {
                type uint64;
                description
                  "Dynamic application policy routing no route octets";
              }
    
              leaf epbr-pkts {
                type uint64;
                description "ePBR packets";
              }
    
              leaf epbr-octets {
                type uint64;
                description "ePBR octets";
              }
    
              leaf sdvt-sn-pkts {
                type uint64;
                description
                  "SDVT Service Node (SN) packets";
              }
    
              leaf sdvt-sn-octets {
                type uint64;
                description
                  "SDVT Service Node (SN) octets";
              }
    
              leaf sdvt-pkts {
                type uint64;
                description "SDVT packets";
              }
    
              leaf sdvt-octets {
                type uint64;
                description "SDVT octets";
              }
    
              leaf tunnel-vxlan-policer-pkts {
                type uint64;
                description
                  "Tunnel VxLAN policer packets";
              }
    
              leaf tunnel-vxlan-policer-octets {
                type uint64;
                description
                  "Tunnel VxLAN policer octets";
              }
    
              leaf tunnel-vrf-mux-pkts {
                type uint64;
                description
                  "Tunnel VRF multiplexed packets";
              }
    
              leaf tunnel-vrf-mux-octets {
                type uint64;
                description
                  "Tunnel VRF multiplexed octets";
              }
    
              leaf tunnel-vrf-demux-pkts {
                type uint64;
                description
                  "Tunnel VRF demultiplexed packets";
              }
    
              leaf tunnel-vrf-demux-octets {
                type uint64;
                description
                  "Tunnel VRF demultiplexed octets";
              }
            }  // container datapath-qfp-stats
          }  // list location
        }  // container qfp-stats-oper-data
      }  // module Cisco-IOS-XE-qfp-stats-oper
    

© 2023 YumaWorks, Inc. All rights reserved.