intGC.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");

	intGC.arp.addSC("arpa", "Standard arp protocol");

	intGC.arp.addSC("frame-relay", "Enable ARP for a frame relay interface");

	intGC.arp.addSC("probe", "HP style arp protocol");

	intGC.arp.addSC("snap", "IEEE 802.3 style arp");

	intGC.arp.addSC("timeout", "Set ARP cache timeout");

		intGC.arp.timeout.addSC("<0-2147483>", "Seconds");

intGC.addSC("backup", "Modify backup parameters");

	intGC.backup.addSC("delay", "Delays before backup line up or down transitions");

		intGC.backup.delay.addSC("<0-4294967294>", "Seconds");

			intGC.backup.delay["<0-4294967294>"].addSC("never", "Never deactivate the backup line");

		intGC.backup.delay.addSC("never", "Never activate the backup line");

			intGC.backup.delay.never.addSC("<0-4294967294>", "Seconds");

			intGC.backup.delay.never.addSC("never", "Never deactivate the backup line");

	intGC.backup.addSC("interface", "Configure an interface as a backup");

		intGC.backup.interface.addSC("Async", "Async interface");

			intGC.backup.interface.Async.addSC("<1-0>", "Async interface number");

		intGC.backup.interface.addSC("BVI", "Bridge-Group Virtual Interface");

			intGC.backup.interface.BVI.addSC("<1-255>", "BVI interface number");

		intGC.backup.interface.addSC("Dialer", "Dialer interface");

			intGC.backup.interface.Dialer.addSC("<0-255>", "Dialer interface number");

		intGC.backup.interface.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");

			intGC.backup.interface["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");

		intGC.backup.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");

			intGC.backup.interface.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");

		intGC.backup.interface.addSC("Group-Async", "Async Group interface");

			intGC.backup.interface["Group-Async"].addSC("<0-0>", "Group-Async interface number");

		intGC.backup.interface.addSC("Lex", "Lex interface");

			intGC.backup.interface.Lex.addSC("<0-2147483647>", "Lex interface number");

		intGC.backup.interface.addSC("Loopback", "Loopback interface");

			intGC.backup.interface.Loopback.addSC("<0-2147483647>", "Loopback interface number");

		intGC.backup.interface.addSC("Multilink", "Multilink-group interface");

			intGC.backup.interface.Multilink.addSC("<0-2147483647>", "Multilink interface number");

		intGC.backup.interface.addSC("Null", "Null interface");

			intGC.backup.interface.Null.addSC("<0-0>", "Null interface number");

		intGC.backup.interface.addSC("Port-channel", "Ethernet Channel of interfaces");

			intGC.backup.interface["Port-channel"].addSC("<1-64>", "Port-channel interface number");

		intGC.backup.interface.addSC("Tunnel", "Tunnel interface");

			intGC.backup.interface.Tunnel.addSC("<0-2147483647>", "Tunnel interface number");

		intGC.backup.interface.addSC("Virtual-Template", "Virtual Template interface");

			intGC.backup.interface["Virtual-Template"].addSC("<1-25>", "Virtual-Template interface number");

		intGC.backup.interface.addSC("Virtual-TokenRing", "Virtual TokenRing");

			intGC.backup.interface["Virtual-TokenRing"].addSC("<0-2147483647>", "Virtual-TokenRing interface number");

		intGC.backup.interface.addSC("Vlan", "Catalyst Vlans");

			intGC.backup.interface.Vlan.addSC("<1-1001>", "Vlan interface number");

	intGC.backup.addSC("load", "Load thresholds for line up or down transitions");

		intGC.backup.load.addSC("<0-100>", "Percentage");

			intGC.backup.load["<0-100>"].addSC("never", "Never deactivate the backup line");

		intGC.backup.load.addSC("never", "Never activate the backup line");

			intGC.backup.load.never.addSC("<0-100>", "Percentage");

			intGC.backup.load.never.addSC("never", "Never deactivate the backup line");

intGC.addSC("bandwidth", "Set bandwidth informational parameter");

	intGC.bandwidth.addSC("<1-10000000>", "Bandwidth in kilobits");

