Help us improve your experience.

Let us know what you think.

Do you have time for a two-minute survey?

header-navigation

Solutions

Featured solutions AI Campus and branch Data center WAN Security Service provider Cloud operator Industries
Campus and Branch

Welcome to the NOW Way to Wi-Fi

Take your networking performance to new heights with a modern, cloud-native, AI-Native architecture. Only Juniper can help you unleash the full potential of Wi-Fi 7 with our AI-Native platform for innovation.
Prepare for liftoff
Business intelligence analyst dashboard on virtual screen. Big data Graphs Charts.

AI Data Center Networking

Juniper’s AI data center solution is a quick way to deploy high performing AI training and inference networks that are the most flexible to design and easiest to manage with limited IT resources.
Find out more
Enterprise AI-Native Networking

Enterprise AI‑Native Routing

Juniper's Ai-Native routing solution delivers robust 400GbE and 800GbE capabilities for unmatched performance, reliability, and sustainability at scale.
Explore enterprise routing
Zero trust security

Ops4AI Lab

Visit our lab in Sunnyvale, CA and see our AI data center solution for yourself. You can try out your own model’s functionality and performance, too.
Visit the lab
Enterprise AI-Native Networking

Enterprise AI‑Native Routing

Juniper's Ai-Native routing solution delivers robust 400GbE and 800GbE capabilities for unmatched performance, reliability, and sustainability at scale.
Explore enterprise routing
Higher Education

Shaping Student Experiences: The NOW Way to Build Higher Education Networks

Join Juniper Networks CIO Sharon Mandell and a virtual summit of C-level IT leaders from prestigious institutions as they discuss ongoing efforts to support digital transformation.
Register to attend
Hand on tablet with healthcare overlay of graphics

Security in healthcare

In this IDC Spotlight report, discover how AI networking can automate and strengthen a healthcare ecosystem to defeat criminals and prevent loss. 
Gain insights into ecosystem security
Retail

The Future of In-Store Technologies

Join us for an enlightening webinar with Kevin McCartan, Senior IT Service Delivery Engineer at Musgrave; retail guru Jack Stratten of Insider Trends; and Christian Gilby, Director of Product Marketing at Juniper Networks, as they discuss the future of in-store technologies.
Reserve my spot

Products

Wireless access Wired access SD-WAN / SASE Routing and switching Security Mist AI™ Management software Network operating system Blueprint for AI-Native Acceleration Optics
  • Operations
ACX7020 router

Juniper ACX7020 Cloud Metro Access Router

Legacy networks simply cannot meet the demands of today’s rapidly evolving metro landscape. Unlock a new generation of highly scalable architectures and automated operations with the Juniper ACX7020. 
Learn more
EX4000 Ethernet Switch

Next-gen AI-Native EX4000 line of switches

Lack of AI innovation from your current networking vendor slowing you down? Embrace Juniper’s cloud-native, AI-Native access switches that support every level and layer, across nearly every deployment.
Discover how
The Q and AI text with an image of Bob Friday and Kedar Dhuru.

The Q&AI Podcast

Delivering practical solutions and enriching discussions, this podcast series is a vital resource for those seeking an in-depth exploration of AI's transformative potential.
Catch the latest episode

Services

Services
Services AI Care

Juniper AI Care Services Revolutionize Your Service Experience

Our industry-first AI-Native services couple AIOps with our deep expertise across the full network life cycle. You can move from reactive response to proactive insight and action.
Explore AI Care Services
Services AI Data Center

Juniper AI Data Center Deployment Services Optimize Your AI Model Runs

We use our expertise and validated designs to help design, deploy, validate and tune networks, including GPUs and storage, to get the most from your AI infrastructure operation.
Learn about AI Data Center Deployment Services

Partners

Partners

Support and Documentation

Support and Documentation

Learn

About Juniper Training Events The Feed Resources Technology learning topics Thought leadership and insights
Audience raising hands up while businessman is speaking in training at the office.

Juniper certification and training news

See the latest
Ringing of the bell

All global events

See the latest
AI-native-now

AI-Native NOW event series

Register now
Juniper's Christina Hendrix at the head of a conference table. With the text "The NOW Way to Network" overlayed, with "NOW" emphasizing the "O" in green color.

The NOW Way to Network

Watch the video series
AI Native Now

Executive insights

