path: root/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Router 1721/cmd_global.txt

globalC.addSC("aaa", "Authentication, Authorization and Accounting.");

	globalC.aaa.addSC("new-model", "Enable NEW access control commands and functions.(Disables OLD commands.)");

globalC.addSC("access-list", "Add an access list entry");

	globalC["access-list"].addSC("<1-99>", "IP standard access list");

		globalC["access-list"]["<1-99>"].addSC("deny", "Specify packets to reject");

		   	globalC["access-list"]["<1-99>"].deny.addSC("A.B.C.D",  "Address to match");

		 		globalC["access-list"]["<1-99>"].deny["A.B.C.D"].addSC("A.B.C.D","Wildcard bits");

 	                  globalC["access-list"]["<1-99>"].deny["A.B.C.D"].addSC("log","Log matches against this entry");

	  	  	  		globalC["access-list"]["<1-99>"].deny["A.B.C.D"].log.addSC("log","Log matches against this entry");

			  globalC["access-list"]["<1-99>"].deny.addSC("any", "Any source host");

			  globalC["access-list"]["<1-99>"].deny.addSC("host", "A single host address");

		globalC["access-list"]["<1-99>"].addSC("permit", "Specify packets to forward");

			  globalC["access-list"]["<1-99>"].permit.addSC("A.B.C.D",  "Address to match");

			  	  globalC["access-list"]["<1-99>"].permit["A.B.C.D"].addSC("A.B.C.D",  "Wildcard bits");

				  globalC["access-list"]["<1-99>"].permit["A.B.C.D"].addSC("log","Log matches against this entry");

			  	  	  globalC["access-list"]["<1-99>"].permit["A.B.C.D"].log.addSC("log","Log matches against this entry");

			  globalC["access-list"]["<1-99>"].permit.addSC("any", "Any source host");

			  globalC["access-list"]["<1-99>"].permit.addSC("host", "A single host address");

		globalC["access-list"]["<1-99>"].addSC("remark",  "Access list entry comment");

	globalC["access-list"].addSC("<100-199>", "IP extended access list");

		globalC["access-list"]["<100-199>"].addSC("deny", "Specify packets to reject");

			  globalC["access-list"]["<100-199>"].deny.addSC("<0-255>",  "An IP protocol number");

			  globalC["access-list"]["<100-199>"].deny.addSC("eigrp", "Cisco's EIGRP routing protocol");

			  globalC["access-list"]["<100-199>"].deny.addSC("icmp", "Internet Control Message Protocol");

			  globalC["access-list"]["<100-199>"].deny.addSC("igmp","Internet Gateway Message Protocol");

			  globalC["access-list"]["<100-199>"].deny.addSC("ip","Any Internet Protocol");

			  globalC["access-list"]["<100-199>"].deny.addSC("ospf","OSPF routing protocol");

			  globalC["access-list"]["<100-199>"].deny.addSC("tcp","Transmission Control Protocol");

			  	  globalC["access-list"]["<100-199>"].deny.tcp.addSC("A.B.C.D","Source address");

				  globalC["access-list"]["<100-199>"].deny.tcp.addSC("any","Any source host");

				  	  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("A.B.C.D","Destination address");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("any","Any destination host");

					  	  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("ack", "Match on the ACK bit");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("eq","Match only packets on a given port number");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("fin","Match on the FIN bit");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("gt","Match only packets with a greater port number");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("lt", "Match only packets with a lower port number");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("neq",  "Match only packets not on a given port number");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("precedence",  "Match packets with given precedence value");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("range", "Match only packets in the range of port numbers");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("time-range",  "Specify a time-range");

						  globalC["access-list"]["<100-199>"].deny.tcp.any.any.addSC("tos", "Match packets with given TOS value");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("eq","Match only packets on a given port number");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("gt","Match only packets with a greater port number");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("host","A single destination host");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("lt","Match only packets with a lower port number");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("neq",  "Match only packets not on a given port number");

					  globalC["access-list"]["<100-199>"].deny.tcp.any.addSC("range", "Match only packets in the range of port numbers");

				  globalC["access-list"]["<100-199>"].deny.tcp.addSC("host", "A single source host");

			  globalC["access-list"]["<100-199>"].deny.addSC("udp", "User Datagram Protocol");

		globalC["access-list"]["<100-199>"].addSC("dynamic", "Specify a DYNAMIC list of PERMITs or DENYs");

		globalC["access-list"]["<100-199>"].addSC("permit", "Specify packets to forward");

			  globalC["access-list"]["<100-199>"].permit.addSC("<0-255>",  "An IP protocol number");

			  globalC["access-list"]["<100-199>"].permit.addSC("eigrp", "Cisco's EIGRP routing protocol");

			  globalC["access-list"]["<100-199>"].permit.addSC("icmp", "Internet Control Message Protocol");

			  globalC["access-list"]["<100-199>"].permit.addSC("igmp","Internet Gateway Message Protocol");

			  globalC["access-list"]["<100-199>"].permit.addSC("ip","Any Internet Protocol");

			  globalC["access-list"]["<100-199>"].permit.addSC("ospf","OSPF routing protocol");

			  globalC["access-list"]["<100-199>"].permit.addSC("tcp","Transmission Control Protocol");

			  	  globalC["access-list"]["<100-199>"].permit.tcp.addSC("A.B.C.D","Source address");

				  globalC["access-list"]["<100-199>"].permit.tcp.addSC("any","Any source host");

				  	  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("A.B.C.D","Destination address");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("any","Any destination host");

					  	  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("ack", "Match on the ACK bit");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("eq","Match only packets on a given port number");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("fin","Match on the FIN bit");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("gt","Match only packets with a greater port number");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("lt", "Match only packets with a lower port number");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("neq",  "Match only packets not on a given port number");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("precedence",  "Match packets with given precedence value");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("range", "Match only packets in the range of port numbers");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("time-range",  "Specify a time-range");

						  globalC["access-list"]["<100-199>"].permit.tcp.any.any.addSC("tos", "Match packets with given TOS value");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("eq","Match only packets on a given port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("gt","Match only packets with a greater port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("host","A single destination host");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("lt","Match only packets with a lower port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("neq",  "Match only packets not on a given port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("range", "Match only packets in the range of port numbers");

				  globalC["access-list"]["<100-199>"].permit.tcp.addSC("host", "A single source host");

					  globalC["access-list"]["<100-199>"].permit.tcp.host.addSC("A.B.C.D","Source address");

						globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("A.B.C.D","Destination address");

						globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("any","Any destination host");					

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("any","Any destination host");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("eq","Match only packets on a given port number");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("gt","Match only packets with a greater port number");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("host","A single destination host");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("lt", "Match only packets with a lower port number");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("neq",  "Match only packets not on a given port number");

					  	globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].addSC("range", "Match only packets in the range of port numbers");

				  	  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host.addSC("A.B.C.D","Destination address");

					  			globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("any","Any destination host");

					  	  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("ack", "Match on the ACK bit");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("eq","Match only packets on a given port number");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("fin","Match on the FIN bit");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("gt","Match only packets with a greater port number");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("lt", "Match only packets with a lower port number");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("neq",  "Match only packets not on a given port number");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("precedence",  "Match packets with given precedence value");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("range", "Match only packets in the range of port numbers");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("time-range",  "Specify a time-range");

						  		globalC["access-list"]["<100-199>"].permit.tcp.host["A.B.C.D"].host["A.B.C.D"].addSC("tos", "Match packets with given TOS value");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("eq","Match only packets on a given port number");

					 	     globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("<0-65535>","Port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("gt","Match only packets with a greater port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("host","A single destination host");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("lt","Match only packets with a lower port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("neq",  "Match only packets not on a given port number");

					  globalC["access-list"]["<100-199>"].permit.tcp.any.addSC("range", "Match only packets in the range of port numbers");

			  globalC["access-list"]["<100-199>"].permit.addSC("udp", "User Datagram Protocol");			

		globalC["access-list"]["<100-199>"].addSC("remark",   "Access list entry comment");

	globalC["access-list"].addSC("<1100-1199>", "Extended 48-bit MAC address access list");

		globalC["access-list"]["<1100-1199>"].addSC("deny", "Specify packets to reject");

		globalC["access-list"]["<1100-1199>"].addSC("permit", "Specify packets to forward");

	globalC["access-list"].addSC("<1300-1999>", "IP standard access list (expanded range)");

		globalC["access-list"]["<1300-1999>"].addSC("deny", "Specify packets to reject");

		globalC["access-list"]["<1300-1999>"].addSC("permit", "Specify packets to forward");

	globalC["access-list"].addSC("<200-299>", "Protocol type-code access list");

		globalC["access-list"]["<200-299>"].addSC("deny", "Specify packets to reject");

		globalC["access-list"]["<200-299>"].addSC("permit", "Specify packets to forward");

	globalC["access-list"].addSC("<2000-2699>", "IP extended access list (expanded range)");

		globalC["access-list"]["<2000-2699>"].addSC("deny", "Specify packets to reject");

		globalC["access-list"]["<2000-2699>"].addSC("dynamic", "Specify a DYNAMIC list of PERMITs or DENYs");

		globalC["access-list"]["<2000-2699>"].addSC("permit", "Specify packets to forward");

		  globalC["access-list"]["<2000-2699>"].permit.addSC("dynamic-extended",  "Extend the dynamic ACL abolute timer");

		  globalC["access-list"]["<2000-2699>"].permit.addSC("rate-limit", "Simple rate-limit specific access list");

globalC.addSC("alias", "Create command alias");

globalC.addSC("arp", "Set a static ARP entry");

globalC.addSC("async-bootp", "Modify system bootp parameters");

globalC.addSC("banner", "Define a login banner");

	globalC.banner.addSC("motd", "Set Message of the Day banner");

		globalC.banner.motd.addSC("LINE", "c banner-text c, where 'c' is a delimiting character");

globalC.addSC("boot", "Modify system boot parameters");

	globalC.boot.addSC("bootstrap", "Bootstrap image file");

	globalC.boot.addSC("host", "Router-specific config file");

	globalC.boot.addSC("network", "Network-wide config file");

	globalC.boot.addSC("system", "System image file");

		globalC.boot.system.addSC("WORD", "TFTP filename or URL");

		globalC.boot.system.addSC("flash", "Boot from flash memory");

		globalC.boot.system.addSC("ftp", "Boot from a server via ftp");

		globalC.boot.system.addSC("tftp", "Boot from a tftp server");

globalC.addSC("bridge", "Bridge Group.");

globalC.addSC("buffers", "Adjust system buffer pool parameters");

globalC.addSC("busy-message", "Display message when connection to host fails");

globalC.addSC("call-history-mib", "Define call history mib parameters");

globalC.addSC("cdp", "Global CDP configuration subcommands");

	globalC.cdp.addSC("run", "");

globalC.addSC("chat-script", "Define a modem chat script");

globalC.addSC("class-map", "Configure QoS Class Map");

	globalC["class-map"].addSC("WORD", "class-map name");

	globalC["class-map"].addSC("match-all", "Logical-AND all matching statements under this classmap");

		globalC["class-map"]["match-all"].addSC("WORD", "class-map name");

	globalC["class-map"].addSC("match-any", "Logical-OR all matching statements under this classmap");

		globalC["class-map"]["match-any"].addSC("WORD", "class-map name");

globalC.addSC("clock", "Configure time-of-day clock");

	globalC.clock.addSC("summer-time", "Configure summer (daylight savings) time");

		globalC.clock["summer-time"].addSC("WORD", "name of time zone in summer");

	globalC.clock.addSC("timezone", "Configure time zone");

		globalC.clock.timezone.addSC("WORD", "name of time zone");

globalC.addSC("cns", "CNS Subsystem");

globalC.addSC("config-register", "Define the configuration register");

	globalC["config-register"].addSC("<0x0-0xFFFF>", "Config register number");

globalC.addSC("connect", "cross-connect two interfaces");

globalC.addSC("controller", "Configure a specific controller");

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

globalC.addSC("default-value", "Default character-bits values");

globalC.addSC("define", "interface range macro definition");

globalC.addSC("dialer", "Dialer commands");

	globalC.dialer.addSC("clid", "Configure dialer CLID command");

		globalC.dialer.clid.addSC("group", "Configure dialer CLID group");

	globalC.dialer.addSC("dnis", "Configure dialer DNIS command");

		globalC.dialer.dnis.addSC("group", "Configure dialer DNIS group");

	globalC.dialer.addSC("watch-list", "Dialer watch list");

		globalC.dialer["watch-list"].addSC("<1-255>", "Dialer watch group number");

globalC.addSC("dialer-list", "Create a dialer list entry");

	globalC["dialer-list"].addSC("<1-128>", "Dialer group number");

		globalC["dialer-list"]["<1-128>"].addSC("protocol", "Permit or Deny based on protocols");

globalC.addSC("dnsix-dmdp", "Provide DMDP service for DNSIX");

globalC.addSC("dnsix-nat", "Provide DNSIX service for audit trails");

globalC.addSC("do", "To run exec commands in config mode");

	globalC["do"].addSC("LINE", "Exec Command");

globalC.addSC("downward-compatible-config", "Generate a configuration compatible with older software");

	globalC["downward-compatible-config"].addSC("<0-999999>.<0-999999>", "Version number");

globalC.addSC("enable", "Modify enable password parameters");

	globalC.enable.addSC("password", "Assign the privileged level password");

		globalC.enable.secret.addSC("LINE", "The UNENCRYPTED (cleartext) 'enable' secret");

		globalC.enable.secret.addSC("level", "Set exec level password");

	globalC.enable.addSC("secret");

	globalC.enable.addSC("use-tacacs", "Use TACACS to check enable passwords");

globalC.addSC("end", "Exit from configure mode");

globalC.addSC("exception", "Exception handling");

globalC.addSC("exit", "Exit from configure mode");

globalC.addSC("file", "Adjust file system parameters");

globalC.addSC("frame-relay", "global frame relay configuration commands");

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

globalC.addSC("hostname", "Set system's network name");

	globalC.hostname.addSC("WORD", "This system's network name");

globalC.addSC("interface", "Select an interface to configure");

	globalC.interface.addSC("Async", "Async interface");

		globalC.interface.Async.addSC("<1-5>", "Async interface number");

	globalC.interface.addSC("Dialer", "Dialer interface");

		globalC.interface.Dialer.addSIC("<0-255>", "Dialer interface number");

			globalC.interface.Dialer["<0-255>"].addSC("<0-4294967295>");

	globalC.interface.addSC("FastEthernet", "FastEthernet IEEE 802.3");

		globalC.interface.FastEthernet.addSIC("<0-0>", "FastEthernet interface number");

			globalC.interface.FastEthernet["<0-0>"].addSC("<0-4294967295>");

	globalC.interface.addSC("Loopback", "Loopback interface");

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

	globalC.interface.addSC("Multilink", "Multilink-group interface");

		globalC.interface.Multilink.addSC("<1-2147483647>", "Multilink interface number");

	globalC.interface.addSC("Null", "Null interface");

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

	globalC.interface.addSC("Serial", "Serial");

		globalC.interface.Serial.addSC("<0-1>", "Serial interface number");

			globalC.interface.Serial["<0-1>"].addSC("<0-4294967295>");

	globalC.interface.addSC("Virtual-Template", "Virtual Template interface");

		globalC.interface["Virtual-Template"].addSC("<1-200>", "Virtual-Template interface number");

globalC.addSC("ip", "Global IP configuration subcommands");

	globalC.ip.addSC("access-list", "Named access-list");

		globalC.ip["access-list"].addSC("extended", "Extended Access List");

		globalC.ip["access-list"].addSC("log-update", "Control access list log updates");

		globalC.ip["access-list"].addSC("logging", "Control access list logging");

		globalC.ip["access-list"].addSC("standard", "Standard Access List");

			globalC.ip["access-list"].standard.addSC("<1-99>","Standard IP access-list number");

			globalC.ip["access-list"].standard.addSC("<1300-9999>","Standard IP access-list number(expanded range)");

			globalC.ip["access-list"].standard.addSC("WORD","Access-list name");

	globalC.ip.addSC("accounting-list", "Select hosts for which IP accounting information is kept");

	globalC.ip.addSC("accounting-threshold", "Sets the maximum number of accounting entries");

	globalC.ip.addSC("accounting-transits", "Sets the maximum number of transit entries");

	globalC.ip.addSC("address-pool", "Specify default IP address pooling mechanism");

	globalC.ip.addSC("alias", "Alias an IP address to a TCP port");

	globalC.ip.addSC("as-path", "BGP autonomous system path filter");

	globalC.ip.addSC("bgp-community", "format for BGP community");

	globalC.ip.addSC("bootp", "Config BOOTP services");

	globalC.ip.addSC("cef", "Cisco Express Forwarding");

	globalC.ip.addSC("classless", "Follow classless routing forwarding rules");

	globalC.ip.addSC("community-list", "Add a community list entry");

	globalC.ip.addSC("default-gateway", "Specify default gateway (if not routing IP)");

		globalC.ip["default-gateway"].addSC("A.B.C.D", "IP address of default gateway");

	globalC.ip.addSC("default-network", "Flags networks as candidates for default routes");

		globalC.ip["default-network"].addSC("A.B.C.D", "IP address of default network");

	globalC.ip.addSC("dhcp", "Configure DHCP server and relay parameters");

		globalC.ip.dhcp.addSC("pool", "Configure DHCP address pools");

		 globalC.ip.dhcp.pool.addSC("WORD",  "Pool name");

	globalC.ip.addSC("dhcp-client", "Configure parameters for DHCP client operation");

	globalC.ip.addSC("dhcp-server", "Specify address of DHCP server to use");

	globalC.ip.addSC("domain", "IP DNS Resolver");

		globalC.ip.domain.addSC("lookup", "Enable IP Domain Name System hostname translation");

		globalC.ip.domain.addSC("name", "Define the default domain name");

	globalC.ip.addSC("domain-list", "Domain name to complete unqualified host names.");

	globalC.ip.addSC("domain-lookup", "Enable IP Domain Name System hostname translation");

	globalC.ip.addSC("domain-name", "Define the default domain name");

	globalC.ip.addSC("dvmrp", "DVMRP global commands");

	globalC.ip.addSC("extcommunity-list", "Add a extended community list entry");

	globalC.ip.addSC("finger", "finger server");

		globalC.ip.finger.addSC("rfc-compliant", "Comply with RFC 1288");

	globalC.ip.addSC("flow-aggregation", "Configure flow aggregation");

	globalC.ip.addSC("flow-cache", "Configure netflow cache parameters");

	globalC.ip.addSC("flow-export", "Specify host/port to send flow statistics");

	globalC.ip.addSC("forward-protocol", "Controls forwarding of physical and directed IP broadcasts");

	globalC.ip.addSC("ftp", "FTP configuration commands");

	globalC.ip.addSC("gratuitous-arps", "Generate gratuitous ARPs for PPP/SLIP peer addresses");

		globalC.ip["gratuitous-arps"].addSC("non-local", "Send only non-local PPP/SLIP gratuitous ARPs (default)");

	globalC.ip.addSC("host", "Add an entry to the ip hostname table");

		globalC.ip.host.addSC("WORD", "Name of host");

	globalC.ip.addSC("host-routing", "Enable host-based routing (proxy ARP and redirect)");

	globalC.ip.addSC("hp-host", "Enable the HP proxy probe service");

		globalC.ip["hp-host"].addSC("WORD", "HP host's name");

	globalC.ip.addSC("http", "HTTP server configuration");

	globalC.ip.addSC("icmp", "ICMP options");

		globalC.ip.icmp.addSC("rate-limit", "rate limit ICMP messages generated");

		globalC.ip.icmp.addSC("redirect", "Redirect type");

	globalC.ip.addSC("igmp", "IGMP global configuration");

		globalC.ip.igmp.addSC("immediate-leave", "Leave groups immediately without sending last member query, use for one host network only");

	globalC.ip.addSC("local", "Specify local options");

		globalC.ip.local.addSC("policy", "Enable policy routing");

		globalC.ip.local.addSC("pool", "IP Local address pool lists");

	globalC.ip.addSC("mrm", "Configure IP Multicast Routing Monitor test parameters");

		globalC.ip.mrm.addSC("accept-manager", "IP MRM manager filter for test sender and test receiver");

		globalC.ip.mrm.addSC("manager", "Configure IP MRM manager parameters");

	globalC.ip.addSC("mroute", "Configure static multicast routes");

		globalC.ip.mroute.addSC("A.B.C.D", "Source address");

	globalC.ip.addSC("msdp", "MSDP global commands");

	globalC.ip.addSC("multicast", "Global IP Multicast Commands");

	globalC.ip.addSC("multicast-routing", "Enable IP multicast forwarding");

	globalC.ip.addSC("name-server", "Specify address of name server to use");

	globalC.ip.addSC("nat", "NAT configuration commands");

		globalC.ip.nat.addSC("inside", "Inside address translation");

		globalC.ip.nat.addSC("outside", "Outside address translation");

		globalC.ip.nat.addSC("pool", "Define pool of addresses");

		globalC.ip.nat.addSC("service", "Special translation for application using non-standard port");

		globalC.ip.nat.addSC("translation", "NAT translation entry configuration");

	globalC.ip.addSC("nbar", "NBAR - Network Based Application Recognition");

	globalC.ip.addSC("ospf", "OSPF");

	globalC.ip.addSC("pgm", "PGM Reliable Transport Protocol");

	globalC.ip.addSC("pim", "PIM global commands");

	globalC.ip.addSC("prefix-list", "Build a prefix list");

	globalC.ip.addSC("radius", "RADIUS configuration commands");

		globalC.ip.radius.addSC("source-interface", "Specify interface for source address in RADIUS packets");

	globalC.ip.addSC("rcmd", "Rcmd commands");

		globalC.ip.rcmd.addSC("domain-lookup", "Enable IP DNS queries for Rcmd");

		globalC.ip.rcmd.addSC("source-interface", "Specify interface for source address in rcmd connections");

	globalC.ip.addSC("reflexive-list", "Reflexive access list");

		globalC.ip["reflexive-list"].addSC("timeout", "Timeout value for reflexive ACL entries");

	globalC.ip.addSC("route", "Establish static routes");

		globalC.ip.route.addSC("A.B.C.D", "Destination prefix");

			globalC.ip.route["A.B.C.D"].addSC("A.B.C.D",  "Destination prefix mask");



				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Forwarding router's address");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].addSC("<1-255>", "Distance metric for this route");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].addSC("name", "Specify name of the next hop");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].name.addSC("WORD", "Name of the next hop");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].addSC("permanent", "permanent route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].permanent.addSC("<1-255>", "Distance metric for this route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].permanent.addSC("name", "Specify name of the next hop");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].addSC("tag", "Set tag for this route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].tag.addSC("<1-4294967295>", "Tag value");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("Async", "Async interface");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("Dialer", "Dialer interface");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("FastEthernet", "FastEthernet IEEE 802.3");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"].FastEthernet.addSC("<0-1>", "FastEthernet interface number");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("Loopback", "Loopback interface");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback.addSC("<0-2147483647>", "Loopback interface number");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback["<0-2147483647>"].addSC("<1-255>", "Distance metric for this route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback["<0-2147483647>"].addSC("A.B.C.D", "Forwarding router's address");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback["<0-2147483647>"].addSC("name", "Specify name of the next hop");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback["<0-2147483647>"].addSC("permanent", "permanent route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Loopback["<0-2147483647>"].addSC("tag", "Set tag for this route");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("Null", "Null interface");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null.addSC("<0-0>", "Null interface number");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null["<0-0>"].addSC("<1-255>", "Distance metric for this route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null["<0-0>"].addSC("A.B.C.D", "Forwarding router's address");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null["<0-0>"].addSC("name", "Specify name of the next hop");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null["<0-0>"].addSC("permanent", "permanent route");

					  globalC.ip.route["A.B.C.D"]["A.B.C.D"].Null["<0-0>"].addSC("tag", "Set tag for this route");

				globalC.ip.route["A.B.C.D"]["A.B.C.D"].addSC("Serial", "Serial");

				   globalC.ip.route["A.B.C.D"]["A.B.C.D"].Serial.addSC("<0-1>", "Serial interface number");



		globalC.ip.route.addSC("profile", "Enable IP routing table profile");





	globalC.ip.addSC("routing", "Enable IP routing");

	globalC.ip.addSC("rsvp", "Configure static RSVP information");

	globalC.ip.addSC("rtcp", "RTCP parameters");

	globalC.ip.addSC("sap", "Global IP Multicast SAP Commands");

	globalC.ip.addSC("security", "Specify system wide security information");

	globalC.ip.addSC("subnet-zero", "Allow 'subnet zero' subnets");

	globalC.ip.addSC("tacacs", "TACACS configuration commands");

		globalC.ip.tacacs.addSC("source-interface", "Specify interface for source address in TACACS packets");

	globalC.ip.addSC("tcp", "Global TCP parameters");

	globalC.ip.addSC("telnet", "Specify telnet options");

		globalC.ip.telnet.addSC("comport", "Specify RFC 2217 options");

		globalC.ip.telnet.addSC("hidden", "Don't display telnet addresses or hostnames");

		globalC.ip.telnet.addSC("quiet", "Don't display non-error telnet messages");

		globalC.ip.telnet.addSC("source-interface", "Specify source interface");

		globalC.ip.telnet.addSC("tos", "Specify type of service");

	globalC.ip.addSC("tftp", "tftp configuration commands");

		globalC.ip.tftp.addSC("boot-interface", "Force interface to use for TFTP booting");

		globalC.ip.tftp.addSC("source-interface", "Specify interface for source address in TFTP connections");

	globalC.ip.addSC("udptn", "UDPTN configuration commands");

		globalC.ip.udptn.addSC("source-interface", "Specify source interface");

	globalC.ip.addSC("vrf", "Configure an IP VPN Routing/Forwarding instance");

		globalC.ip.vrf.addSC("WORD", "VPN Routing/Forwarding instance name");

	globalC.ip.addSC("wccp", "Web-Cache Coordination Protocol Commands");

		globalC.ip.wccp.addSC("<0-99>", "Dynamically defined service identifier number");

		globalC.ip.wccp.addSC("version", "protocol version");

		globalC.ip.wccp.addSC("web-cache", "Standard web caching service");

globalC.addSC("ipv6", "Global IPv6 configuration commands");

globalC.addSC("key", "Key management");

globalC.addSC("line", "Configure a terminal line");

	//globalC.line.addSC("<0-10>", "First Line number");

	//	globalC.line["<0-10>"].addSC("<1-10>", "Last Line number");

	globalC.line.addSC("aux", "Auxiliary line");

		globalC.line.aux.addSC("<0-0>", "First Line number");

	globalC.line.addSC("console", "Primary terminal line");

		globalC.line.console.addSC("<0-0>", "First Line number");

	globalC.line.addSC("tty", "Terminal controller");

		globalC.line.tty.addSC("<1-4>", "First Line number");

	globalC.line.addSC("vty", "Virtual terminal");

		globalC.line.vty.addSC("<0-15>", "First Line number");

globalC.addSC("logging", "Modify message logging facilities");

	globalC.logging.addSC("Hostname or A.B.C.D", "IP address of the logging host");

	globalC.logging.addSC("buffered", "Set buffered logging parameters");

	globalC.logging.addSC("cns-events", "Set CNS Event logging level");

	globalC.logging.addSC("console", "Set console logging level");

	globalC.logging.addSC("count", "Count every log message and timestamp last occurance");

	globalC.logging.addSC("exception", "Limit size of exception flush output");

		globalC.logging.exception.addSC("<4096-2147483647>", "Set size of logging exception flush");

	globalC.logging.addSC("facility", "Facility parameter for syslog messages");

	globalC.logging.addSC("history", "Configure syslog history table");

	globalC.logging.addSC("monitor", "Set terminal line (monitor) logging level");

	globalC.logging.addSC("on", "Enable logging to all supported destinations");

	globalC.logging.addSC("rate-limit", "Set messages per second limit");

	globalC.logging.addSC("source-interface", "Specify interface for source address in logging transactions");

	globalC.logging.addSC("trap", "Set syslog server logging level");

globalC.addSC("login-string", "Define a host-specific login string");

globalC.addSC("map-class", "Configure static map class");

	globalC["map-class"].addSC("atm", "Asynchronous transfer mode");

		globalC["map-class"].atm.addSC("WORD", "Static map class name");

	globalC["map-class"].addSC("dialer", "Dial on Demand");

		globalC["map-class"].dialer.addSC("WORD", "Static map class name");

	globalC["map-class"].addSC("frame-relay", "Frame Relay");

		globalC["map-class"]["frame-relay"].addSC("WORD", "Static map class name");

globalC.addSC("map-list", "Configure static map list");

globalC.addSC("memory-size", "Adjust memory size by percentage");

globalC.addSC("menu", "Define a user-interface menu");

globalC.addSC("netbios", "NETBIOS access control filtering");

	globalC.netbios.addSC("access-list", "Define NETBIOS station access list");

globalC.addSC("modemcap", "Modem Capabilities database");

	globalC.modemcap.addSC("edit", "Edit a modemcap entry");

		globalC.modemcap.edit.addSC("WORD", "Modem type");

	globalC.modemcap.addSC("entry", "Give a full modemcap entry");

		globalC.modemcap.entry.addSC("LINE", "Modemcap entry for this modem");

globalC.addSC("multilink", "PPP multilink global configuration");

	globalC.multilink.addSC("bundle-name", "Select method for naming multilink bundles");

		globalC.multilink["bundle-name"].addSC("authenticated", "Use peer's authenticated name");

		globalC.multilink["bundle-name"].addSC("both", "Use peer's authenticated name and endpoint discriminator");

		globalC.multilink["bundle-name"].addSC("endpoint", "Use peer's endpoint discriminator");

	globalC.multilink.addSC("virtual-template", "virtual-template interface");

		globalC.multilink["virtual-template"].addSC("<1-200>", "virtual template number");

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

	globalC.no.addSC("aaa", "Authentication, Authorization and Accounting.");

	globalC.no.addSC("boot", "Modify system boot parameters");

	globalC.no.addSC("clock", "Configure time-of-day clock");

	globalC.no.addSC("config-register", "Define the configuration register");

	globalC.no.addSC("do", "To run exec commands in config mode");

	globalC.no.addSC("downward-compatible-config", "Generate a configuration compatible with older software");

	globalC.no.addSC("enable", "Modify enable password parameters");

		globalC.no.enable.addSC("password", "Assign the privileged level password");

		globalC.no.enable.addSC("secret", "Assign the privileged level secret");

		globalC.no.enable.addSC("use-tacacs", "Use TACACS to check enable passwords");

	globalC.no.addSC("hostname", "Set system's network name");

	globalC.no.addSC("ip", "Global IP configuration subcommands");

		globalC.no.ip.addSC("access-list", "Named access-list");

		globalC.no.ip.addSC("accounting-list", "Select hosts for which IP accounting information is kept");

		globalC.no.ip.addSC("accounting-threshold", "Sets the maximum number of accounting entries");

		globalC.no.ip.addSC("accounting-transits", "Sets the maximum number of transit entries");

		globalC.no.ip.addSC("address-pool", "Specify default IP address pooling mechanism");

		globalC.no.ip.addSC("as-path", "BGP autonomous system path filter");

		globalC.no.ip.addSC("bgp-community", "format for BGP community");

		globalC.no.ip.addSC("classless", "Follow classless routing forwarding rules");

		globalC.no.ip.addSC("community-list", "Add a community list entry");

		globalC.no.ip.addSC("default-gateway", "Specify default gateway (if not routing IP)");

		globalC.no.ip.addSC("default-network", "Flags networks as candidates for default routes");

		globalC.no.ip.addSC("dhcp", "Configure DHCP server and relay parameters");

		globalC.no.ip.addSC("dhcp-client", "Configure parameters for DHCP client operation");

		globalC.no.ip.addSC("dhcp-server", "Specify address of DHCP server to use");

		globalC.no.ip.addSC("domain", "IP DNS Resolver");

		globalC.no.ip.addSC("domain-list", "Domain name to complete unqualified host names.");

		globalC.no.ip.addSC("domain-lookup", "Enable IP Domain Name System hostname translation");

		globalC.no.ip.addSC("domain-name", "Define the default domain name");

		globalC.no.ip.addSC("dvmrp", "DVMRP global commands");

		globalC.no.ip.addSC("extcommunity-list", "Add a extended community list entry");

		globalC.no.ip.addSC("finger", "finger server");

		globalC.no.ip.addSC("flow-aggregation", "Configure flow aggregation");

		globalC.no.ip.addSC("flow-cache", "Configure netflow cache parameters");

		globalC.no.ip.addSC("flow-export", "Specify host/port to send flow statistics");

		globalC.no.ip.addSC("forward-protocol", "Controls forwarding of physical and directed IP broadcasts");

		globalC.no.ip.addSC("ftp", "FTP configuration commands");

		globalC.no.ip.addSC("gratuitous-arps", "Generate gratuitous ARPs for PPP/SLIP peer addresses");

		globalC.no.ip.addSC("host", "Add an entry to the ip hostname table");

		globalC.no.ip.addSC("host-routing", "Enable host-based routing (proxy ARP and redirect)");

		globalC.no.ip.addSC("http", "HTTP server configuration");

		globalC.no.ip.addSC("icmp", "ICMP options");

		globalC.no.ip.addSC("igmp", "IGMP global configuration");

		globalC.no.ip.addSC("local", "Specify local options");

		globalC.no.ip.addSC("nat", "NAT configuration commands");

		globalC.no.ip.addSC("ospf", "OSPF");

		globalC.no.ip.addSC("reflexive-list", "Reflexive access list");

		globalC.no.ip.addSC("route", "Establish static routes");

		globalC.no.ip.addSC("routing", "Enable IP routing");

		globalC.no.ip.addSC("sap", "Global IP Multicast SAP Commands");

		globalC.no.ip.addSC("subnet-zero", "Allow 'subnet zero' subnets");

		globalC.no.ip.addSC("tacacs", "TACACS configuration commands");

		globalC.no.ip.addSC("tcp", "Global TCP parameters");

		globalC.no.ip.addSC("telnet", "Specify telnet options");

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

globalC.addSC("parser", "Configure parser");

globalC.addSC("partition", "Partition device");

globalC.addSC("policy-map", "Configure QoS Policy Map");

globalC.addSC("priority-list", "Build a priority list");

globalC.addSC("privilege", "Command privilege parameters");

globalC.addSC("process-max-time", "Maximum time for process to run before voluntarily relinquishing processor");

globalC.addSC("prompt", "Set system's prompt");

globalC.addSC("queue-list", "Build a custom queue list");

globalC.addSC("random-detect-group", "Configure random-detect class");

globalC.addSC("regexp", "regexp commands");

globalC.addSC("resume-string", "Define a host-specific resume string");

globalC.addSC("rif", "Source-route RIF cache");

globalC.addSC("rlogin", "Rlogin configuration commands");

globalC.addSC("rmon", "Remote Monitoring");

globalC.addSC("route-map", "Create route-map or enter route-map command mode");

	globalC["route-map"].addSC("WORD", "Route map tag");

		globalC["route-map"].WORD.addSC("<0-65535>", "Sequence to insert to/delete from existing route-map entry");

		globalC["route-map"].WORD.addSC("deny", "Route map denies set operations");

		globalC["route-map"].WORD.addSC("permit", "Route map permits set operations");

globalC.addSC("router", "Enable a routing process");

	globalC.router.addSC("bgp", "Border Gateway Protocol (BGP)");

		globalC.router.bgp.addSC("<1-65535>", "Autonomous system number");

	globalC.router.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");

		globalC.router.eigrp.addSC("<1-65535>", "Autonomous system number");

	globalC.router.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");

		globalC.router.igrp.addSC("<1-65535>", "Autonomous system number");

	globalC.router.addSC("ospf", "Open Shortest Path First (OSPF)");

		globalC.router.ospf.addSC("<1-65535>", "Process ID");

	globalC.router.addSC("rip", "Routing Information Protocol (RIP)");

	globalC.router.addSC("static", "Static routes");

globalC.addSC("rtr", "RTR Base Configuration");

globalC.addSC("scheduler", "Scheduler parameters");

globalC.addSC("service", "Modify use of network based services");

globalC.addSC("snmp", "Modify non engine SNMP parameters");

globalC.addSC("snmp-server", "Modify SNMP engine parameters");

globalC.addSC("sntp", "Configure SNTP");

globalC.addSC("stackmaker", "Specify stack name and add its member");

globalC.addSC("standby", "Global HSRP configuration commands");

globalC.addSC("state-machine", "Define a TCP dispatch state machine");

globalC.addSC("subscriber-policy", "Subscriber policy");

globalC.addSC("tacacs-server", "Modify TACACS query parameters");

globalC.addSC("template", "Select a template to configure");

globalC.addSC("terminal-queue", "Terminal queue commands");

globalC.addSC("tftp-server", "Provide TFTP service for netload requests");

globalC.addSC("time-range", "Define time range entries");

globalC.addSC("trunk", "Configure a trunk group");

globalC.addSC("username", "Establish User Name Authentication");

globalC.addSC("virtual-profile", "");

globalC.addSC("virtual-template", "Virtual Template configuration");

globalC.addSC("vpdn", "Virtual Private Dialup Network");

	globalC.vpdn.addSC("aaa", "VPDN AAA related options");

	globalC.vpdn.addSC("domain-delimiter", "Configure VPDN domain delimiter, prefix/suffix");

	globalC.vpdn.addSC("enable", "Enable VPDN");

	globalC.vpdn.addSC("history", "Enable history logging");

	globalC.vpdn.addSC("incoming", "Configure an incoming tunnel");

	globalC.vpdn.addSC("logging", "Configure logging for VPDN");

	globalC.vpdn.addSC("multihop", "Allow VPDN Multihop");

	globalC.vpdn.addSC("outgoing", "Configure an outgoing tunnel");

		globalC.vpdn.outgoing.addSC("WORD", "Name of GW domain");

	globalC.vpdn.addSC("source-ip", "Set Source IP address");

		globalC.vpdn["source-ip"].addSC("A.B.C.D", "IP source");

globalC.addSC("vpdn-group", "VPDN group configuration");

	globalC["vpdn-group"].addSC("WORD", "VPDN Group name");

globalC.addSC("vpdn-template", "VPDN template configuration");

globalC.addSC("x25", "X.25 Level 3");

globalC.addSC("x29", "X29 commands");

globalC.addSC("xot", "Global XOT commands");