intGC.addSC("bgp-policy", "Apply policy propogated by bgp community string");

	intGC["bgp-policy"].addSC("accounting", "bgp based policy accounting of traffic");

	intGC["bgp-policy"].addSC("destination", "use destination IP address for route lookup");

		intGC["bgp-policy"].destination.addSC("ip-prec-map", "map ip precedence bits");

		intGC["bgp-policy"].destination.addSC("ip-qos-map", "set qos-group");

	intGC["bgp-policy"].addSC("source", "use source IP address for route lookup");

		intGC["bgp-policy"].source.addSC("ip-prec-map", "map ip precedence bits");

		intGC["bgp-policy"].source.addSC("ip-qos-map", "set qos-group");

intGC.addSC("carrier-delay", "Specify delay for interface transitions");

	intGC["carrier-delay"].addSC("<0-60>", "Carrier Transitions delay seconds");

	intGC["carrier-delay"].addSC("msec", "delay specified in milliseconds");

		intGC["carrier-delay"].msec.addSC("<0-1000>", "Carrier Transitions delay milliseconds");

intGC.addSC("cdp", "CDP interface subcommands");

	intGC.cdp.addSC("enable", "Enable CDP on interface");

intGC.addSC("channel-group", "Etherchannel/port bundling configuration");

	intGC["channel-group"].addSC("<1-64>", "Channel group number");

		intGC["channel-group"]["<1-64>"].addSC("mode", "Etherchannel Mode of the interface");

intGC.addSC("custom-queue-list", "Assign a custom queue list to an interface");

	intGC["custom-queue-list"].addSC("<1-16>", "Custom queue list number");

intGC.addSC("default", "Set a command to its defaults");

	intGC["default"].addSC("arp", "Set arp type (arpa, probe, snap) or timeout");

		intGC["default"].arp.addSC("arpa", "Standard arp protocol");

		intGC["default"].arp.addSC("frame-relay", "Enable ARP for a frame relay interface");

		intGC["default"].arp.addSC("probe", "HP style arp protocol");

		intGC["default"].arp.addSC("snap", "IEEE 802.3 style arp");

		intGC["default"].arp.addSC("timeout", "Set ARP cache timeout");

	intGC["default"].addSC("backup", "Modify backup parameters");

		intGC["default"].backup.addSC("delay", "Delays before backup line up or down transitions");

		intGC["default"].backup.addSC("interface", "Configure an interface as a backup");

		intGC["default"].backup.addSC("load", "Load thresholds for line up or down transitions");

	intGC["default"].addSC("bandwidth", "Set bandwidth informational parameter");

	intGC["default"].addSC("bgp-policy", "Apply policy propogated by bgp community string");

		intGC["default"]["bgp-policy"].addSC("accounting", "bgp based policy accounting of traffic");

		intGC["default"]["bgp-policy"].addSC("destination", "use destination IP address for route lookup");

		intGC["default"]["bgp-policy"].addSC("source", "use source IP address for route lookup");

	intGC["default"].addSC("carrier-delay", "Specify delay for interface transitions");

	intGC["default"].addSC("cdp", "CDP interface subcommands");

		intGC["default"].cdp.addSC("enable", "Enable CDP on interface");

	intGC["default"].addSC("channel-group", "Etherchannel/port bundling configuration");

	intGC["default"].addSC("custom-queue-list", "Assign a custom queue list to an interface");

intGC.addSC("delay", "Specify interface throughput delay");

	intGC.delay.addSC("<1-16777215>", "Throughput delay (tens of microseconds)");

intGC.addSC("description", "Interface specific description");

	intGC.description.addSC("LINE", "Up to 240 characters describing this interface");

intGC.addSC("exit", "Exit from interface configuration mode");

intGC.addSC("fair-queue", "Enable Fair Queuing on an Interface");

	intGC["fair-queue"].addSC("<1-4096>", "Congestive Discard Threshold");

		intGC["fair-queue"]["<1-4096>"].addSC("<16-4096>", "Number Dynamic Conversation Queues");

			intGC["fair-queue"]["<1-4096>"]["<16-4096>"].addSC("<0-1000>", "Number Reservable Conversation Queues");