Dive deep with leading experts and thought leaders on all the topics that matter most to your business, from AI to network security to driving rapid, relevant transformation for your business.
Learn more
A keynote speaker giving a presentation at a conference. There are dozens of people sitting around them. The presentation is displayed via projector on all the walls in the room.

Leadership voices

Juniper Networks’ leaders operate on the front lines of creating the network of the future. Take a look around to see what’s on their minds.
Watch now
Bob Friday and Jessica Garrison speaking

Bob Friday Talks

Join Bob as he ventures into all the knowns -- and -- unknowns -- of AI.
Catch the latest episode
Documentation
Menu
License Guide
Quick Starts
Validated Designs
Explore Pathfinder Apps
CLI Explorer
Feature Explorer
Hardware Compatibility Tool
Port Checker
Browse All
Collapse

Pathfinder Apps

All

By Software

By Hardware

Learn More
Pathfinder HomeCLI ExplorerCompliance AdvisorFeature ExplorerHardware Compatibility ToolJunos XML API ExplorerJunos YANG Data Model ExplorerPort CheckerPower CalculatorSNMP MIB ExplorerSystem Log Explorer
CLI ExplorerFeature ExplorerJunos XML API ExplorerJunos YANG Data Model ExplorerSNMP MIB ExplorerSystem Log Explorer
Compliance AdvisorFeature ExplorerHardware Compatibility ToolPort CheckerPower Calculator
Home Documentation Junos OS Junos CLI Reference CLI Reference D

Junos CLI Reference

keyboard_arrow_up
close
keyboard_arrow_left
Junos CLI Reference
Table of Contents Expand all
list Table of Contents
file_download PDF
{ "lLangCode": "en", "lName": "English", "lCountryCode": "us", "transcode": "en_US" }
English
ON THIS PAGE
keyboard_arrow_right

ddos-protection

date_range 31-Aug-23
arrow_backward
arrow_forward

Syntax

