submodule Cisco-IOS-XR-mfwd-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-mfwd-oper {
        prefix Cisco-IOS-XR-mfwd-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-mfwd-oper-sub2 {
      revision-date "2020-10-11";
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR mfwd package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-11" {
      description
        "Backward compatible addition in leaf ul-interface, customer-mdt-data-tree-sidacl-name, is-customer-mdt-data-tree-sidacl-present and ,is-all-customer-routes-for-tree-sid-data-mdt";
    }

    revision "2019-08-27" {
      description
        "Initial IOS-XR MFWD native model";
    }

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Rsi-vrf-id {
      type uint32;
      description "Rsi vrf id";
    }

    typedef Ipv4-mfwd-intf-create-state {
      type enumeration {
        enum "interface-state-unknown" {
          value 0;
          description
            "Interface create status unknown";
        }
        enum "interface-create-received" {
          value 1;
          description "Interface created";
        }
        enum "interface-delete-received" {
          value 2;
          description "Interface deleted";
        }
      }
      description
        "Ipv4 mfwd intf create state";
    }

    typedef Ipv4-mfwd-idb-intf {
      type enumeration {
        enum "physical-interface" {
          value 0;
          description "Physical interface";
        }
        enum "vlan-over-bundle-interface" {
          value 1;
          description
            "Vlan over Bundle interface";
        }
        enum "layer3-tunnel-interface" {
          value 2;
          description
            "Layer 3 tunnel interface";
        }
        enum "layer2-bundle-interface" {
          value 3;
          description
            "Layer 2 bundle interface";
        }
        enum "loopback-interface" {
          value 4;
          description "Loopback interface";
        }
        enum "service-virtual-interface" {
          value 5;
          description
            "Service virtual interface";
        }
        enum "mdt-interface" {
          value 6;
          description "MDT interface";
        }
        enum "unsupported-interface" {
          value 7;
          description
            "Unsupported interface";
        }
        enum "bridged-virtual-interface" {
          value 8;
          description
            "Bridged virtual interface";
        }
        enum
          "pointto-point-protocol-over-ethernet-interface" {
          value 9;
          description
            "Point to Point Protocol Over Ethernet";
        }
        enum "psuedo-wire-ether-interface" {
          value 10;
          description
            "Psuedo Wire Ether Interface";
        }
        enum
          "vlan-over-psuedo-wire-interface" {
          value 11;
          description
            "Vlan over Psuedo Wire Interface";
        }
        enum "csi-interface" {
          value 12;
          description "CSI Interface";
        }
      }
      description "Ipv4 mfwd idb intf";
    }

    typedef Ipv4-mfwd-show-encap {
      type enumeration {
        enum "any" {
          value 0;
          description "Any Type";
        }
        enum "lsmid" {
          value 1;
          description "LSM Type";
        }
        enum "teifh" {
          value 2;
          description "TE Type";
        }
        enum "gre" {
          value 3;
          description "GRE Type";
        }
        enum "nh" {
          value 4;
          description "Nexthop Type";
        }
        enum "timofrr" {
          value 5;
          description "MOFRR Type";
        }
      }
      description "Ipv4 mfwd show encap";
    }

    typedef Mfwd-afi {
      type enumeration {
        enum "ipv4-unicast" {
          value 0;
          description "IP v4 unicast";
        }
        enum "ipv6-unicast" {
          value 1;
          description "IP v6 unicast";
        }
      }
      description "Address family";
    }

    typedef Ipv4-mfwd-show-ctid {
      type enumeration {
        enum "any" {
          value 0;
          description "any";
        }
        enum "ipv4" {
          value 1;
          description "ipv4";
        }
        enum "ipv6" {
          value 2;
          description "ipv6";
        }
        enum "none" {
          value 3;
          description "none";
        }
      }
      description "Ipv4 mfwd show ctid";
    }

    typedef Ipv4-mfwd-tbl-location {
      type enumeration {
        enum "remote-table" {
          value 0;
          description "Remote table";
        }
        enum "pending-local-table" {
          value 1;
          description "Pending local table";
        }
        enum "local-table" {
          value 2;
          description "Local table";
        }
      }
      description "Ipv4 mfwd tbl location";
    }

    typedef Ipv4-mfwd-nsf-modes {
      type enumeration {
        enum "undefined" {
          value -1;
          description "undefined";
        }
        enum "boot" {
          value 0;
          description "boot";
        }
        enum "normal" {
          value 1;
          description "normal";
        }
        enum "no-mfwd" {
          value 2;
          description "no mfwd";
        }
        enum "mcast-nsf" {
          value 3;
          description "mcast nsf";
        }
        enum "updating" {
          value 4;
          description "updating";
        }
      }
      description "Ipv4 mfwd nsf modes";
    }

    grouping MFWD-BVI-INTERFACE-BAG {
      description "MFWD BVI INTERFACE BAG";
      leaf vrf-id {
        type Rsi-vrf-id;
        description "Vrf Id";
      }

      leaf vrf-name {
        type string;
        description "Vrf Name";
      }
    }  // grouping MFWD-BVI-INTERFACE-BAG

    grouping IPV4-MFWD-IMDR-BAG {
      description "List of IMDR state";
      leaf imdr-end-of-download-start-received {
        type boolean;
        description
          "IMDR End Of Download Start received state";
      }

      leaf fib-end-of-download-received {
        type boolean;
        description
          "FIB End Of Download state";
      }

      leaf im-end-of-download-received {
        type boolean;
        description
          "IM End Of Download state";
      }

      leaf mfwd-end-of-download-sent {
        type boolean;
        description
          "MFWD End Of Download send state";
      }
    }  // grouping IPV4-MFWD-IMDR-BAG

    grouping IPV4-MFWD-CONNECTION-BAG {
      description "List of connections";
      leaf-list connection {
        type boolean;
        description
          "Array containing status of each connection";
      }
    }  // grouping IPV4-MFWD-CONNECTION-BAG

    grouping IPV4-MFWD-SVD-PENDING-BAG {
      description "SVD Pending table entry";
      leaf pending-table-id {
        type uint32;
        description "Table ID";
      }

      leaf pending-table-name {
        type string;
        description "Table Name";
      }
    }  // grouping IPV4-MFWD-SVD-PENDING-BAG

    grouping IPV4-MFWD-SVD-BAG {
      description "MFWD SVD info";
      leaf bcdl-reset-timer {
        type uint32;
        description "BCDL reset timer";
      }

      leaf is-bcd-just-reset {
        type boolean;
        description "BCDL connection state";
      }

      leaf is-platform-svd-state {
        type boolean;
        description "Platform SVD state";
      }

      leaf platform-svd-reason {
        type uint32;
        description
          "Platform SVD update reason";
      }

      list pending-local-tbl {
        description "Pending Local table";
        uses IPV4-MFWD-SVD-PENDING-BAG;
      }  // list pending-local-tbl
    }  // grouping IPV4-MFWD-SVD-BAG

    grouping IPV4-MFWD-ENCAP-BAG {
      description
        "MFWD Encap Table information";
      container source-xr {
        description "Source address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container source-xr

      container group-prefix {
        description "Group address prefix";
        uses IPV4-MFWD-CTID-BAG;
      }  // container group-prefix

      container orig-source {
        description "Orig source address";
        uses MFWD-ADDRTYPE;
      }  // container orig-source

      leaf group-prefix-length {
        type uint16;
        description
          "Group address prefix length";
      }

      leaf encapsulation-reference-count {
        type uint32;
        description
          "No of VRF routes using this encap ";
      }

      leaf mdt-interface {
        type xr:Interface-name;
        description "MDT Interface";
      }

      leaf associated-table-id {
        type uint32;
        description "Associated Table ID";
      }
    }  // grouping IPV4-MFWD-ENCAP-BAG

    grouping IPV4-MFWD-COUNTER-BAG {
      description "Counter entry";
      leaf description {
        type string {
          length "0..128";
        }
        description
          "Description of the counter";
      }

      leaf count {
        type uint32;
        description "Value of the counter";
      }
    }  // grouping IPV4-MFWD-COUNTER-BAG

    grouping IPV4-MFWD-TABLE-COUNTERS-BAG {
      description "MFIB counters";
      list counters {
        description
          "Counters in the main MFIB table";
        uses IPV4-MFWD-COUNTER-BAG;
      }  // list counters
    }  // grouping IPV4-MFWD-TABLE-COUNTERS-BAG

    grouping IPV4-MFWD-ATTRIB-INTF-BAG {
      description
        "MFWD Interface level flags";
      leaf is-forward {
        type boolean;
        description "Forwarding flag";
      }

      leaf is-accept {
        type boolean;
        description "Accepting flag";
      }

      leaf is-accept-backup {
        type boolean;
        description "Backup Accepting flag";
      }

      leaf is-internal-copy {
        type boolean;
        description "Internal Copy flag";
      }

      leaf is-negate-signal {
        type boolean;
        description "Negate Signal";
      }

      leaf is-donot-preserve {
        type boolean;
        description "Don't preserve flag";
      }

      leaf is-signal-present {
        type boolean;
        description "Signal Present flag";
      }

      leaf is-internal-interest {
        type boolean;
        description "Internal Interest flag";
      }

      leaf is-internal-disinterest {
        type boolean;
        description
          "Internal Disinterest flag";
      }

      leaf is-local-interest {
        type boolean;
        description "Local Interest flag";
      }

      leaf is-local-disinterest {
        type boolean;
        description "Local Disinterest flag";
      }

      leaf is-decapsulation-interface {
        type boolean;
        description "Decaps interface flag";
      }

      leaf is-underlying-physical-change {
        type boolean;
        description
          "Underlying physical change flag";
      }

      leaf is-encapsulated-interface {
        type boolean;
        description
          "Encapsulated interface flag";
      }

      leaf is-egress-interface {
        type boolean;
        description "Egress processing flag";
      }

      leaf is-mdt-interface {
        type boolean;
        description "MDT Interface flag";
      }

      leaf is-mldp-mdt-interface {
        type boolean;
        description
          "MLDP MDT Interface flag";
      }

      leaf is-rsvp-te-mdt-interface {
        type boolean;
        description
          "RSVP-TE MDT Interface flag";
      }

      leaf is-ir-mdt-interface {
        type boolean;
        description "IR MDT Interface flag";
      }

      leaf is-tr-mdt-interface {
        type boolean;
        description
          "TreeSID MDT Interface flag";
      }

      leaf is-mdt-data-triggered {
        type boolean;
        description
          "Data MDT triggered on this interface";
      }

      leaf is-label-interface {
        type boolean;
        description "Label Interface flag";
      }

      leaf is-extranet {
        type boolean;
        description "Extranet flag";
      }

      leaf turn-around {
        type boolean;
        description "Turnaround flag";
      }

      leaf amt {
        type boolean;
        description "AMT flag";
      }
    }  // grouping IPV4-MFWD-ATTRIB-INTF-BAG

    grouping IPV4-MFWD-INTRF-BAG {
      description
        "MFIB multicast-forwarding entry";
      container interface-attributes {
        description "Interface attributes";
        uses IPV4-MFWD-ATTRIB-INTF-BAG;
      }  // container interface-attributes

      leaf type {
        type uint32;
        description "Type of Interface";
      }

      leaf interface {
        type xr:Interface-name;
        description "Interface";
      }

      leaf ul-interface {
        type xr:Interface-name;
        description "Underlying Interface";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf stale-interface {
        type boolean;
        description "Interface is stale";
      }

      leaf amt-port {
        type uint16;
        description "AMT Port";
      }

      leaf nexthop {
        type inet:ipv4-address;
        description "Nexthop";
      }

      leaf amt-nexthop {
        type inet:ipv4-address;
        description "AMT Nexthop";
      }

      leaf amt-mtu {
        type uint16;
        description "AMT MTU";
      }

      leaf amt-tos {
        type uint8;
        description "AMT TOS";
      }

      leaf amt-ttl {
        type uint8;
        description "AMT TTL";
      }

      leaf amt-source {
        type inet:ipv4-address;
        description "AMT Source";
      }

      leaf amt-id {
        type uint32;
        description " AMT ID";
      }

      leaf amt-in-pkts {
        type uint64;
        description
          "Incoming Packtes AMT intterface";
      }

      leaf amt-in-byets {
        type uint64;
        units "byte";
        description
          "Incoming Bytes on AMT intterface";
      }

      leaf amt-out-pkts {
        type uint64;
        description
          "Outgoing Packtes on AMT intterface";
      }

      leaf amt-out-bytes {
        type uint64;
        units "byte";
        description
          "Outgoing Bytes on AMT intterface";
      }
    }  // grouping IPV4-MFWD-INTRF-BAG

    grouping IPV4-MFWD-ATTRIB-ENTRY-BAG {
      description "MFWD Entry level flags";
      leaf is-domain-local-source {
        type boolean;
        description
          "Domain-local source flag";
      }

      leaf is-source-external {
        type boolean;
        description
          "Source external to domain";
      }

      leaf is-signal-by-default-on {
        type boolean;
        description "Signal by default";
      }

      leaf is-directly-connected-check-set {
        type boolean;
        description
          "Directly connected check";
      }

      leaf is-inherit-accept-set {
        type boolean;
        description
          "Inherit Accept information";
      }

      leaf is-inherit-from-set {
        type boolean;
        description
          "Inherit from information";
      }

      leaf is-drop {
        type boolean;
        description "Drop flag";
      }

      leaf is-rpf-neighbor-present {
        type boolean;
        description
          "RPF neighbor present flag";
      }

      leaf is-multicast-nsf-on {
        type boolean;
        description "Multicast NSF flag";
      }

      leaf is-unicast-nsf-on {
        type boolean;
        description "Unicast NSF flag";
      }

      leaf is-mdt-encapsulation-on {
        type boolean;
        description "MDT Encapsulation flag";
      }

      leaf is-mdt-decapsulation-on {
        type boolean;
        description "MDT Decapsulation flag";
      }

      leaf is-mdt-address-on {
        type boolean;
        description "MDT Address flag";
      }

      leaf is-threshold-crossed {
        type boolean;
        description
          "Data MDT Threshold Crossed";
      }

      leaf is-mdt-handle-set {
        type boolean;
        description "MDT Handle flag";
      }

      leaf is-conditional-decapsulation {
        type boolean;
        description
          "Conditional Decapsulation flag";
      }

      leaf is-packet-decapsulation-true {
        type boolean;
        description
          "Should we decapsulation pkt";
      }

      leaf is-packet-decapsulation-true-v6 {
        type boolean;
        description
          "decapsulation pkt with v6 payload";
      }

      leaf is-via-lsm {
        type boolean;
        description "LSM flag";
      }

      leaf is-forward-mpls {
        type boolean;
        description "MPLS Forward";
      }

      leaf is-extranet {
        type boolean;
        description "Extranet flag";
      }

      leaf encapsulation-identifier {
        type boolean;
        description "Encap-id present";
      }

      leaf rpf-identifier {
        type boolean;
        description "RPF-id present";
      }

      leaf mo-frr-enabled {
        type boolean;
        description "MoFRR Enable";
      }

      leaf mo-frr-state {
        type boolean;
        description "MOFRR State";
      }

      leaf mo-frr-primary {
        type boolean;
        description "MOFRR Primary";
      }

      leaf mo-frr-backup {
        type boolean;
        description "MOFRR Backup";
      }

      leaf amt {
        type boolean;
        description "AMT State";
      }

      leaf vx-lan {
        type boolean;
        description "VxLAN State";
      }
    }  // grouping IPV4-MFWD-ATTRIB-ENTRY-BAG

    grouping IPV4-MFWD-ROUTE-BAG {
      description
        "MFIB multicast-routing entry";
      container source {
        description "Source address";
        uses MFWD-ADDRTYPE;
      }  // container source

      container group-prefix {
        description "Group address prefix";
        uses MFWD-ADDRTYPE;
      }  // container group-prefix

      container orig-source {
        description "Orig source address";
        uses MFWD-ADDRTYPE;
      }  // container orig-source

      container entry-attributes {
        description
          "Routing entry attributes";
        uses IPV4-MFWD-ATTRIB-ENTRY-BAG;
      }  // container entry-attributes

      container parent-group-prefix {
        description
          "Inherit from Group address prefix";
        uses MFWD-ADDRTYPE;
      }  // container parent-group-prefix

      container lsm-rpf-address {
        description "LSM RPF Address";
        uses MFWD-ADDRTYPE;
      }  // container lsm-rpf-address

      container mdt-default-source {
        description "Source address";
        uses IPV4-MFWD-MDTID-BAG;
      }  // container mdt-default-source

      container mdt-default-group-prefix {
        description "Group address prefix";
        uses IPV4-MFWD-MDTID-BAG;
      }  // container mdt-default-group-prefix

      leaf rsi-table-id {
        type uint32;
        description "RSI Table ID";
      }

      leaf group-prefix-length {
        type uint16;
        description
          "Group address prefix length";
      }

      leaf route-version {
        type uint16;
        description "Route version";
      }

      leaf stale-route {
        type boolean;
        description "The route is stale";
      }

      leaf incomplete-route {
        type boolean;
        description
          "The route is incomplete";
      }

      leaf time-last-used {
        type string;
        description
          "Last time entry was used";
      }

      leaf bytes-out {
        type uint64;
        units "byte";
        description "No of bytes out";
      }

      leaf bytes-rep {
        type uint64;
        units "byte";
        description "No of bytes replicated";
      }

      leaf packets-in {
        type uint32;
        description "No of packets in";
      }

      leaf packets-out {
        type uint32;
        description "No of packets out";
      }

      leaf packets-rep {
        type uint32;
        description
          "No of packets replicated";
      }

      leaf packets-failed-rpf {
        type uint32;
        description
          "No of packets which failed rpf";
      }

      leaf packets-failed-ttl {
        type uint32;
        description
          "No of packets which failed TTL check";
      }

      leaf outgoing-list-failure-packets {
        type uint32;
        description
          "No of packets dropped due to null olist";
      }

      leaf encapsulation-ratelimit-drops {
        type uint32;
        description
          "No of encap packets dropped/ratelimited";
      }

      leaf other-failures {
        type uint32;
        description
          "No of packets dropped due to misc failures";
      }

      leaf hardware-ingress-packets-in {
        type uint64;
        description
          "No of packets input at ingress metro";
      }

      leaf hardware-ingress-bytes-in {
        type uint64;
        units "byte";
        description
          "No of bytes input on this interface";
      }

      leaf hardware-ingres-packets-drop {
        type uint64;
        description
          "No of packets dropped at ingress metro";
      }

      leaf hardware-egress-packets-out {
        type uint64;
        description
          "No of packets sent out at egress metro";
      }

      leaf hardware-egress-packets-rep {
        type uint64;
        description
          "No of packets replicated at egress metro";
      }

      leaf hardware-egress-packets-drop {
        type uint64;
        description
          "No of packets dropped at egress metro";
      }

      leaf hardware-egress-byte-out {
        type uint64;
        units "byte";
        description
          "No of bytes sent out at egress metro";
      }

      leaf hardware-egress-byte-rep {
        type uint64;
        units "byte";
        description
          "No of bytes replicated at egress metro";
      }

      leaf is-hardware-ingress-input-counter-valid {
        type boolean;
        description
          "Is input counter at ingress metro valid ?";
      }

      leaf is-hardware-ingress-drop-counter-valid {
        type boolean;
        description
          "Is drop counter at ingress metro valid ?";
      }

      leaf is-hardware-ingress-bytes-counter-valid {
        type boolean;
        description
          "Is bytes counter at egress metro valid ?";
      }

      leaf is-hardware-egress-output-counter-valid {
        type boolean;
        description
          "Is output counter at egress metro valid ?";
      }

      leaf is-hardware-egress-replicate-counter-valid {
        type boolean;
        description
          "Is replicated counter at egress metro valid ?";
      }

      leaf is-hardware-egress-drop-counter-valid {
        type boolean;
        description
          "Is drop counter at egress metro valid ?";
      }

      leaf is-hardware-egress-fwd-bytes-counter-valid {
        type boolean;
        description
          "Is bytes counter at egress metro valid ?";
      }

      leaf is-hardware-egress-rep-bytes-counter-valid {
        type boolean;
        description
          "Is bytes replicated counter at egress metro
         valid ?";
      }

      leaf parent-group-prefix-length {
        type uint16;
        description
          "Inherit from Group address prefix length";
      }

      leaf mo-frr-active {
        type boolean;
        description "MoFRR Active";
      }

      leaf mo-frr-sequence-number {
        type uint32;
        description "MoFRR Sequence Number";
      }

      leaf new-mo-frr-active {
        type boolean;
        description "New MoFRR Active";
      }

      leaf new-mo-frr-sequence-number {
        type uint32;
        description
          "New MoFRR Sequence Number";
      }

      leaf mo-frrhw-event {
        type boolean;
        description
          "Is this an MoFRR Hardware Event";
      }

      leaf mdt-interface {
        type xr:Interface-name;
        description "MDT Interface";
      }

      leaf is-mdt-encapsulation-info {
        type boolean;
        description "MDT Encap information";
      }

      leaf mdt-default-group-prefix-length {
        type uint16;
        description
          "Group address prefix length";
      }

      leaf mdt-associated-table-id {
        type uint32;
        description
          "Associated Table (vrf or Core)";
      }

      leaf mdt-associated-remote-table-id {
        type uint32;
        description
          "Associated Remote Table (vrf or Core)";
      }

      leaf is-mdt-data-rate-probe {
        type boolean;
        description
          "Are we probing for rate for Data MDT ?";
      }

      leaf is-mdt-data-rate-in-list {
        type boolean;
        description
          "Are we in the list for rate calc for Data MDT ?";
      }

      leaf is-mdt-data-rate-throttle {
        type boolean;
        description
          "Is Data MDT rate calculation throttled ?";
      }

      leaf mdt-data-throttle-left {
        type uint32;
        description
          "Time remaining for throttle to be removed ?";
      }

      leaf mdt-decapsulation-egress-count {
        type uint32;
        description
          "No. of pkts decapped on SW egress node";
      }

      leaf mdt-encapsulation-ingress-v4-count {
        type uint32;
        description
          "No. of v4 pkts encapped on SW ingress node";
      }

      leaf mdt-encapsulation-ingress-v6-count {
        type uint32;
        description
          "No. of v6 pkts encapped on SW ingress node";
      }

      leaf incoming-traffic-rate {
        type uint64;
        description
          "Incoming traffic rate when MDT is forwarding";
      }

      leaf is-rate-per-route {
        type boolean;
        description
          "Are we doing rate per route ?";
      }

      leaf is-prefix-accounting {
        type boolean;
        description
          "Are we doing stats per route ?";
      }

      leaf annotation {
        type string;
        description "Platform annotation";
      }

      leaf is-hardware-egress-bits-per-seconds-average-rate {
        type uint64;
        units "bit/s";
        description "Average bps out rate";
      }

      leaf is-hardware-ingress-bits-per-seconds-average-rate {
        type uint64;
        units "bit/s";
        description "Average bps in rate";
      }

      leaf is-hardware-egress-packet-per-seconds-average-rate {
        type uint64;
        description "Average pps out rate";
      }

      leaf is-hardware-ingress-packet-per-seconds-average-rate {
        type uint64;
        description "Average pps in rate";
      }

      leaf is-hardware-egress-bytes-rate-counte-valid {
        type boolean;
        description
          "Is egress bits per sec rate valid?";
      }

      leaf is-hardware-egress-packets-rate-counter-valid {
        type boolean;
        description
          "Is egress packet per sec rate valid?";
      }

      leaf is-hardware-ingress-bytes-rate-counter-valid {
        type boolean;
        description
          "Is ingress bits per sec rate valid?";
      }

      leaf is-hardware-ingress-packets-rate-counter-valid {
        type boolean;
        description
          "Is ingress packet per sec rate valid?";
      }

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf rpf-table-id {
        type uint32;
        description "RPF TID";
      }

      leaf route-e-gcount {
        type uint16;
        description "Route EG count";
      }

      leaf route-encap-id {
        type uint32;
        description "Encap Id";
      }

      leaf rpf-id {
        type uint32;
        description "RPF Id";
      }

      leaf local-receiver {
        type boolean;
        description "Local Receiver Flag";
      }

      leaf turn-around {
        type boolean;
        description "Turn Around Flag";
      }

      leaf next-amt-route {
        type uint64;
        description "Next AMT route";
      }

      leaf prev-amt-route {
        type uint64;
        description "Prev AMT route";
      }

      leaf in-amt-route-list {
        type boolean;
        description
          "Are we in the list of AMT route ?";
      }

      list interface {
        description "Interfaces";
        uses IPV4-MFWD-INTRF-BAG;
      }  // list interface
    }  // grouping IPV4-MFWD-ROUTE-BAG

    grouping IPV4-MFWD-BUNDLE-MEMBER-BAG {
      description "MFIB bundle member entry";
      leaf interface {
        type xr:Interface-name;
        description "Interface";
      }

      leaf ul-identifier {
        type If-ul-id;
        description "UL ID";
      }
    }  // grouping IPV4-MFWD-BUNDLE-MEMBER-BAG

    grouping IPV4-MFWD-BUNDLE-INTF-BAG {
      description
        "MFIB bundle interface entry";
      leaf bundle-member-count {
        type uint32;
        description "No. of bundle members";
      }

      list member {
        description
          "List of currently local and active members of
         the bundle";
        uses IPV4-MFWD-BUNDLE-MEMBER-BAG;
      }  // list member
    }  // grouping IPV4-MFWD-BUNDLE-INTF-BAG

    grouping IPV4-MFWD-TUNNEL-INTF-BAG {
      description
        "MFIB tunnel interface entry";
      leaf is-active-tunnel {
        type boolean;
        description
          "Is this interface an active tunnel";
      }
    }  // grouping IPV4-MFWD-TUNNEL-INTF-BAG

    grouping IPV4-MFWD-INTF-BAG {
      description "MFIB interface entry";
      leaf interface {
        type xr:Interface-name;
        description "Interface Handle";
      }

      leaf is-interface-local {
        type boolean;
        description
          "Is interface local to the node ?";
      }

      leaf multicast-packets-in {
        type uint64;
        description
          "No. of multicast packets in";
      }

      leaf multicast-packets-out {
        type uint64;
        description
          "No. of multicast packets out";
      }

      leaf ttl-threshold {
        type uint8;
        description
          "Multicast TTL threshold";
      }

      leaf referencecount {
        type uint32;
        description
          "Referencecount of times this interface is
         referenced";
      }

      leaf is-multicast-interface-enabled {
        type boolean;
        description
          "Is interface multicast enabled";
      }
    }  // grouping IPV4-MFWD-INTF-BAG

    grouping IPV4-MFWD-INTF-DETAIL-BAG {
      description
        "MFIB interface detailed entry";
      container interface-info {
        description
          "Basic interface information";
        uses IPV4-MFWD-INTF-BAG;
      }  // container interface-info

      container tunnel-info {
        description
          "Tunnel interface information";
        uses IPV4-MFWD-TUNNEL-INTF-BAG;
      }  // container tunnel-info

      container bundle-info {
        description
          "Bundle interface information";
        uses IPV4-MFWD-BUNDLE-INTF-BAG;
      }  // container bundle-info

      leaf interface {
        type xr:Interface-name;
        description "Interface Handle";
      }

      leaf vrf-id {
        type uint32;
        description "RSI VRF ID";
      }

      leaf rsi-table-id {
        type uint32;
        description "RSI Table ID";
      }

      leaf route-count {
        type uint32;
        description
          "No of routes associated with this interface";
      }

      leaf is-explicit-enable {
        type boolean;
        description
          "Is multicast explicitly enabled on the interface";
      }

      leaf boundary-acl-name {
        type string;
        description "Boundary ACL";
      }

      leaf type {
        type Ipv4-mfwd-idb-intf;
        description "Interface type";
      }

      leaf is-multicast-adjacency-present {
        type boolean;
        description
          "Is adjacency known on this interface ?";
      }

      leaf create-status {
        type Ipv4-mfwd-intf-create-state;
        description
          "The create status of this interface";
      }

      leaf bundle-parent {
        type xr:Interface-name;
        description
          "Bundle I/F if this I/F is member of the bundle";
      }

      leaf underlying-interface {
        type xr:Interface-name;
        description "Underlying interface";
      }

      leaf mdt-mtu {
        type uint32;
        description "MDT MTU";
      }

      leaf remote-mdt-mtu {
        type uint32;
        description "Remote MDT MTU";
      }

      leaf special-referencecount {
        type uint32;
        description
          "Count of Special Updates using this MDT
         interface";
      }

      leaf mh-referencecount {
        type uint32;
        description
          "Count of Core routes with MH flag & using this
         MDT interface";
      }

      leaf mi-referencecount {
        type uint32;
        description
          "Count of VRF routes with MI flag MDT interface";
      }

      leaf is-data-plane-local {
        type boolean;
        description
          "Is the dataplane for this interface local ?";
      }

      leaf mcast-intf-config-vrf-set {
        type boolean;
        description
          "Multicast Interface configuration VRF present";
      }

      leaf mcast-intf-config-vrf-error {
        type boolean;
        description
          "Multicast Interface configuration VRF error";
      }

      leaf mcast-intf-config-vrf-name {
        type string;
        description
          "Multicast Interface configuration VRF Name";
      }

      leaf in-name-tree {
        type boolean;
        description
          "Is interface present in global name tree";
      }

      leaf learned-via-gsp {
        type boolean;
        description
          "Is interface learned via gsp";
      }

      leaf stale-im {
        type boolean;
        description
          "Does interface has stale im info";
      }

      leaf intf-flag {
        type uint8;
        description "Interface flag";
      }
    }  // grouping IPV4-MFWD-INTF-DETAIL-BAG

    grouping IPV4-MFWD-ENCAP-TIMOFRR-BAG {
      description "MFWD Encap Id TIMOFRR";
      container source-address {
        description "Core Source address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container source-address

      container group-address {
        description "Core Group address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container group-address
    }  // grouping IPV4-MFWD-ENCAP-TIMOFRR-BAG

    grouping IPV4-MFWD-ENCAP-NH-BAG {
      description "MFWD encap Id NH";
      leaf next-hop {
        type inet:ipv4-address;
        description "Next hop address";
      }
    }  // grouping IPV4-MFWD-ENCAP-NH-BAG

    grouping IPV4-MFWD-ENCAP-GRE-BAG {
      description "MFWD Encap Id GRE";
      container source-address {
        description "Core Source address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container source-address

      container group-address {
        description "Core Group address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container group-address
    }  // grouping IPV4-MFWD-ENCAP-GRE-BAG

    grouping IPV4-MFWD-SHOW-ENCAP {
      description "IPV4 MFWD SHOW ENCAP";
      container encap-gre {
        when "../type = 'gre'" {
          description "../Type = 'gre'";
        }
        description "GRE";
        uses IPV4-MFWD-ENCAP-GRE-BAG;
      }  // container encap-gre

      container encap-nh {
        when "../type = 'nh'" {
          description "../Type = 'nh'";
        }
        description "NH";
        uses IPV4-MFWD-ENCAP-NH-BAG;
      }  // container encap-nh

      container encap-timofrr {
        when "../type = 'timofrr'" {
          description "../Type = 'timofrr'";
        }
        description "TIMOFRR";
        uses IPV4-MFWD-ENCAP-TIMOFRR-BAG;
      }  // container encap-timofrr

      leaf type {
        type Ipv4-mfwd-show-encap;
        description "Type";
      }

      leaf lsm-id {
        when "../type = 'lsmid'" {
          description "../Type = 'lsmid'";
        }
        type uint32;
        description "Core LSM ID";
      }

      leaf te-ifhandle {
        when "../type = 'teifh'" {
          description "../Type = 'teifh'";
        }
        type xr:Interface-name;
        description "Core TE Ifhandle";
      }
    }  // grouping IPV4-MFWD-SHOW-ENCAP

    grouping IPV4-MFWD-ENCAPLEAF-BAG {
      description "MFWD encap leaf entry";
      container type {
        description "Encap Leaf Type";
        uses IPV4-MFWD-SHOW-ENCAP;
      }  // container type

      leaf leaf-tr {
        type boolean;
        description "Encap Leaf Turnaround";
      }
    }  // grouping IPV4-MFWD-ENCAPLEAF-BAG

    grouping IPV4-MFWD-ENCAPID-BAG {
      description "MFWD encap id entry";
      leaf encap-id-xr {
        type uint32;
        description "Encap ID";
      }

      leaf stale-flag {
        type boolean;
        description "Stale flag";
      }

      leaf encap-lookup-flag {
        type boolean;
        description "IP Lookup flag";
      }

      leaf encap-route-count {
        type uint32;
        description
          "Number of Routes using this Encap";
      }

      leaf interface-e-gcount {
        type uint32;
        description
          "Number of egress interfaces using this encapid";
      }

      leaf interface-eg-from-v6 {
        type boolean;
        description
          "Egress interfaces indicated by V6";
      }

      leaf leaf-count {
        type uint32;
        description "Number of Encap OLEs";
      }

      leaf vr-flite-flag {
        type boolean;
        description "MRIB Update VRFLite";
      }

      leaf v6vr-flite-flag {
        type boolean;
        description
          "MRIB Update v6 VRF lite";
      }

      list leave {
        description "Encap Leafs";
        uses IPV4-MFWD-ENCAPLEAF-BAG;
      }  // list leave
    }  // grouping IPV4-MFWD-ENCAPID-BAG

    grouping IPV4-MFWD-ROUTE-SUMM-BAG {
      description "MFIB Route Summary";
      leaf groutes-count {
        type uint32;
        description "No. of (*,G) routes";
      }

      leaf sg-routes-count {
        type uint32;
        description "No. of (S,G) routes";
      }

      leaf groutes-stale-count {
        type uint32;
        description
          "No. of stale (*,G) routes";
      }

      leaf sg-routes-stale-count {
        type uint32;
        description
          "No. of stale (S,G) routes";
      }

      leaf groutes-incomplete-count {
        type uint32;
        description
          "No. of incomplete (*,G) routes";
      }

      leaf sg-routes-incomplete-count {
        type uint32;
        description
          "No. of incomplete (S,G) routes";
      }
    }  // grouping IPV4-MFWD-ROUTE-SUMM-BAG

    grouping IPV4-MFWD-REGDB-TIMOFRR-BAG {
      description
        "MFWD encap reg TI MOFRR entry";
      container source-address {
        description "Core Source address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container source-address

      container group-address {
        description "Core Group address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container group-address

      leaf is-timofrr-core-valid {
        type boolean;
        description "Is TI MOFRR Core Valid";
      }
    }  // grouping IPV4-MFWD-REGDB-TIMOFRR-BAG

    grouping IPV4-MFWD-REGDB-NH-BAG {
      description "MFWD encap reg NH entry";
      leaf next-hop {
        type inet:ipv4-address;
        description "Next hop address";
      }
    }  // grouping IPV4-MFWD-REGDB-NH-BAG

    grouping IPV4-MFWD-CTID-UNION {
      description "MRIB Core Tree ID";
      leaf mib-type {
        type Ipv4-mfwd-show-ctid;
        description "MIBType";
      }

      leaf ipv4ctid {
        when "../mib-type = 'ipv4'" {
          description "../MIBType = 'IPv4'";
        }
        type inet:ipv4-address;
        description "IPv4 CTID";
      }

      leaf any-ctid {
        when "../mib-type = 'any'" {
          description "../MIBType = 'Any'";
        }
        type uint32;
        description "Any CTID";
      }
    }  // grouping IPV4-MFWD-CTID-UNION

    grouping IPV4-MFWD-CTID-BAG {
      description "MRIB Core Tree ID";
      container ctid {
        description "Core Tree ID";
        uses IPV4-MFWD-CTID-UNION;
      }  // container ctid

      leaf mib-type {
        type Ipv4-mfwd-show-ctid;
        description
          "MIB type Deprecated by CTID";
      }

      leaf id {
        type uint32;
        description "ID Deprecated by CTID";
      }
    }  // grouping IPV4-MFWD-CTID-BAG

    grouping IPV4-MFWD-REGDB-GRE-BAG {
      description "MFWD encap reg GRE entry";
      container source-address {
        description "Core Source address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container source-address

      container group-address {
        description "Core Group address";
        uses IPV4-MFWD-CTID-BAG;
      }  // container group-address

      leaf is-gre-core-valid {
        type boolean;
        description "Is GRE Core Valid";
      }
    }  // grouping IPV4-MFWD-REGDB-GRE-BAG

    grouping IPV4-MFWD-REGDB-TE-BAG {
      description "MFWD encap reg TE entry";
      leaf te-ifhandle {
        type xr:Interface-name;
        description "Core TE Ifhandle";
      }

      leaf reg-is-ecd-stale {
        type boolean;
        description
          "Encap reg ECD stale flag";
      }

      leaf reg-is-ecd-reg {
        type boolean;
        description
          "Encap reg ECD is registered";
      }
    }  // grouping IPV4-MFWD-REGDB-TE-BAG

    grouping IPV4-MFWD-REGDB-LSM-BAG {
      description "MFWD encap reg LSM entry";
      leaf lsm-id {
        type uint32;
        description "Core LSM ID";
      }

      leaf reg-is-ecd-stale {
        type boolean;
        description
          "encap reg ECD stale flag";
      }

      leaf reg-is-ecd-reg {
        type boolean;
        description
          "Encap reg ECD is registered";
      }
    }  // grouping IPV4-MFWD-REGDB-LSM-BAG

    grouping IPV4-MFWD-REGTYPE {
      description "IPV4 MFWD REGTYPE";
      container reg-dblsm {
        when "../type = 'lsmid'" {
          description "../Type = 'lsmid'";
        }
        description "LSM Type";
        uses IPV4-MFWD-REGDB-LSM-BAG;
      }  // container reg-dblsm

      container reg-dbte {
        when "../type = 'teifh'" {
          description "../Type = 'teifh'";
        }
        description "TE Type";
        uses IPV4-MFWD-REGDB-TE-BAG;
      }  // container reg-dbte

      container reg-dbgre {
        when "../type = 'gre'" {
          description "../Type = 'gre'";
        }
        description "GRE Type";
        uses IPV4-MFWD-REGDB-GRE-BAG;
      }  // container reg-dbgre

      container reg-dbnh {
        when "../type = 'nh'" {
          description "../Type = 'nh'";
        }
        description "NH Type";
        uses IPV4-MFWD-REGDB-NH-BAG;
      }  // container reg-dbnh

      container reg-dbtimofrr {
        when "../type = 'timofrr'" {
          description "../Type = 'timofrr'";
        }
        description "TIMOFRR TYPE";
        uses IPV4-MFWD-REGDB-TIMOFRR-BAG;
      }  // container reg-dbtimofrr

      leaf type {
        type Ipv4-mfwd-show-encap;
        description "Type";
      }
    }  // grouping IPV4-MFWD-REGTYPE

    grouping IPV4-MFWD-REGDB-BAG {
      description "MFWD encap reg entry";
      container registration-type {
        description "Regdb Type";
        uses IPV4-MFWD-REGTYPE;
      }  // container registration-type

      leaf registration-if-handle {
        type xr:Interface-name;
        description "Regdb Ifhandle";
      }

      leaf encap-leaf-count {
        type uint32;
        description "Encap Leaf Count";
      }
    }  // grouping IPV4-MFWD-REGDB-BAG

    grouping MFWD-BVI-MROUTE-BAG {
      description "MFWD BVI Mroute";
      container source {
        description "Source address";
        uses MFWD-ADDRTYPE;
      }  // container source

      container group-prefix {
        description "Group address prefix";
        uses MFWD-ADDRTYPE;
      }  // container group-prefix

      leaf group-prefix-length {
        type uint8;
        description
          "Group address prefix length";
      }
    }  // grouping MFWD-BVI-MROUTE-BAG

    grouping MFWD-ADDRTYPE {
      description "MFWD ADDRTYPE";
      leaf af-name {
        type Mfwd-afi;
        description "AFName";
      }

      leaf ipv4-address {
        when "../af-name = 'ipv4-unicast'" {
          description
            "../AFName = 'IPv4Unicast'";
        }
        type inet:ipv4-address;
        description "IPv4 Addr";
      }

      leaf ipv6-address {
        when "../af-name = 'ipv6-unicast'" {
          description
            "../AFName = 'IPv6Unicast'";
        }
        type Ipv6-address;
        description "IPV6 Addr";
      }
    }  // grouping MFWD-ADDRTYPE

    grouping MFWD-BVI-ROUTE-BAG {
      description "MFWD BVI DB";
      container source {
        description "Source address";
        uses MFWD-ADDRTYPE;
      }  // container source

      container group-prefix {
        description "Group address prefix";
        uses MFWD-ADDRTYPE;
      }  // container group-prefix

      container orig-source {
        description "Orig Source address";
        uses MFWD-ADDRTYPE;
      }  // container orig-source

      leaf group-prefix-length {
        type uint8;
        description
          "Group address prefix length";
      }

      leaf bvi-interface {
        type xr:Interface-name;
        description "BVI interface";
      }

      leaf table-name {
        type string;
        description "Table Name";
      }

      leaf uptime {
        type uint64;
        description
          "Time entry has been active";
      }

      list mroute {
        description "MRoute";
        uses MFWD-BVI-MROUTE-BAG;
      }  // list mroute
    }  // grouping MFWD-BVI-ROUTE-BAG

    grouping IPV4-MFWD-MDTID-BAG {
      description "IPV4 MFWD MDTID BAG";
      leaf id-type {
        type Ipv4-mfwd-show-ctid;
        description "IDType";
      }

      leaf ipv4-mdt-address {
        when "../id-type = 'ipv4'" {
          description "../IDType = 'IPv4'";
        }
        type inet:ipv4-address;
        description "IPv4 Addr";
      }

      leaf id {
        when "../id-type = 'any'" {
          description "../IDType = 'Any'";
        }
        type uint32;
        description "ID";
      }

      leaf ipv6-mdt-address {
        when "../id-type = 'ipv6'" {
          description "../IDType = 'IPv6'";
        }
        type inet:ipv4-address;
        description "IPv6 Addr";
      }
    }  // grouping IPV4-MFWD-MDTID-BAG

    grouping IPV4-MFWD-TABLE-BAG {
      description "MFWD Table information";
      container mdt-default-source {
        description
          "Default MDT Source address";
        uses IPV4-MFWD-MDTID-BAG;
      }  // container mdt-default-source

      container mdt-default-group-prefix {
        description
          "Default MDT Group address prefix";
        uses IPV4-MFWD-MDTID-BAG;
      }  // container mdt-default-group-prefix

      leaf rsi-table-name {
        type string;
        description "RSI Table Name";
      }

      leaf rsi-table-id {
        type uint32;
        description "RSI Table ID";
      }

      leaf vrf-id {
        type uint32;
        description "RSI VRF ID";
      }

      leaf vr-id {
        type uint32;
        description "RSI VR ID";
      }

      leaf is-table-active {
        type boolean;
        description "Is Table active?";
      }

      leaf previous-rsi-table-id {
        type uint32;
        description "Previous RSI Table ID";
      }

      leaf is-linked {
        type boolean;
        description
          "Is linked to sibling table?";
      }

      leaf table-type {
        type uint8;
        description "table type";
      }

      leaf table-location {
        type Ipv4-mfwd-tbl-location;
        description "table location";
      }

      leaf local-interface-count {
        type uint32;
        description "Table local intf count";
      }

      leaf route-count {
        type uint32;
        description "Total route count";
      }

      leaf mdt-default-group-prefix-length {
        type uint16;
        description
          "Default MDT Group address prefix length";
      }

      leaf mdt-interface {
        type xr:Interface-name;
        description "MDT Interface handle";
      }

      leaf mldp-mdt-interface {
        type xr:Interface-name;
        description
          "MLDP MDT Interface handle";
      }

      leaf inband-mdt-interface {
        type xr:Interface-name;
        description
          "Inband MDT Interface handle";
      }

      leaf star-g-inband-mdt-interface {
        type xr:Interface-name;
        description
          "StarG Inband MDT Interface handle";
      }

      leaf p2mpte-mdt-interface {
        type xr:Interface-name;
        description
          "P2MPTE MDT Interface handle";
      }

      leaf ir-mdt-interface {
        type xr:Interface-name;
        description
          "IR MDT Interface handle";
      }

      leaf tr-mdt-interface {
        type xr:Interface-name;
        description
          "TreeSID MDT Interface handle";
      }

      leaf mldp-mdt-turnaround {
        type boolean;
        description "MLDP MDT Turnaround";
      }

      leaf p2mpte-mdt-turnaround {
        type boolean;
        description "P2MPTE MDT Turnaround";
      }

      leaf ir-mdt-turnaround {
        type boolean;
        description "IR MDT Turnaround";
      }

      leaf tr-mdt-turnaround {
        type boolean;
        description "TreeSID MDT Turnaround";
      }

      leaf mdt-interface-count {
        type uint32;
        description
          "No of routes using MDT handle";
      }

      leaf is-mdt-master-linecard {
        type boolean;
        description
          "Is this Master LC table";
      }

      leaf local-egress-count {
        type uint32;
        description
          "No of local egress interfaces";
      }

      leaf loopback {
        type xr:Interface-name;
        description
          "Loopback interface handle";
      }

      leaf customer-mdt-data-acl-name {
        type string;
        description
          "Data MDT ACL Name for customer vrf";
      }

      leaf customer-mdt-data-mldpacl-name {
        type string;
        description
          "MLDP Data MDT ACL Name for customer vrf";
      }

      leaf customer-mdt-data-p2mpteacl-name {
        type string;
        description
          "P2MPTE Data MDT ACL Name for customer vrf";
      }

      leaf customer-mdt-data-iracl-name {
        type string;
        description
          "IR Data MDT ACL Name for customer vrf";
      }

      leaf customer-mdt-data-tree-sidacl-name {
        type string;
        description
          "Tree-SID Data MDT ACL Name for customer vrf";
      }

      leaf is-customer-mdt-data-acl-present {
        type boolean;
        description
          "Is Data MDT ACL present";
      }

      leaf is-customer-mdt-data-mldpacl-present {
        type boolean;
        description
          "Is MLDP Data MDT ACL present";
      }

      leaf is-customer-mdt-data-p2mpteacl-present {
        type boolean;
        description
          "Is P2MPTE Data MDT ACL present";
      }

      leaf is-customer-mdt-data-iracl-present {
        type boolean;
        description
          "Is IR Data MDT ACL present";
      }

      leaf is-customer-mdt-data-tree-sidacl-present {
        type boolean;
        description
          "Is Tree-SID Data MDT ACL present";
      }

      leaf data-mdt-threshold {
        type uint32;
        description "Data MDT Threshold";
      }

      leaf is-all-customer-routes-for-data-mdt {
        type boolean;
        description
          "All customer routes for data mdt ?";
      }

      leaf is-all-customer-routes-for-mldp-data-mdt {
        type boolean;
        description
          "All customer routes for MLDP data mdt ?";
      }

      leaf is-all-customer-routes-for-p2mpte-data-mdt {
        type boolean;
        description
          "All customer routes for P2MPTE data mdt ?";
      }

      leaf is-all-customer-routes-for-ir-data-mdt {
        type boolean;
        description
          "All customer routes for IR data mdt ?";
      }

      leaf is-all-customer-routes-for-tree-sid-data-mdt {
        type boolean;
        description
          "All customer routes for Tree-SID data mdt ?";
      }

      leaf extranet-child-route-count {
        type uint32;
        description
          "Number of child extranet routes";
      }
    }  // grouping IPV4-MFWD-TABLE-BAG

    grouping IPV4-MFWD-NSF-BAG {
      description "MFIB NSF state";
      leaf multicast-nsf {
        type Ipv4-mfwd-nsf-modes;
        units "second";
        description
          "Multicast NSF state in secs";
      }

      leaf multicast-nsf-time-left {
        type uint32;
        units "second";
        description
          "Multicast NSF time remaining in secs";
      }

      leaf ifcnsf {
        type boolean;
        description "IFC NSF state";
      }
    }  // grouping IPV4-MFWD-NSF-BAG
  }  // submodule Cisco-IOS-XR-mfwd-oper-sub1