intGC.addSC("flowcontrol", "Configure flow operation.");

	intGC.flowcontrol.addSC("receive", "Configure receiving flow operation");

		intGC.flowcontrol.receive.addSC("desired", "Allow but do not require flow-control packets on port");

		intGC.flowcontrol.receive.addSC("off", "Disable flow-control packets on port");

		intGC.flowcontrol.receive.addSC("on", "Enable flow-control packets on port");

	intGC.flowcontrol.addSC("send", "Configure sending flow operation");

		intGC.flowcontrol.send.addSC("desired", "Allow but do not require flow-control packets on port");

		intGC.flowcontrol.send.addSC("off", "Disable flow-control packets on port");

		intGC.flowcontrol.send.addSC("on", "Enable flow-control packets on port");

intGC.addSC("help", "Description of the interactive help system");

intGC.addSC("hold-queue", "Set hold queue depth");

	intGC["hold-queue"].addSC("<0-4096>", "Queue length");

		intGC["hold-queue"]["<0-4096>"].addSC("in", "Input queue");

		intGC["hold-queue"]["<0-4096>"].addSC("out", "Output queue");

intGC.addSC("ip", "Interface Internet Protocol config commands");

	intGC.ip.addSC("address", "Set the IP address of an interface");

		intGC.ip.address.addSC("A.B.C.D", "IP address");

			intGC.ip.address["A.B.C.D"].addSC("A.B.C.D", "IP subnet mask");

				intGC.ip.address["A.B.C.D"]["A.B.C.D"].addSC("secondary", "Make this IP address a secondary address");

intGC.addSC("keepalive", "Enable keepalive");

	intGC.keepalive.addSC("<0-32767>", "Keepalive period (default 10 seconds)");

intGC.addSC("load-interval", "Specify interval for load calculation for an interface");

	intGC["load-interval"].addSC("<30-600>", "Load interval delay in seconds");

intGC.addSC("logging", "Configure logging for interface");

	intGC.logging.addSC("event", "Interface events");

		intGC.logging.event.addSC("link-status", "UPDOWN and CHANGE messages");

intGC.addSC("loopback", "Configure internal loopback on an interface");

intGC.addSC("max-reserved-bandwidth", "Maximum Reservable Bandwidth on an Interface");

	intGC["max-reserved-bandwidth"].addSC("<1-100>", "Max. reservable bandwidth as % of interface bandwidth");

intGC.addSC("no", "Negate a command or set its defaults");

	intGC.no.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");

		intGC.no.arp.addSC("arpa", "Standard arp protocol");

		intGC.no.arp.addSC("frame-relay", "Enable ARP for a frame relay interface");

		intGC.no.arp.addSC("probe", "HP style arp protocol");

		intGC.no.arp.addSC("snap", "IEEE 802.3 style arp");

		intGC.no.arp.addSC("timeout", "Set ARP cache timeout");

	intGC.no.addSC("backup", "Modify backup parameters");

		intGC.no.backup.addSC("delay", "Delays before backup line up or down transitions");

		intGC.no.backup.addSC("interface", "Configure an interface as a backup");

		intGC.no.backup.addSC("load", "Load thresholds for line up or down transitions");

	intGC.no.addSC("bandwidth", "Set bandwidth informational parameter");

	intGC.no.addSC("bgp-policy", "Apply policy propogated by bgp community string");

		intGC.no["bgp-policy"].addSC("accounting", "bgp based policy accounting of traffic");

		intGC.no["bgp-policy"].addSC("destination", "use destination IP address for route lookup");

		intGC.no["bgp-policy"].addSC("source", "use source IP address for route lookup");

	intGC.no.addSC("carrier-delay", "Specify delay for interface transitions");

	intGC.no.addSC("cdp", "CDP interface subcommands");

		intGC.no.cdp.addSC("enable", "Enable CDP on interface");

	intGC.no.addSC("channel-group", "Etherchannel/port bundling configuration");

	intGC.no.addSC("custom-queue-list", "Assign a custom queue list to an interface");

	intGC.no.addSC("delay", "Specify interface throughput delay");

	intGC.no.addSC("description", "Interface specific description");

	intGC.no.addSC("fair-queue", "Enable Fair Queuing on an Interface");

		intGC.no["fair-queue"].addSC("<1-4096>", "Congestive Discard Threshold");

	intGC.no.addSC("flowcontrol", "Configure flow operation.");

		intGC.no.flowcontrol.addSC("receive", "Configure receiving flow operation");

		intGC.no.flowcontrol.addSC("send", "Configure sending flow operation");

	intGC.no.addSC("hold-queue", "Set hold queue depth");

		intGC.no["hold-queue"].addSC("<0-4096>", "Queue length");

		intGC.no["hold-queue"].addSC("in", "Input queue");

		intGC.no["hold-queue"].addSC("out", "Output queue");

	intGC.no.addSC("ip", "Interface Internet Protocol config commands");

		intGC.no.ip.addSC("address", "Set the IP address of an interface");

	intGC.no.addSC("keepalive", "Enable keepalive");

		intGC.no.keepalive.addSC("<0-32767>", "Keepalive period (default 10 seconds)");

	intGC.no.addSC("load-interval", "Specify interval for load calculation for an interface");

	intGC.no.addSC("logging", "Configure logging for interface");

		intGC.no.logging.addSC("event", "Interface events");

	intGC.no.addSC("loopback", "Configure internal loopback on an interface");

	intGC.no.addSC("max-reserved-bandwidth", "Maximum Reservable Bandwidth on an Interface");

		intGC.no["max-reserved-bandwidth"].addSC("<1-100>", "Max. reservable bandwidth as % of interface bandwidth");