content_copy zoom_out_map
 ddos-protection {
 global {
  disable-fpc;
  disable-logging;
  disable-routing-engine;
  flow-detection;
  flow-detection-mode(automatic | off | on);
  flow-level-control(drop | keep | police);


  flow-report-rate reports per second;
  violation-report-rate reports per second;
 }
 protocols {
  all-fiber-channel-enode {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  amtv4 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  amtv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ancp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ancpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  arp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   arp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   bcast {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ucast {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  atm {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }


  bfd {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   bundle-bfd {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   multihop-bfd {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  bfdv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  bgp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  bgpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  custom {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  demux-autosense {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dhcpv4 {
   ack {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;


    recover-time seconds;




   }
   bad-packets {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   bootp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   decline {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   discover {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   force-renew {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   inform {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lease-active {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lease-query {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lease-unassigned {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lease-unknown {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   nak {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   no-message-type {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   offer {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   rebind {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   release {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   renew {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   request {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dhcpv4v6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dhcpv6 {
   advertise {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   confirm {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   decline {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   information-request {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   leasequery {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   leasequery-data {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   leasequery-done {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   leasequery-reply {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   rebind {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   reconfigure {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   relay-forward {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   relay-reply {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   release {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   renew {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   reply {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   request {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   solicit {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  diameter {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dns {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dtcp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  dynamic-vlan {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  egpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  eoam {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   oam-cfm {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  esmc {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  exceptions {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   mcast-rpf-err {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mtu-exceeded {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  fab-probe {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  filter-action {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   filter-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   filter-v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   other {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  fip-snooping {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  firewall-host {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  frame-relay {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   frf15 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   frf16 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ftp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ftpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  garp-reply {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  gre {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   hag {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   hbc {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   punt {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  gtp-path-mgmt {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
  }
  icmp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  icmpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  igmp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   query {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   report {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  igmpv4v6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  igmpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mld {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mld-query {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mld-report {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  inline-ka {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  inline-svcs {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ip-fragments {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   first-fragment {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   trail-fragment {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ipmcast-miss {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ipmc-reserved {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ip-options {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   non-v4v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   router-alert {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ipsec {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   ike {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mtu-error {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   on-trigger {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   sn-alarm {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   spi-inval {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   tx-alarm {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }




  isis {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   isis-data {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   isis-hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  jfm {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l2pt {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l2tp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l3dest-miss {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l3mc-sgv-hit-icl {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l3mtu-fail {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  l3nhop {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  lacp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ldp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ldp-hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ldpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  lldp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  lmp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  lmpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  localnh {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  mac-host {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  martian-address {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  mcast-snoop {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   igmp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mld {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   pim {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  mld {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  mlp {
   add {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   delete {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lookup {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   macpin-exception {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  msdp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  msdpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }


  mvrp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ndpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   invalid-hop-limit {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   neighbor-advertisement {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   neighbor-solicitation {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   redirect {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   router-advertisement {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   router-solicitation {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  nonucast-switch {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ntp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  oam-lfm {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ospf {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ospf-hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ospf-uncls {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ospf-hello {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ospfv3v6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ospfv3v6-hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ospfv3v6-uncls {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  overlay {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   arp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ndpv6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pfcp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
  }
  pfe-alive {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pim {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pim-ctrl {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   join {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pim-data {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pimv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pkt-inject {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pmvrp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pos {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ppp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   authentication {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   echo-rep {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   echo-req {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ipcp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ipv6cp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   isis {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   lcp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mlppp-lcp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mplscp {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pppoe {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   padi {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   padm {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   padn {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   pado {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   padr {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   pads {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   padse {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   padt {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  proto-802-1x {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ptp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ptpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  pvstp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  radius {
   accounting {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   authorization {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   server {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  redirect {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  reject {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  rejectv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  re-services {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   captive-portal {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  re-services-v6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   captive-portal {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  resolve {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   mcast-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mcast-v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   other {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ucast-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ucast-v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  rip {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ripv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  rsvp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   rsvp-hello {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   rsvp-uncls {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  rsvpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  sample {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   host {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   pfe {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   sflow {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   syslog {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   tap {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  sample-dest {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  sample-source {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  sctp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  services {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   bsdt {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   packet {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  snmp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  snmpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ssh {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  sshv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  stp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  syslog {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  tacacs {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  tcc {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   ethernet-tcc {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   iso-tcc {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  tcp-flags {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   established {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   initial {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  telnet {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  telnetv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  ttl {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  tunnel-fragment {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  tunnel-ka {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  unclassified {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   control-layer2 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   control-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   control-v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }




   fw-host {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   host-route-tcp-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   host-route-udp-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   host-route-v4 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   host-route-v6 {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   mcast-copy {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   other {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }




  }
  unknown-l2mc {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  urpf-fail {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  vcipc-udp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  virtual-chassis {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;














    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
    }


    recover-time seconds;




   }
   control-high {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   control-low {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   unclassified {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   vc-packets {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   vc-ttl-errors {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  vrrp {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  vrrpv6 {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
  vxlan {
   aggregate {
    bandwidth packets per second;
    burst packets;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
   bfd {
    bandwidth packets per second;
    burst packets;
    bypass-aggregate;
    disable-fpc;
    disable-logging;
    disable-routing-engine;
    flow-detection-mode(automatic | off | on);
    flow-detect-time seconds;
    flow-level-bandwidth {
     logical-interface packets per second;
     physical-interface packets per second;
     subscriber packets per second;
    }
    flow-level-control {
     logical-interface(drop | keep | police);
     physical-interface(drop | keep | police);
     subscriber(drop | keep | police);
    }
    flow-level-detection {
     logical-interface(automatic | off | on);
     physical-interface(automatic | off | on);
     subscriber(automatic | off | on);
    }
    flow-recover-time seconds;
    flow-timeout-time seconds;
    fpc name {
     bandwidth-scale percent;
     burst-scale percent;
     disable-fpc;
     hostbound-queue hostbound-queue;
    }
    hostbound-queue hostbound-queue;
    no-flow-logging;
    priority(high | low | medium);
    recover-time seconds;
    timeout-active-flows;


   }
  }
 }
 traceoptions {
  file< filename><files files><match match><size size><(world-readable | no-world-readable)>;
  flag name;

  level(all | error | info | notice | verbose | warning);
  no-remote-trace;


 }
 }

Hierarchy Level

content_copy zoom_out_map
[edit system]

Description

Configure DDOS process

Required Privilege Level

admin—To view this statement in the configuration.

admin-control—To add this statement to the configuration.

Release Information

arrow_backward PREVIOUS dce-options
NEXT arrow_forward ddos-protection (DDoS)
footer-navigation

© 1999 - 2025 Juniper Networks, Inc. All rights reserved.

Scroll to top