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";

    grouping datapath-qfp-stats {
      description "Datapath QFP stats";
      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";
      }
    }  // grouping datapath-qfp-stats

    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";
        uses common-types-ios-xe:extended-location;

        container datapath-qfp-stats {
          presence "datapath-qfp-stats";
          description
            "Datapath Quantum Flow Processor(QFP) statistics";
          uses qfp-stats-ios-xe-oper:datapath-qfp-stats;
        }  // container datapath-qfp-stats
      }  // list location
    }  // container qfp-stats-oper-data
  }  // module Cisco-IOS-XE-qfp-stats-oper