intGC.addSC("ntp", "Configure NTP");

	intGC.ntp.addSC("broadcast", "Configure NTP broadcast service");

		intGC.ntp.broadcast.addSC("client", "Listen to NTP broadcasts");

		intGC.ntp.broadcast.addSC("destination", "Configure broadcast destination address");

		intGC.ntp.broadcast.addSC("key", "Configure broadcast authentication key");

		intGC.ntp.broadcast.addSC("version", "Configure NTP version");

	intGC.ntp.addSC("disable", "Disable NTP");

	intGC.ntp.addSC("multicast", "Configure NTP multicast service");

		intGC.ntp.multicast.addSC("A.B.C.D", "Multicast group IP address");

		intGC.ntp.multicast.addSC("client", "Listen to NTP multicasts");

		intGC.ntp.multicast.addSC("key", "Configure multicast authentication key");

		intGC.ntp.multicast.addSC("ttl", "TTL of the multicast packet");

		intGC.ntp.multicast.addSC("version", "Configure NTP version");

intGC.addSC("pagp", "PAgP interface subcommands");

	intGC.pagp.addSC("learn-method", "The ability to determine the input interface of incoming packets");

		intGC.pagp["learn-method"].addSC("aggregation-port", "Learns the destination on the agport");

		intGC.pagp["learn-method"].addSC("physical-port", "Learns the destination on the physical port");

	intGC.pagp.addSC("port-priority", "PAgP priority on this interface");

		intGC.pagp["port-priority"].addSC("<0-255>", "Priority number");

intGC.addSC("priority-group", "Assign a priority group to an interface");

	intGC["priority-group"].addSC("<1-16>", "Priority group");

intGC.addSC("qos", "QoS configuration");

	intGC.qos.addSC("cos", "Default CoS");

		intGC.qos.cos.addSC("<0-7>", "CoS value");

	intGC.qos.addSC("dscp", "Default DSCP");

		intGC.qos.dscp.addSC("<0-63>", "DSCP value");

	intGC.qos.addSC("trust", "Trust state of the interface");

		intGC.qos.trust.addSC("cos", "Trust CoS");

		intGC.qos.trust.addSC("dscp", "Trust DSCP");

	intGC.qos.addSC("vlan-based", "Vlan-based QoS");

intGC.addSC("random-detect", "Enable Weighted Random Early Detection (WRED) on an Interface");

intGC.addSC("rate-limit", "Rate Limit");

	intGC["rate-limit"].addSC("input", "Rate limit on input");

		intGC["rate-limit"].input.addSC("<8000-2000000000>", "Bits per second");

		intGC["rate-limit"].input.addSC("access-group", "Match access list");

		intGC["rate-limit"].input.addSC("dscp", "Match dscp value");

		intGC["rate-limit"].input.addSC("qos-group", "Match qos-group ID");

	intGC["rate-limit"].addSC("output", "Rate limit on output");

		intGC["rate-limit"].output.addSC("<8000-2000000000>", "Bits per second");

		intGC["rate-limit"].output.addSC("access-group", "Match access list");

		intGC["rate-limit"].output.addSC("dscp", "Match dscp value");

		intGC["rate-limit"].output.addSC("qos-group", "Match qos-group ID");

intGC.addSC("rmon", "Configure Remote Monitoring on an interface");

	intGC.rmon.addSC("collection", "Configure Remote Monitoring Collection on an interface");

		intGC.rmon.collection.addSC("history", "Configure history");

		intGC.rmon.collection.addSC("stats", "Configure statistics");

	intGC.rmon.addSC("native", "Monitor the interface in native mode");

	intGC.rmon.addSC("promiscuous", "Monitor the interface in promiscuous mode");

intGC.addSC("service-policy", "Configure QoS Service Policy");

	intGC["service-policy"].addSC("history", "Keep history of QoS metrics");

	intGC["service-policy"].addSC("input", "Assign policy-map to the input of an interface");

		intGC["service-policy"].input.addSC("WORD", "policy-map name");

	intGC["service-policy"].addSC("output", "Assign policy-map to the output of an interface");

		intGC["service-policy"].output.addSC("WORD", "policy-map name");

intGC.addSC("shutdown", "Shutdown the selected interface");

intGC.addSC("snmp", "Modify SNMP interface parameters");

	intGC.snmp.addSC("trap", "Allow a specific SNMP trap");

		intGC.snmp.trap.addSC("link-status", "Allow SNMP LINKUP and LINKDOWN traps");

intGC.addSC("spanning-tree", "Spanning Tree Subsystem");

	intGC["spanning-tree"].addSC("cost", "Change an interface's spanning tree port path cost");

		intGC["spanning-tree"].cost.addSC("<1-200000000>", "port path cost");

	intGC["spanning-tree"].addSC("guard", "Change an interface's spanning tree guard mode");

		intGC["spanning-tree"].guard.addSC("none", "Set guard mode to none");

		intGC["spanning-tree"].guard.addSC("root", "Set guard mode to root guard on interface");

	intGC["spanning-tree"].addSC("port-priority", "Change an interface's spanning tree port priority");

		intGC["spanning-tree"]["port-priority"].addSC("<0-240>", "port priority in increments of 16");

	intGC["spanning-tree"].addSC("portfast", "Enable an interface to move directly to forwarding on link up");

	intGC["spanning-tree"].addSC("vlan", "VLAN Switch Spanning Tree");

		intGC["spanning-tree"].vlan.addSC("<1-1005>", "Spanning tree VLAN id");

intGC.addSC("speed", "Configure speed operation.");

	intGC.speed.addSC("nonegotiate", "Do not negotiate speed");

intGC.addSC("switchport", "Set switching mode characteristics");

	intGC.switchport.addSC("access", "Set access mode characteristics of the interface");

		intGC.switchport.access.addSC("vlan", "Set VLAN when interface is in access mode");

	intGC.switchport.addSC("host", "Set port host");

	intGC.switchport.addSC("mode", "Set trunking mode of the interface");

		intGC.switchport.mode.addSC("access", "Set trunking mode to ACCESS unconditionally");

		intGC.switchport.mode.addSC("dynamic", "Set trunking mode to dynamically negotiate access or trunk mode");

		intGC.switchport.mode.addSC("private-vlan", "Set the mode to private-vlan host or promiscuous");

		intGC.switchport.mode.addSC("trunk", "Set trunking mode to TRUNK unconditionally");

	intGC.switchport.addSC("nonegotiate", "Device will not engage in negotiation protocol on this interface");

	intGC.switchport.addSC("private-vlan", "Set the private VLAN host association or promiscuous mapping");

		intGC.switchport["private-vlan"].addSC("host-association", "Set the private VLAN host association");

		intGC.switchport["private-vlan"].addSC("mapping", "Set the private VLAN promiscuous mapping");

	intGC.switchport.addSC("trunk", "Set trunking characteristics of the interface");

		intGC.switchport.trunk.addSC("allowed", "Set allowed VLAN characteristics when interface is in trunking mode");

		intGC.switchport.trunk.addSC("encapsulation", "Set trunking encapsulation when interface is in trunking mode");

		intGC.switchport.trunk.addSC("native", "Set trunking native characteristics when interface is in trunking mode");

		intGC.switchport.trunk.addSC("pruning", "Set pruning VLAN characteristics when interface is in trunking mode");

intGC.addSC("timeout", "Define timeout values for this interface");

	intGC.timeout.addSC("absolute", "Define session timeout value for this interface");

		intGC.timeout.absolute.addSC("<0-35790>", "Session lifetime (in minutes)");

intGC.addSC("traffic-shape", "Enable Traffic Shaping on an Interface or Sub-Interface");

	intGC["traffic-shape"].addSC("group", "configure token bucket: group <access-list> CIR (bps) [Bc (bits) [Be (bits)]]");

		intGC["traffic-shape"].group.addSC("<1-2699>", "selecting Access list");

	intGC["traffic-shape"].addSC("rate", "configure token bucket: CIR (bps) [Bc (bits) [Be (bits)]]");

		intGC["traffic-shape"].rate.addSC("<8000-100000000>", "Target Bit Rate (bits per second)");

intGC.addSC("transmit-interface", "Assign a transmit interface to a receive-only interface");

	intGC["transmit-interface"].addSC("Async", "Async interface");

		intGC["transmit-interface"].Async.addSC("<1-0>", "Async interface number");

	intGC["transmit-interface"].addSC("Dialer", "Dialer interface");

		intGC["transmit-interface"].Dialer.addSC("<0-255>", "Dialer interface number");

	intGC["transmit-interface"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");

		intGC["transmit-interface"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");

	intGC["transmit-interface"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");

		intGC["transmit-interface"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");

	intGC["transmit-interface"].addSC("Group-Async", "Async Group interface");

		intGC["transmit-interface"]["Group-Async"].addSC("<0-0>", "Group-Async interface number");

	intGC["transmit-interface"].addSC("Lex", "Lex interface");

		intGC["transmit-interface"].Lex.addSC("<0-2147483647>", "Lex interface number");

	intGC["transmit-interface"].addSC("Loopback", "Loopback interface");

		intGC["transmit-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");

	intGC["transmit-interface"].addSC("Multilink", "Multilink-group interface");

		intGC["transmit-interface"].Multilink.addSC("<0-2147483647>", "Multilink interface number");

	intGC["transmit-interface"].addSC("Null", "Null interface");

		intGC["transmit-interface"].Null.addSC("<0-0>", "Null interface number");

	intGC["transmit-interface"].addSC("Port-channel", "Ethernet Channel of interfaces");

		intGC["transmit-interface"]["Port-channel"].addSC("<1-64>", "Port-channel interface number");

	intGC["transmit-interface"].addSC("Tunnel", "Tunnel interface");

		intGC["transmit-interface"].Tunnel.addSC("<0-2147483647>", "Tunnel interface number");

	intGC["transmit-interface"].addSC("Virtual-Template", "Virtual Template interface");

		intGC["transmit-interface"]["Virtual-Template"].addSC("<1-25>", "Virtual-Template interface number");

	intGC["transmit-interface"].addSC("Virtual-TokenRing", "Virtual TokenRing");

		intGC["transmit-interface"]["Virtual-TokenRing"].addSC("<0-2147483647>", "Virtual-TokenRing interface number");

	intGC["transmit-interface"].addSC("Vlan", "Catalyst Vlans");

		intGC["transmit-interface"].Vlan.addSC("<1-1001>", "Vlan interface number");

intGC.addSC("tx-queue", "Configure interface transmit queue");

	intGC["tx-queue"].addSC("<1-4>", "Transmit queue number");

intGC.addSC("tx-ring-limit", "Configure PA level transmit ring limit");

	intGC["tx-ring-limit"].addSC("<1-32767>", "Number (ring limit)");

intGC.addSC("udld", "Configure UDLD enabled or disabled and ignore global UDLD setting");

	intGC.udld.addSC("aggressive", "Enable UDLD protocol in aggressive mode on this interface despite global UDLD setting");

	intGC.udld.addSC("disable", "Disable UDLD protocol on this interface despite global UDLD setting");

	intGC.udld.addSC("enable", "Enable UDLD protocol on this interface despite global UDLD setting");