add new repoHEADmaster

73 files changed, 16221 insertions, 0 deletions

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/classMap.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/classMap.swf
new file mode 100644
index 0000000..cbf8f84
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/classMap.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_classMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_classMap.txt
new file mode 100644
index 0000000..b5cd92b
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_classMap.txt
@@ -0,0 +1,75 @@
+

+classMapC.addSC("description", "Class-Map description");

+classMapC.addSC("exit", "Exit from QoS class-map configuration mode");

+classMapC.addSC("match", "classification criteria");

+    classMapC.match.addSC("access-group", "Access group");

+        classMapC.match["access-group"].addSC("<1-2699>", "Access list index");

+        classMapC.match["access-group"].addSC("name", "Named Access List");

+            classMapC.match["access-group"].name.addSC("WORD", "Access List name");

+    classMapC.match.addSC("any", "Any packets");

+    classMapC.match.addSC("class-map", "Class map");

+        classMapC.match["class-map"].addSC("WORD", "Match class-map name");

+    classMapC.match.addSC("cos", "IEEE 802.1Q/ISL class of service/user priority values");

+        classMapC.match.cos.addSC("<0-7>", "Enter up to 4 class-of-service values separated by white-spaces");

+    classMapC.match.addSC("destination-address", "Destination address");

+        classMapC.match["destination-address"].addSC("mac", "MAC address");

+            classMapC.match["destination-address"].mac.addSC("H.H.H", "MAC address");

+    classMapC.match.addSC("input-interface", "Select an input interface to match");

+        classMapC.match["input-interface"].addSC("ATM", "ATM interface");

+            classMapC.match["input-interface"].ATM.addSC("<0-0>", "ATM interface number");

+        classMapC.match["input-interface"].addSC("Async", "Async interface");

+            classMapC.match["input-interface"].Async.addSC("<1-0>", "Async interface number");

+        classMapC.match["input-interface"].addSC("BVI", "Bridge-Group Virtual Interface");

+            classMapC.match["input-interface"].BVI.addSC("<1-255>", "BVI interface number");

+        classMapC.match["input-interface"].addSC("CTunnel", "CTunnel interface");

+            classMapC.match["input-interface"].CTunnel.addSC("<0-2147483647>", "CTunnel interface number");

+        classMapC.match["input-interface"].addSC("Dialer", "Dialer interface");

+            classMapC.match["input-interface"].Dialer.addSC("<0-255>", "Dialer interface number");

+        classMapC.match["input-interface"].addSC("Ethernet", "IEEE 802.3");

+            classMapC.match["input-interface"].Ethernet.addSC("<0-0>", "Ethernet interface number");

+        classMapC.match["input-interface"].addSC("Group-Async", "Async Group interface");

+            classMapC.match["input-interface"]["Group-Async"].addSC("<0-0>", "Group-Async interface number");

+        classMapC.match["input-interface"].addSC("Lex", "Lex interface");

+            classMapC.match["input-interface"].Lex.addSC("<0-2147483647>", "Lex interface number");

+        classMapC.match["input-interface"].addSC("Loopback", "Loopback interface");

+            classMapC.match["input-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");

+        classMapC.match["input-interface"].addSC("Multilink", "Multilink-group interface");

+            classMapC.match["input-interface"].Multilink.addSC("<0-2147483647>", "Multilink interface number");

+        classMapC.match["input-interface"].addSC("Null", "Null interface");

+            classMapC.match["input-interface"].Null.addSC("<0-0>", "Null interface number");

+        classMapC.match["input-interface"].addSC("Tunnel", "Tunnel interface");

+            classMapC.match["input-interface"].Tunnel.addSC("<0-2147483647>", "Tunnel interface number");

+        classMapC.match["input-interface"].addSC("Vif", "PGM Multicast Host interface");

+            classMapC.match["input-interface"].Vif.addSC("<1-1>", "Vif interface number");

+        classMapC.match["input-interface"].addSC("Virtual-Template", "Virtual Template interface");

+            classMapC.match["input-interface"]["Virtual-Template"].addSC("<1-25>", "Virtual-Template interface number");

+        classMapC.match["input-interface"].addSC("Virtual-TokenRing", "Virtual TokenRing");

+            classMapC.match["input-interface"]["Virtual-TokenRing"].addSC("<0-2147483647>", "Virtual-TokenRing interface number");

+    classMapC.match.addSC("ip", "IP specific values");

+        classMapC.match.ip.addSC("dscp", "Match IP DSCP (DiffServ CodePoints)");

+        classMapC.match.ip.addSC("precedence", "Match IP precedence");

+            classMapC.match.ip.precedence.addSC("<0-7>", "Enter up to 4 precedence values separated by white-spaces");

+        classMapC.match.ip.addSC("rtp", "Match RTP port nos");

+            classMapC.match.ip.rtp.addSC("<2000-65535>", "Lower bound of UDP destination port");

+                classMapC.match.ip.rtp["<2000-65535>"].addSC("<0-16383>", "Range of UDP ports");

+    classMapC.match.addSC("mpls", "Multi Protocol Label Switching specific values");

+        classMapC.match.mpls.addSC("experimental", "Match MPLS experimental");

+            classMapC.match.mpls.experimental.addSC("<0-7>", "Enter up to 8 experimental values separated by white-spaces");

+    classMapC.match.addSC("protocol", "Protocol");

+        classMapC.match.protocol.addSC("arp", "IP ARP");

+        classMapC.match.protocol.addSC("bridge", "Bridging");

+        classMapC.match.protocol.addSC("cdp", "Cisco Discovery Protocol");

+        classMapC.match.protocol.addSC("compressedtcp", "Compressed TCP");

+        classMapC.match.protocol.addSC("ip", "IP");

+        classMapC.match.protocol.addSC("ipx", "Novell IPX");

+        classMapC.match.protocol.addSC("llc2", "llc2");

+        classMapC.match.protocol.addSC("pppoe", "PPP over Ethernet");

+        classMapC.match.protocol.addSC("snapshot", "Snapshot routing support");

+        classMapC.match.protocol.addSC("vofr", "voice over Frame Relay packets");

+    classMapC.match.addSC("qos-group", "Qos-group");

+        classMapC.match["qos-group"].addSC("<0-99>", "Qos Group value");

+    classMapC.match.addSC("source-address", "Source address");

+        classMapC.match["source-address"].addSC("mac", "MAC address");

+            classMapC.match["source-address"].mac.addSC("H.H.H", "MAC address");

+classMapC.addSC("no", "Negate or set default values of a command");

+classMapC.addSC("rename", "Rename this class-map");

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_dhcp.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_dhcp.txt
new file mode 100644
index 0000000..75b7f94
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_dhcp.txt
@@ -0,0 +1,55 @@
+

+dhcpC.addSC("bootfile", "Boot file name");

+	dhcpC.bootfile.addSC("WORD", "Boot file name");

+dhcpC.addSC("client-identifier", "Client identifier");

+	dhcpC["client-identifier"].addSC("WORD", "Dotted-hexadecimal string (aabb.ccdd.eeff ...)");

+dhcpC.addSC("client-name", "Client name");

+	dhcpC["client-name"].addSC("WORD", "Client name (domain should not be included)");

+dhcpC.addSC("default-router", "Default routers");

+	dhcpC["default-router"].addSC("Hostname or A.B.C.D", "Router's name or IP address");

+dhcpC.addSC("dns-server", "DNS servers");

+	dhcpC["dns-server"].addSC("Hostname or A.B.C.D", "Server's name or IP address");

+dhcpC.addSC("domain-name", "Domain name");

+	dhcpC["domain-name"].addSC("WORD", "Domain name");

+dhcpC.addSC("exit", "Exit from DHCP pool configuration mode");

+dhcpC.addSC("hardware-address", "Client hardware address");

+	dhcpC["hardware-address"].addSC("WORD", "Dotted-hexadecimal string (aabb.ccdd.eeff ...)");

+dhcpC.addSC("host", "Client IP address and mask");

+	dhcpC.host.addSC("A.B.C.D", "IP address in dotted-decimal notation");

+		dhcpC.host["A.B.C.D"].addSC("/nn or A.B.C.D", "Network mask or prefix length");

+dhcpC.addSC("import", "Programatically importing DHCP option parameters");

+	dhcpC.import.addSC("all", "all DHCP options");

+dhcpC.addSC("lease", "Address lease time");

+	dhcpC.lease.addSC("<0-365>", "Days");

+	dhcpC.lease.addSC("infinite", "Infinite lease");

+dhcpC.addSC("netbios-name-server", "NetBIOS (WINS) name servers");

+	dhcpC["netbios-name-server"].addSC("Hostname or A.B.C.D", "Server's name or IP address");

+dhcpC.addSC("netbios-node-type", "NetBIOS node type");

+	dhcpC["netbios-node-type"].addSC("<0-FF>", "Hexadecimal number");

+	dhcpC["netbios-node-type"].addSC("b-node", "Broadcast node");

+	dhcpC["netbios-node-type"].addSC("h-node", "Hybrid node");

+	dhcpC["netbios-node-type"].addSC("m-node", "Mixed node");

+	dhcpC["netbios-node-type"].addSC("p-node", "Peer-to-peer node");

+dhcpC.addSC("network", "Network number and mask");

+	dhcpC.network.addSC("A.B.C.D", "Network number in dotted-decimal notation");

+		dhcpC.network["A.B.C.D"].addSC("/nn or A.B.C.D", "Network mask or prefix length");

+dhcpC.addSC("next-server", "Next server in boot process");

+	dhcpC["next-server"].addSC("Hostname or A.B.C.D", "Server's name or IP address");

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

+	dhcpC.no.addSC("bootfile", "Boot file name");

+	dhcpC.no.addSC("client-identifier", "Client identifier");

+	dhcpC.no.addSC("client-name", "Client name");

+	dhcpC.no.addSC("default-router", "Default routers");

+	dhcpC.no.addSC("dns-server", "DNS servers");

+	dhcpC.no.addSC("domain-name", "Domain name");

+	dhcpC.no.addSC("exit", "Exit from DHCP pool configuration mode");

+	dhcpC.no.addSC("hardware-address", "Client hardware address");

+	dhcpC.no.addSC("host", "Client IP address and mask");

+	dhcpC.no.addSC("import", "Programatically importing DHCP option parameters");

+	dhcpC.no.addSC("lease", "Address lease time");

+	dhcpC.no.addSC("netbios-name-server", "NetBIOS (WINS) name servers");

+	dhcpC.no.addSC("netbios-node-type", "NetBIOS node type");

+	dhcpC.no.addSC("network", "Network number and mask");

+	dhcpC.no.addSC("next-server", "Next server in boot process");

+dhcpC.addSC("option", "Raw DHCP options");

+	dhcpC.option.addSC("<0-254>", "DHCP option code");

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_enable.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_enable.txt
new file mode 100644
index 0000000..9a4adaf
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_enable.txt
@@ -0,0 +1,766 @@
+	enableC["access-enable"].addSC("host", "Enable a specific host only");


+	enableC["access-enable"].addSC("timeout", "Maximum idle time to expire this entry");


+		enableC["access-enable"].timeout.addSC("<1-9999>", "Access-List Idle timeout");


+enableC.addSC("access-template", "Create a temporary Access-List entry");


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


+		enableC["access-template"]["<100-199>"].addSC("WORD", "Name of Temp. list within the access-list");


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


+		enableC["access-template"]["<2000-2699>"].addSC("WORD", "Name of Temp. list within the access-list");


+	enableC["access-template"].addSC("WORD", "Access-list name");


+		enableC["access-template"].WORD.addSC("WORD", "Name of Temp. list within the access-list");


+enableC.addSC("archive", "manage archive files");


+enableC.addSC("cd", "Change current directory");


+	enableC.cd.addSC("flash:", "Directory name");


+	enableC.cd.addSC("null:", "Directory name");


+	enableC.cd.addSC("nvram:", "Directory name");


+	enableC.cd.addSC("system:", "Directory name");


+	enableC.cd.addSC("xmodem:", "Directory name");


+	enableC.cd.addSC("ymodem:", "Directory name");


+enableC.addSC("clear", "Reset functions");


+


+enableC.addSC("clear", "Clear, use 'clear help' for more info");


+	enableC.clear.addSC("alias", "Clear aliases of commands");


+	enableC.clear.addSC("arp", "Clear ARP table entries");


+	enableC.clear.addSC("banner", "Clear Message Of The Day banner");


+	enableC.clear.addSC("boot", "Clear booting environment variable");


+	enableC.clear.addSC("cam", "Clear CAM table entries");


+	enableC.clear.addSC("cgmp", "Clear CGMP statistics");


+	enableC.clear.addSC("channel", "Clear PagP statistical information");


+	enableC.clear.addSC("config", "Clear configuration and reset system");


+		enableC.clear.config.addSC("all", "Clear all configurations");


+		enableC.clear.config.addSC("pvlan", "Clear Private Vlan Configuration");


+		enableC.clear.config.addSC("snmp", "Clear SNMP");


+		enableC.clear.config.addSC("rmon", "Clear RMON");


+		enableC.clear.config.addSC("<mod>", "Clear configuration of a module");


+	enableC.clear.addSC("counters", "Clear MAC and Port counters");


+	enableC.clear.addSC("dot1x", "Clear Dot1x feature");


+	enableC.clear.addSC("gmrp", "Clear GMRP statistics");


+	enableC.clear.addSC("gvrp", "Clear GVRP statistics");


+	enableC.clear.addSC("ip", "Clear IP, use 'clear ip help' for more info");


+		enableC.clear.ip.addSC("alias", "Clear IP address aliases");


+		enableC.clear.ip.addSC("dns", "Clear IP DNS information");


+		enableC.clear.ip.addSC("permit", "Clear IP permit list");


+		enableC.clear.ip.addSC("route", "Clear IP routing table entries");


+			enableC.clear.ip.route.addSC("all", "Clear all IP routes");


+			enableC.clear.ip.route.addSC("<destination>", "Clear IP route destination");


+	enableC.clear.addSC("kerberos", "Clear Kerberos configuration information");


+	enableC.clear.addSC("key", "Clear config-key string");


+	enableC.clear.addSC("log", "Clear log information");


+	enableC.clear.addSC("logging", "Clear system logging information");


+	enableC.clear.addSC("multicast", "Clear multicast router port");


+	enableC.clear.addSC("netstat", "Clear network statistics");


+	enableC.clear.addSC("ntp", "Clear NTP servers and timezone");


+	enableC.clear.addSC("port", "Clear port features");


+		enableC.clear.port.addSC("host", "Clear port host");


+			enableC.clear.port.host.addSC("all", "Clear port host for all ports");


+			enableC.clear.port.host.addSC("<mod/port>", "Module number and Port number(s)");


+		enableC.clear.port.addSC("security", "Clear secure MAC addresses");


+	enableC.clear.addSC("pvlan", "Clear Private Vlan Mappings");


+		enableC.clear.pvlan.addSC("mapping", "Clear private vlan mappings");


+			enableC.clear.pvlan.mapping.addSC("<primary_vlan>", "Primary Vlan");


+				enableC.clear.pvlan.mapping["<primary_vlan>"].addSC("<isolated_vlan>", "Isolated Vlan");


+					enableC.clear.pvlan.mapping["<primary_vlan>"]["<isolated_vlan>"].addSC("<mod/port>", "Ports");


+				enableC.clear.pvlan.mapping["<primary_vlan>"].addSC("<community_vlan>", "Community Vlan");


+					enableC.clear.pvlan.mapping["<primary_vlan>"]["<community_vlan>"].addSC("<mod/port>", "Ports");


+				enableC.clear.pvlan.mapping["<primary_vlan>"].addSC("<twoway_community_vlan>", "TwoWay Community Vlan");


+					enableC.clear.pvlan.mapping["<primary_vlan>"]["<twoway_community_vlan>"].addSC("<mod/port>", "Ports");


+			enableC.clear.pvlan.mapping.addSC("<mod/port>", "Clear all mappings from port");


+				enableC.clear.pvlan.mapping["<mod/port>"].addSC("<isolated_vlan>", "Isolated Vlan");


+					enableC.clear.pvlan.mapping["<mod/port>"]["<isolated_vlan>"].addSC("<mod/port>", "Ports");


+				enableC.clear.pvlan.mapping["<mod/port>"].addSC("<community_vlan>", "Community Vlan");


+					enableC.clear.pvlan.mapping["<mod/port>"]["<community_vlan>"].addSC("<mod/port>", "Ports");


+				enableC.clear.pvlan.mapping["<mod/port>"].addSC("<twoway_community_vlan>", "TwoWay Community Vlan");


+					enableC.clear.pvlan.mapping["<mod/port>"]["<twoway_community_vlan>"].addSC("<mod/port>", "Ports");


+	enableC.clear.addSC("qos", "Clear QoS features");


+	enableC.clear.addSC("radius", "Clear radius information");


+	enableC.clear.addSC("rcp", "Clear RCP information for other copy");


+	enableC.clear.addSC("snmp", "Clear SNMP trap receiver address");


+	enableC.clear.addSC("spantree", "Clear spantree parameters");


+		enableC.clear.spantree.addSC("portinstancecost", "Clear spantree port instance cost");


+		enableC.clear.spantree.addSC("portinstancepri", "Clear spantree port instance priority");


+		enableC.clear.spantree.addSC("portvlancost", "Clear spantree port vlan cost");


+			enableC.clear.spantree.portvlancost.addSC("<mod/port>", "Module number and Port number(s)");


+				enableC.clear.spantree.portvlancost["<mod/port>"].addSC("<vlans>", "VLAN numbers for PVST+");


+		enableC.clear.spantree.addSC("portvlanpri", "Clear spantree port vlan priority");


+		enableC.clear.spantree.addSC("root", "Restore STP parameters to default values");


+			enableC.clear.spantree.root.addSC("mistp-instance", "Clear root for MISTP instance");


+			enableC.clear.spantree.root.addSC("<vlans>", "VLAN numbers for PVST+");


+		enableC.clear.spantree.addSC("statistics", "Clear spantree statistics information");


+		enableC.clear.spantree.addSC("uplinkfast", "Clear uplinkfast groups");


+	enableC.clear.addSC("tacacs", "Clear TACACS server host/key");


+	enableC.clear.addSC("timezone", "Clear timezone");


+	enableC.clear.addSC("top", "Clear TopN report");


+	enableC.clear.addSC("trunk", "Clear trunk ports");


+		enableC.clear.trunk.addSC("<mod/port>", "Module number and Port number(s)");


+			enableC.clear.trunk["<mod/port>"].addSC("<vlan>", "VLAN number");


+	enableC.clear.addSC("vlan", "Clear VLAN information");


+		enableC.clear.vlan.addSC("mapping", "Clear the 802.1Q to ISL Vlan Mapping");


+		enableC.clear.vlan.addSC("<vlans>", "Vlan Number(s)");


+	enableC.clear.addSC("vmps", "Clear VMPS information");


+	enableC.clear.addSC("vtp", "Clear VTP statistics");


+		enableC.clear.vtp.addSC("pruneeligible", "Clear VTP pruning eligibility");


+		enableC.clear.vtp.addSC("statistics", "Clear VTP pruning statistics");


+enableC.addSC("configure", "Configure system from network");


+	enableC.configure.addSC("<host>", "IP address or hostname");


+		enableC.configure["<host>"].addSC("<file>", "File name");


+			enableC.configure["<host>"]["<file>"].addSC("rcp", "Download configuration by RCP method");


+	enableC.configure.addSC("network", "Get host/file name interactively");


+enableC.addSC("copy", "Copy files between TFTP/RCP/module/flash devices");


+	enableC.copy.addSC("config", "Copy configuration to a device");


+		enableC.copy.config.addSC("flash", "Copy from config to flash");


+		enableC.copy.config.addSC("rcp", "Copy from config to RCP server");


+		enableC.copy.config.addSC("tftp", "Copy from config to TFTP server");


+		enableC.copy.config.addSC("<file-id>", "File name");


+	enableC.copy.addSC("flash", "Copy from flash");


+		enableC.copy.flash.addSC("config", "Copy from flash to configuration");


+		enableC.copy.flash.addSC("rcp", "Copy from flash to RCP server");


+		enableC.copy.flash.addSC("tftp", "Copy from flash to TFTP server");


+		enableC.copy.flash.addSC("<file-id>", "File name");


+	enableC.copy.addSC("rcp", "Copy from RCP server");


+	enableC.copy.addSC("tftp", "Copy from TFTP server");


+		enableC.copy.tftp.addSC("config", "Copy from TFTP server to configuration");


+		enableC.copy.tftp.addSC("flash", "Copy from TFTP server to flash");


+		enableC.copy.tftp.addSC("<file-id>", "File name");


+	enableC.copy.addSC("<file-id>", "File name");


+		enableC.copy["<file-id>"].addSC("config", "Copy from file to configuration");


+		enableC.copy["<file-id>"].addSC("flash", "Copy from file to flash");


+		enableC.copy["<file-id>"].addSC("rcp", "Copy from file to RCP server");


+		enableC.copy["<file-id>"].addSC("tftp", "Copy from file to TFTP server");


+


+enableC.addSC("debug", "Debugging functions (see also 'undebug')");


+	enableC.debug.addSC("access-expression", "Boolean access expression");


+		enableC.debug["access-expression"].addSC("<0-15>", "Debugging level (0=No Debugging)");


+	enableC.debug.addSC("acltcam", "Debug QoS/ACL TCAM Manager");


+		enableC.debug.acltcam.addSC("verbose", "Verbose Debug Output");


+	enableC.debug.addSC("adjacency", "adjacency");


+		enableC.debug.adjacency.addSC("ipc", "IPC");


+	enableC.debug.addSC("all", "Enable all debugging");


+	enableC.debug.addSC("arp", "IP ARP and HP Probe transactions");


+	enableC.debug.addSC("cdp", "CDP information");


+		enableC.debug.cdp.addSC("adjacency", "CDP neighbor info");


+		enableC.debug.cdp.addSC("events", "CDP events");


+		enableC.debug.cdp.addSC("ip", "CDP ip info");


+		enableC.debug.cdp.addSC("packets", "CDP packet-related information");


+	enableC.debug.addSC("cluster", "Cluster information");


+	enableC.debug.addSC("condition", "Condition");


+	enableC.debug.addSC("cpu-interface", "CPU interface driver debug flag");


+	enableC.debug.addSC("csuf", "STP CSUF");


+	enableC.debug.addSC("custom-queue", "Custom output queueing");


+	enableC.debug.addSC("dhcp", "DHCP client activity");


+		enableC.debug.dhcp.addSC("detail", "DHCP packet content");


+	enableC.debug.addSC("dnsix", "Dnsix information");


+		enableC.debug.dnsix.addSC("dmdp", "Debug DNSIX/DMDP protocol");


+		enableC.debug.dnsix.addSC("dnssec", "Debug DNSSEC protocol");


+		enableC.debug.dnsix.addSC("nat", "Debug DNSIX/NAT protocol");


+	enableC.debug.addSC("domain", "Domain Name System");


+		enableC.debug.domain.addSC("replies", "DNS replies only");


+			enableC.debug.domain.replies.addSC("detail", "Detailed information");


+	enableC.debug.addSC("dtp", "DTP debug information");


+	enableC.debug.addSC("eigrp", "EIGRP Protocol information");


+	enableC.debug.addSC("etherchannel", "EtherChannel/PAgP Shim debugging");


+		enableC.debug.etherchannel.addSC("all", "All debugging");


+		enableC.debug.etherchannel.addSC("detail", "Step below all");


+		enableC.debug.etherchannel.addSC("error", "Displaying error messages");


+		enableC.debug.etherchannel.addSC("event", "Major events");


+		enableC.debug.etherchannel.addSC("idb", "Agport idb related events");


+		enableC.debug.etherchannel.addSC("linecard", "SCP messages to linecard");


+	enableC.debug.addSC("ethernet-controller", "Ethernet controller driver debug flags");


+		enableC.debug["ethernet-controller"].addSC("ram-access", "Ethernet Controller RAM Access");


+	enableC.debug.addSC("ethernet-interface", "Ethernet network interface events");


+	enableC.debug.addSC("fallback-bridging", "Debug Fallback Bridging Manager");


+	enableC.debug.addSC("gigastack", "Debug Gigastack");


+	enableC.debug.addSC("interface", "interface");


+	enableC.debug.addSC("ip", "IP information");


+		enableC.debug.ip.addSC("cache", "IP cache operations");


+			enableC.debug.ip.cache.addSC("<1-99>", "Access list");


+			enableC.debug.ip.cache.addSC("<1300-1999>", "Access list (expanded range)");


+		enableC.debug.ip.addSC("cef", "IP CEF operations");


+		enableC.debug.ip.addSC("cgmp", "CGMP protocol activity");


+		enableC.debug.ip.addSC("dhcp", "Dynamic Host Configuration Protocol");


+			enableC.debug.ip.dhcp.addSC("server", "DHCP server activity");


+				enableC.debug.ip.dhcp.server.addSC("events", "Report address assignments, lease expirations, etc.");


+				enableC.debug.ip.dhcp.server.addSC("linkage", "Show database linkage");


+				enableC.debug.ip.dhcp.server.addSC("packet", "Decode message receptions and transmissions");


+		enableC.debug.ip.addSC("dvmrp", "DVMRP protocol activity");


+		enableC.debug.ip.addSC("eigrp", "IP-EIGRP information");


+		enableC.debug.ip.addSC("error", "IP error debugging");


+		enableC.debug.ip.addSC("flow", "IP Flow switching operations");


+		enableC.debug.ip.addSC("ftp", "FTP dialogue");


+		enableC.debug.ip.addSC("html", "HTML connections");


+			enableC.debug.ip.html.addSC("forms", "HTML forms");


+			enableC.debug.ip.html.addSC("pages", "HTML pages");


+			enableC.debug.ip.html.addSC("ssi", "HTML server side includes");


+			enableC.debug.ip.html.addSC("tokens", "HTML tokens");


+		enableC.debug.ip.addSC("http", "HTTP connections");


+			enableC.debug.ip.http.addSC("authentication", "HTTP Authentication");


+			enableC.debug.ip.http.addSC("ezsetup", "HTTP EZSetup");


+			enableC.debug.ip.http.addSC("ssi", "HTTP Server Side Includes");


+			enableC.debug.ip.http.addSC("tokens", "HTTP tokens");


+			enableC.debug.ip.http.addSC("transactions", "HTTP transactions");


+			enableC.debug.ip.http.addSC("url", "HTTP URL");


+		enableC.debug.ip.addSC("icmp", "ICMP transactions");


+		enableC.debug.ip.addSC("igmp", "IGMP protocol activity");


+		enableC.debug.ip.addSC("igrp", "IGRP information");


+		enableC.debug.ip.addSC("igsn", "IGMP snooping activity");


+			enableC.debug.ip.igsn.addSC("all", "all");


+			enableC.debug.ip.igsn.addSC("group", "igmp snooping group activity");


+			enableC.debug.ip.igsn.addSC("management", "igmp snooping management activity");


+			enableC.debug.ip.igsn.addSC("router", "igmp snooping router activity");


+			enableC.debug.ip.igsn.addSC("timer", "igmp snooping timer events");


+		enableC.debug.ip.addSC("interface", "IP interface configuration changes");


+			enableC.debug.ip.interface.addSC("route-cache", "Route-cache changes");


+		enableC.debug.ip.addSC("mcache", "IP multicast cache operations");


+			enableC.debug.ip.mcache.addSC("Hostname or A.B.C.D", "IP group address");


+		enableC.debug.ip.addSC("mpacket", "IP multicast packet debugging");


+		enableC.debug.ip.addSC("mrm", "IP Multicast Routing Monitor");


+			enableC.debug.ip.mrm.addSC("events", "MRM events");


+			enableC.debug.ip.mrm.addSC("packets", "MRM test packets");


+		enableC.debug.ip.addSC("mrouting", "IP multicast routing table activity");


+			enableC.debug.ip.mrouting.addSC("Hostname or A.B.C.D", "IP group address");


+		enableC.debug.ip.addSC("msdp", "Multicast Source Discovery Protocol (MSDP)");


+			enableC.debug.ip.msdp.addSC("Hostname or A.B.C.D", "Peer name or address");


+			enableC.debug.ip.msdp.addSC("detail", "Print more debugging detail");


+			enableC.debug.ip.msdp.addSC("resets", "Print peer reset reasons");


+			enableC.debug.ip.msdp.addSC("routes", "MSDP route entries");


+		enableC.debug.ip.addSC("nat", "NAT events");


+			enableC.debug.ip.nat.addSC("<1-99>", "Access list");


+			enableC.debug.ip.nat.addSC("detailed", "NAT detailed events");


+			enableC.debug.ip.nat.addSC("port", "NAT PORT events");


+		enableC.debug.ip.addSC("ospf", "OSPF information");


+		enableC.debug.ip.addSC("packet", "General IP debugging and IPSO security transactions");


+			enableC.debug.ip.packet.addSC("<1-199>", "Access list");


+			enableC.debug.ip.packet.addSC("<1300-2699>", "Access list (expanded range)");


+			enableC.debug.ip.packet.addSC("detail", "Print more debugging detail");


+				enableC.debug.ip.packet.detail.addSC("<1-199>", "Access list");


+				enableC.debug.ip.packet.detail.addSC("<1300-2699>", "Access list (expanded range)");


+		enableC.debug.ip.addSC("peer", "IP peer address activity");


+		enableC.debug.ip.addSC("pim", "PIM protocol activity");


+			enableC.debug.ip.pim.addSC("Hostname or A.B.C.D", "IP group address");


+			enableC.debug.ip.pim.addSC("atm", "PIM ATM signalling activity");


+			enableC.debug.ip.pim.addSC("auto-rp", "Auto-RP");


+			enableC.debug.ip.pim.addSC("bsr", "PIM Candidate-RP/BSR activity");


+		enableC.debug.ip.addSC("rgmp", "RGMP protocol activity");


+			enableC.debug.ip.rgmp.addSC("Hostname or A.B.C.D", "IP group address");


+		enableC.debug.ip.addSC("rip", "RIP protocol transactions");


+			enableC.debug.ip.rip.addSC("database", "RIP database events");


+			enableC.debug.ip.rip.addSC("events", "RIP protocol events");


+			enableC.debug.ip.rip.addSC("trigger", "RIP trigger extension");


+		enableC.debug.ip.addSC("routing", "Routing table events");


+			enableC.debug.ip.routing.addSC("<1-199>", "Access list");


+			enableC.debug.ip.routing.addSC("<1300-2699>", "Access list (expanded range)");


+		enableC.debug.ip.addSC("sd", "Session Directory (SD)");


+		enableC.debug.ip.addSC("security", "IP security options");


+		enableC.debug.ip.addSC("socket", "Socket event");


+		enableC.debug.ip.addSC("tcp", "TCP information");


+	enableC.debug.addSC("l3multicast", "Debug L3 Multicast Manager");


+	enableC.debug.addSC("l3tcam", "Debug L3 TCAM Mgr");


+	enableC.debug.addSC("l3unicast", "Debug L3 Unicast Manager");


+	enableC.debug.addSC("list", "Set interface or/and access list for the next debug command");


+		enableC.debug.list.addSC("<0-2699>", "access list");


+		enableC.debug.list.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.debug.list.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.debug.list.addSC("Null", "Null interface");


+			enableC.debug.list.Null.addSC("<0-0>", "Null interface number");


+				enableC.debug.list.Null["<0-0>"].addSC("<0-2699>", "access list");


+		enableC.debug.list.addSC("Vlan", "Catalyst Vlans");


+			enableC.debug.list.Vlan.addSC("<1-1001>", "Vlan interface number");


+				enableC.debug.list.Vlan["<1-1001>"].addSC("<0-2699>", "access list");


+	enableC.debug.addSC("mac-manager", "Debug Platform Dependent Mac Manager");


+	enableC.debug.addSC("matm", "Debug Platform Independent Mac Manager");


+	enableC.debug.addSC("mergeapi", "Debug ACLMERGE");


+		enableC.debug.mergeapi.addSC("all", "mergeapi all");


+		enableC.debug.mergeapi.addSC("normal", "mergeapi normal");


+		enableC.debug.mergeapi.addSC("profile", "mergeapi profile");


+		enableC.debug.mergeapi.addSC("verbose", "mergeapi verbose");


+	enableC.debug.addSC("met", "Debug Multicast Expansion Table Manager");


+	enableC.debug.addSC("modem", "Modem control/process activation");


+	enableC.debug.addSC("monitor", "SPAN debug information");


+	enableC.debug.addSC("mvrdbg", "MVR debug all");


+	enableC.debug.addSC("ntp", "NTP information");


+	enableC.debug.addSC("nvram", "Debug NVRAM behavior");


+	enableC.debug.addSC("packet", "Log unknown packets");


+	enableC.debug.addSC("pagp", "Port Aggregation Protocol");


+	enableC.debug.addSC("pm", "Port Manager debugging");


+	enableC.debug.addSC("priority", "Priority output queueing");


+	enableC.debug.addSC("qm", "Debug QoS Manager");


+	enableC.debug.addSC("rtr", "RTR Monitor Information");


+	enableC.debug.addSC("smf", "Software MAC filter");


+		enableC.debug.smf.addSC("updates", "address insertions and deletions");


+	enableC.debug.addSC("snmp", "SNMP information");


+		enableC.debug.snmp.addSC("headers", "SNMP packet headers");


+		enableC.debug.snmp.addSC("packets", "SNMP packets");


+		enableC.debug.snmp.addSC("timers", "SNMP timer activity");


+	enableC.debug.addSC("span-session", "Debug Switch Port Analyzer (SPAN)");


+	enableC.debug.addSC("spanning-tree", "Spanning tree debugging");


+		enableC.debug["spanning-tree"].addSC("all", "All Spanning Tree debugging messages");


+	enableC.debug.addSC("standby", "Hot standby protocol");


+	enableC.debug.addSC("sw-vlan", "vlan manager");


+	enableC.debug.addSC("tacacs", "TACACS authentication and authorization");


+		enableC.debug.tacacs.addSC("events", "TACACS+ protocol events");


+	enableC.debug.addSC("tbridge", "Transparent Bridging");


+		enableC.debug.tbridge.addSC("autonomous", "autonomous bridging statistics");


+		enableC.debug.tbridge.addSC("flow-id", "bridged fair-queue packets");


+	enableC.debug.addSC("telnet", "Incoming telnet connections");


+	enableC.debug.addSC("template", "Template activity");


+	enableC.debug.addSC("tftp", "TFTP debugging");


+		enableC.debug.tftp.addSC("events", "TFTP events");


+		enableC.debug.tftp.addSC("packets", "TFTP packets");


+	enableC.debug.addSC("tunnel", "Generic Tunnel Interface");


+	enableC.debug.addSC("udld", "UDLD protocol");


+		enableC.debug.udld.addSC("events", "UDLD events");


+		enableC.debug.udld.addSC("packets", "UDLD packets");


+		enableC.debug.udld.addSC("registries", "UDLD registry events");


+


+enableC.addSC("delete", "Delete a file on flash device");


+enableC.addSC("dir", "Show list of files on flash device");


+enableC.addSC("disable", "Disable privileged mode");


+enableC.addSC("disconnect", "Disconnect user session");


+enableC.addSC("enable", "Enable privileged mode");


+enableC.addSC("erase", "Erase a filesystem");


+	enableC.erase.addSC("flash:", "Filesystem to be erased");


+	enableC.erase.addSC("nvram:", "Filesystem to be erased");


+	enableC.erase.addSC("startup-config", "Erase contents of configuration memory");


+enableC.addSC("exit", "Exit from the EXEC");


+enableC.addSC("format", "Format a filesystem");


+	enableC.format.addSC("flash:", "Filesystem to be formatted");


+	enableC.format.addSC("zflash:", "Filesystem to be formatted");


+enableC.addSC("fsck", "Fsck a filesystem");


+	enableC.fsck.addSC("/nocrc", "Skip CRC checks during fsck");


+	enableC.fsck.addSC("/test", "Test device during fsck");


+	enableC.fsck.addSC("flash:", "Filesystem to be fsck'ed");


+	enableC.fsck.addSC("zflash:", "Filesystem to be fsck'ed");


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


+enableC.addSC("lock", "Lock the terminal");


+enableC.addSC("login", "Log in as a particular user");


+enableC.addSC("logout", "Exit from the EXEC");


+enableC.addSC("mkdir", "Create new directory");


+


+enableC.addSC("more", "Display the contents of a file");


+enableC.addSC("mrinfo", "Request neighbor and version information from a multicast router");


+	enableC.mrinfo.addSC("Hostname or A.B.C.D", "Router to request info from");


+		enableC.mrinfo["Hostname or A.B.C.D"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		enableC.mrinfo["Hostname or A.B.C.D"].addSC("Hostname or A.B.C.D", "Source address or interface for request");


+		enableC.mrinfo["Hostname or A.B.C.D"].addSC("Null", "Null interface");


+		enableC.mrinfo["Hostname or A.B.C.D"].addSC("Vlan", "Catalyst Vlans");


+enableC.addSC("mrm", "IP Multicast Routing Monitor Test");


+enableC.addSC("mstat", "Show statistics after multiple multicast traceroutes");


+enableC.addSC("mtrace", "Trace reverse multicast path from destination to source");


+enableC.addSC("name-connection", "Name an existing network connection");


+enableC.addSC("no", "Disable debugging functions");


+


+


+enableC.addSC("ping", "Send echo packets to hosts");


+	enableC.ping.addSC("-s", "Ping parameter");


+		enableC.ping["-s"].addSC("<host>", "IP address or hostname");


+			enableC.ping["-s"]["<host>"].addSC("<packet_size>", "Size of the packet (56..1472 bytes)");


+				enableC.ping["-s"]["<host>"]["<packet_size>"].addSC("<packet_count>", "Number of packets");


+	enableC.ping.addSC("<host>", "IP address or hostname");


+


+enableC.addSC("pwd", "Display current working directory");


+enableC.addSC("rcommand", "Run command on remote switch");


+


+enableC.addSC("reload", "Halt and perform a cold restart");


+	enableC.reload.addSC("LINE", "Reason for reload");


+	enableC.reload.addSC("at", "Reload at a specific time/date");


+		enableC.reload.at.addSC("hh:mm", "Time to reload (hh:mm)");


+	enableC.reload.addSC("cancel", "Cancel pending reload");


+	enableC.reload.addSC("in", "Reload after a time interval");


+enableC.addSC("rename", "Rename a file");


+	enableC.rename.addSC("flash:", "Source file path");


+		enableC.rename["flash:"].addSC("flash:", "Destination file path");


+		enableC.rename["flash:"].addSC("zflash:", "Destination file path");


+	enableC.rename.addSC("zflash:", "Source file path");


+		enableC.rename["zflash:"].addSC("flash:", "Destination file path");


+		enableC.rename["zflash:"].addSC("zflash:", "Destination file path");


+enableC.addSC("resume", "Resume an active network connection");


+


+enableC.addSC("rmdir", "Remove existing directory");


+	enableC.rmdir.addSC("flash:", "Directory name");


+	enableC.rmdir.addSC("zflash:", "Directory name");


+enableC.addSC("rsh", "Execute a remote command");


+	enableC.rsh.addSC("WORD", "IP address or hostname of rsh server");


+		enableC.rsh.WORD.addSC("/user", "Specify remote username");


+		enableC.rsh.WORD.addSC("LINE", "Command to be executed remotely");


+enableC.addSC("send", "Send a message to other tty lines");


+	enableC.send.addSC("*", "All tty lines");


+	enableC.send.addSC("<0-16>", "Send a message to a specific line");


+	enableC.send.addSC("console", "Primary terminal line");


+		enableC.send.console.addSC("<0-0>", "Send a message to a specific line");


+	enableC.send.addSC("vty", "Virtual terminal");


+		enableC.send.vty.addSC("<0-15>", "Send a message to a specific line");


+enableC.addSC("setup", "Run the SETUP command facility");


+enableC.addSC("show", "Show running system information");


+	enableC.show.addSC("access-expression", "List access expression");


+	enableC.show.addSC("access-lists", "List access lists");


+		enableC.show["access-lists"].addSC("<1-2699>", "ACL number");


+		enableC.show["access-lists"].addSC("WORD", "ACL name");


+		enableC.show["access-lists"].addSC("hardware", "Show access-list hardware info");


+			enableC.show["access-lists"].hardware.addSC("counters", "ACL hardware counters");


+	enableC.show.addSC("accounting", "Accounting data for active sessions");


+	enableC.show.addSC("adjacency", "Adjacent nodes");


+	enableC.show.addSC("aliases", "Display alias commands");


+	enableC.show.addSC("arp", "ARP table");


+	enableC.show.addSC("boot", "show boot attributes");


+	enableC.show.addSC("bridge", "Bridge Forwarding/Filtering Database [verbose]");


+		enableC.show.bridge.addSC("<1-255>", "Bridge Group Number");


+		enableC.show.bridge.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.bridge.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.bridge.addSC("H.H.H", "Ethernet address");


+			enableC.show.bridge["H.H.H"].addSC("H.H.H", "Ethernet address mask");


+		enableC.show.bridge.addSC("Null", "Null interface");


+			enableC.show.bridge.Null.addSC("<0-0>", "Null interface number");


+		enableC.show.bridge.addSC("Vlan", "Catalyst Vlans");


+			enableC.show.bridge.Vlan.addSC("<1-1001>", "Vlan interface number");


+		enableC.show.bridge.addSC("circuit-group", "Circuit Group");


+			enableC.show.bridge["circuit-group"].addSC("<1-9>", "Circuit Group number");


+				enableC.show.bridge["circuit-group"]["<1-9>"].addSC("H.H.H", "Src mac address");


+					enableC.show.bridge["circuit-group"]["<1-9>"]["H.H.H"].addSC("H.H.H", "Dst mac address");


+		enableC.show.bridge.addSC("group", "Bridge Group [verbose]");


+		enableC.show.bridge.addSC("verbose", "Display the extended Bridge Table");


+	enableC.show.addSC("buffers", "Buffer pool statistics");


+		enableC.show.buffers.addSC("address", "Buffer at a given address");


+	enableC.show.addSC("cdp", "CDP information");


+		enableC.show.cdp.addSC("entry", "Information for specific neighbor entry");


+			enableC.show.cdp.entry.addSC("*", "all CDP neighbor entries");


+	enableC.show.addSC("cef", "Cisco Express Forwarding");


+		enableC.show.cef.addSC("drop", "Classify packets dropped");


+		enableC.show.cef.addSC("interface", "CEF interface status and configuration");


+			enableC.show.cef.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+	enableC.show.addSC("class-map", "Show QoS Class Map");


+		enableC.show["class-map"].addSC("WORD", "class-map name");


+	enableC.show.addSC("clock", "Display the system clock");


+		enableC.show.clock.addSC("detail", "Display detailed information");


+	enableC.show.addSC("cluster", "Cluster information");


+		enableC.show.cluster.addSC("candidates", "Lists cluster candidates information");


+			enableC.show.cluster.candidates.addSC("detail", "Detail inforamtion of all candidates");


+	enableC.show.addSC("configuration", "Contents of Non-Volatile memory");


+	enableC.show.addSC("controllers", "Interface controller status");


+		enableC.show.controllers.addSC("cpu-interface", "Display CPU-Interface Status");


+		enableC.show.controllers.addSC("ethernet-controller", "Show Ethernet Controller info");


+	enableC.show.addSC("debugging", "State of each debugging option");


+		enableC.show.debugging.addSC("condition", "Condition");


+			enableC.show.debugging.condition.addSC("<1-1000>", "Condition identifier");


+			enableC.show.debugging.condition.addSC("all", "All conditions");


+	enableC.show.addSC("dhcp", "Dynamic Host Configuration Protocol status");


+		enableC.show.dhcp.addSC("lease", "Show DHCP Addresses leased from a server");


+		enableC.show.dhcp.addSC("server", "Show DHCP Servers we know about");


+	enableC.show.addSC("dnsix", "Shows Dnsix/DMDP information");


+	enableC.show.addSC("dtp", "DTP information");


+		enableC.show.dtp.addSC("interface", "DTP interface status");


+	enableC.show.addSC("env", "Environmental facilities");


+		enableC.show.env.addSC("all", "Show all environment status");


+		enableC.show.env.addSC("fan", "Show fan status");


+		enableC.show.env.addSC("temperature", "Show temperature status");


+	enableC.show.addSC("errdisable", "Error disable");


+		enableC.show.errdisable.addSC("detect", "Error disable detection");


+		enableC.show.errdisable.addSC("flap-values", "Flap values for error disable detection");


+		enableC.show.errdisable.addSC("recovery", "Error disable recovery");


+	enableC.show.addSC("etherchannel", "EtherChannel information");


+		enableC.show.etherchannel.addSC("<1-64>", "Channel group number");


+	enableC.show.addSC("exception", "exception informations");


+	enableC.show.addSC("file", "Show filesystem information");


+		enableC.show.file.addSC("descriptors", "List open file descriptors");


+		enableC.show.file.addSC("information", "List file information");


+			enableC.show.file.information.addSC("flash:", "File path");


+			enableC.show.file.information.addSC("ftp:", "File path");


+			enableC.show.file.information.addSC("null:", "File path");


+			enableC.show.file.information.addSC("nvram:", "File path");


+			enableC.show.file.information.addSC("rcp:", "File path");


+			enableC.show.file.information.addSC("system:", "File path");


+			enableC.show.file.information.addSC("tftp:", "File path");


+			enableC.show.file.information.addSC("xmodem:", "File path");


+			enableC.show.file.information.addSC("ymodem:", "File path");


+			enableC.show.file.information.addSC("zflash:", "File path");


+		enableC.show.file.addSC("systems", "List filesytems");


+	enableC.show.addSC("flash:", "display information about flash: file system");


+	enableC.show.addSC("fm", "Feature Manager Information");


+	enableC.show.addSC("forward", "Show forwarding info");


+		enableC.show.forward.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.forward.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+	enableC.show.addSC("history", "Display the session command history");


+	enableC.show.addSC("hosts", "IP domain-name, lookup style, nameservers, and host table");


+		enableC.show.hosts.addSC("WORD", "Hostname for specific information");


+	enableC.show.addSC("html", "HTML helper commands");


+		enableC.show.html.addSC("module", "Module information");


+			enableC.show.html.module.addSC("command", "Execute command over modules");


+				enableC.show.html.module.command.addSC("LINE", "The command to execute over modules");


+			enableC.show.html.module.addSC("count", "Show module count");


+	enableC.show.addSC("interfaces", "Interface status and configuration");


+		enableC.show.interfaces.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.interfaces.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.interfaces.addSC("Null", "Null interface");


+			enableC.show.interfaces.Null.addSC("<0-0>", "Null interface number");


+		enableC.show.interfaces.addSC("Vlan", "Catalyst Vlans");


+			enableC.show.interfaces.Vlan.addSC("<1-1001>", "Vlan interface number");


+	enableC.show.addSC("ip", "IP information");


+		enableC.show.ip.addSC("access-lists", "List IP access lists");


+			enableC.show.ip["access-lists"].addSC("<1-199>", "Access list number");


+			enableC.show.ip["access-lists"].addSC("<1300-2699>", "Access list number (expanded range)");


+			enableC.show.ip["access-lists"].addSC("WORD", "Access list name");


+		enableC.show.ip.addSC("accounting", "The active IP accounting database");


+		enableC.show.ip.addSC("aliases", "IP alias table");


+		enableC.show.ip.addSC("arp", "IP ARP table");


+			enableC.show.ip.arp.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show.ip.arp.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.ip.addSC("cache", "IP fast-switching route cache");


+			enableC.show.ip.cache.addSC("A.B.C.D", "prefix of entries to show");


+				enableC.show.ip.cache["A.B.C.D"].addSC("A.B.C.D", "prefix mask");


+		enableC.show.ip.addSC("cef", "Cisco Express Forwarding");


+			enableC.show.ip.cef.addSC("A.B.C.D", "prefix of entries to show");


+				enableC.show.ip.cef["A.B.C.D"].addSC("A.B.C.D", "prefix mask");


+					enableC.show.ip.cef["A.B.C.D"]["A.B.C.D"].addSC("longer-prefixes", "Show all more specific prefixes");


+			enableC.show.ip.cef.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show.ip.cef.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.ip.addSC("dvmrp", "DVMRP information");


+			enableC.show.ip.dvmrp.addSC("route", "DVMRP routing information");


+				enableC.show.ip.dvmrp.route.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					enableC.show.ip.dvmrp.route.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.ip.addSC("eigrp", "IP-EIGRP show commands");


+			enableC.show.ip.eigrp.addSC("interfaces", "IP-EIGRP interfaces");


+				enableC.show.ip.eigrp.interfaces.addSC("<1-65535>", "AS Number");


+				enableC.show.ip.eigrp.interfaces.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					enableC.show.ip.eigrp.interfaces.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+				enableC.show.ip.eigrp.interfaces.addSC("Null", "Null interface");


+					enableC.show.ip.eigrp.interfaces.Null.addSC("<0-0>", "Null interface number");


+		enableC.show.ip.addSC("flow", "NetFlow switching");


+			enableC.show.ip.flow.addSC("acceleration", "Display export statistics");


+			enableC.show.ip.flow.addSC("export", "Display export statistics");


+		enableC.show.ip.addSC("igmp", "IGMP information");


+			enableC.show.ip.igmp.addSC("groups", "IGMP group membership information");


+				enableC.show.ip.igmp.groups.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		enableC.show.ip.addSC("interface", "IP interface status and configuration");


+			enableC.show.ip.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show.ip.interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+			enableC.show.ip.interface.addSC("Null", "Null interface");


+		enableC.show.ip.addSC("irdp", "ICMP Router Discovery Protocol");


+		enableC.show.ip.addSC("local", "IP local options");


+		enableC.show.ip.addSC("masks", "Masks associated with a network");


+			enableC.show.ip.masks.addSC("A.B.C.D", "Network number");


+		enableC.show.ip.addSC("mcache", "IP multicast fast-switching cache");


+			enableC.show.ip.mcache.addSC("Hostname or A.B.C.D", "Source or group IP name or address");


+				enableC.show.ip.mcache["Hostname or A.B.C.D"].addSC("Hostname or A.B.C.D", "Group IP name or address");


+		enableC.show.ip.addSC("mpacket", "Display possible duplicate multicast packets");


+			enableC.show.ip.mpacket.addSC("Hostname or A.B.C.D", "Group address or source address or source name");


+		enableC.show.ip.addSC("msdp", "Multicast Source Discovery Protool (MSDP)");


+			enableC.show.ip.msdp.addSC("count", "SA count per AS");


+				enableC.show.ip.msdp.count.addSC("<1-65535>", "AS number");


+			enableC.show.ip.msdp.addSC("peer", "MSDP Peer Status");


+				enableC.show.ip.msdp.peer.addSC("Hostname or A.B.C.D", "Peer name or address");


+					enableC.show.ip.msdp.peer["Hostname or A.B.C.D"].addSC("advertised-SAs", "SAs advertised to this peer");


+			enableC.show.ip.msdp.addSC("sa-cache", "MSDP Source-Active Cache");


+				enableC.show.ip.msdp["sa-cache"].addSC("<1-65535>", "AS number");


+				enableC.show.ip.msdp["sa-cache"].addSC("Hostname or A.B.C.D", "Source or group IP name or address");


+					enableC.show.ip.msdp["sa-cache"]["Hostname or A.B.C.D"].addSC("<1-65535>", "AS number");


+			enableC.show.ip.msdp.addSC("summary", "MSDP Peer Summary");


+		enableC.show.ip.addSC("nat", "IP NAT information");


+			enableC.show.ip.nat.addSC("statistics", "Translation statistics");


+			enableC.show.ip.nat.addSC("translations", "Translation entries");


+				enableC.show.ip.nat.translations.addSC("verbose", "Show extra information");


+		enableC.show.ip.addSC("ospf", "OSPF information");


+		enableC.show.ip.addSC("rpf", "Display RPF information for multicast source");


+			enableC.show.ip.rpf.addSC("Hostname or A.B.C.D", "IP name or address of multicast source");


+		enableC.show.ip.addSC("sdr", "Session Directory (SDPv2) cache");


+			enableC.show.ip.sdr.addSC("A.B.C.D", "IP group address");


+			enableC.show.ip.sdr.addSC("WORD", "Session name (in double quotes)");


+			enableC.show.ip.sdr.addSC("detail", "Session details");


+		enableC.show.ip.addSC("sockets", "Open IP sockets");


+		enableC.show.ip.addSC("traffic", "IP protocol statistics");


+		enableC.show.ip.addSC("vrf", "VPN Routing/Forwarding instance information");


+	enableC.show.addSC("key", "Key information");


+		enableC.show.key.addSC("chain", "Keychain information");


+			enableC.show.key.chain.addSC("WORD", "Keychain name");


+	enableC.show.addSC("l2tcam", "Show L2TCAM Manager tables");


+		enableC.show.l2tcam.addSC("cam", "Dump the CAM contents");


+			enableC.show.l2tcam.cam.addSC("forwarding", "Dump the CAM contents of forwarding table");


+				enableC.show.l2tcam.cam.forwarding.addSC("<0-4294967295>", "handle");


+			enableC.show.l2tcam.cam.addSC("learning", "Dump the CAM contents of learning table");


+		enableC.show.l2tcam.addSC("shadow", "Dump the shadow table");


+	enableC.show.addSC("l3tcam", "Show L3TCAM Manager tables");


+		enableC.show.l3tcam.addSC("cam", "Dump the CAM contents");


+		enableC.show.l3tcam.addSC("shadow", "Dump the shadow table");


+	enableC.show.addSC("line", "TTY line information");


+		enableC.show.line.addSC("<0-16>", "First Line range");


+			enableC.show.line["<0-16>"].addSC("<1-16>", "Last Line range");


+		enableC.show.line.addSC("console", "Primary terminal line");


+			enableC.show.line.console.addSC("<0-0>", "First Line range");


+		enableC.show.line.addSC("summary", "Quick line status summary");


+		enableC.show.line.addSC("vty", "Virtual terminal");


+	enableC.show.addSC("location", "Display the system location");


+	enableC.show.addSC("logging", "Show the contents of logging buffers");


+		enableC.show.logging.addSC("history", "Show the contents of syslog history table");


+	enableC.show.addSC("mac-address-table", "MAC forwarding table");


+		enableC.show["mac-address-table"].addSC("address", "address keyword");


+			enableC.show["mac-address-table"].address.addSC("H.H.H", "48 bit mac address");


+		enableC.show["mac-address-table"].addSC("aging-time", "aging-time keyword");


+		enableC.show["mac-address-table"].addSC("count", "count keyword");


+		enableC.show["mac-address-table"].addSC("dynamic", "dynamic entry type");


+			enableC.show["mac-address-table"].dynamic.addSC("address", "address keyword");


+				enableC.show["mac-address-table"].dynamic.address.addSC("H.H.H", "48 bit mac address");


+		enableC.show["mac-address-table"].addSC("interface", "interface keyword");


+			enableC.show["mac-address-table"].interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show["mac-address-table"].interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show["mac-address-table"].addSC("multicast", "multicast info for selected wildcard");


+			enableC.show["mac-address-table"].multicast.addSC("count", "Count Keyword");


+			enableC.show["mac-address-table"].multicast.addSC("igmp-snooping", "Addresses learned by IGMP Snooping");


+				enableC.show["mac-address-table"].multicast["igmp-snooping"].addSC("count", "Count Keyword");


+			enableC.show["mac-address-table"].multicast.addSC("user", "User entered(static) addresses");


+				enableC.show["mac-address-table"].multicast.user.addSC("count", "Count Keyword");


+		enableC.show["mac-address-table"].addSC("static", "static entry type");


+			enableC.show["mac-address-table"].static.addSC("address", "address keyword");


+				enableC.show["mac-address-table"].static.address.addSC("H.H.H", "48 bit mac address");


+			enableC.show["mac-address-table"].static.addSC("interface", "interface keyword");


+				enableC.show["mac-address-table"].static.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					enableC.show["mac-address-table"].static.interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show["mac-address-table"].addSC("vlan", "vlan keyword");


+			enableC.show["mac-address-table"].vlan.addSC("<1-1005>", "vlan number");


+	enableC.show.addSC("memory", "Memory statistics");


+	enableC.show.addSC("mls", "Show MultiLayer Switching information");


+		enableC.show.mls.addSC("qos", "Show QoS information");


+	enableC.show.addSC("monitor", "Show a SPAN session");


+		enableC.show.monitor.addSC("session", "SPAN session");


+			enableC.show.monitor.session.addSC("<1-2>", "SPAN session number");


+	enableC.show.addSC("mvr", "Show mvr global parameters");


+		enableC.show.mvr.addSC("interface", "Show mvr interface information");


+			enableC.show.mvr.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show.mvr.interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.mvr.addSC("members", "Show multicast group members");


+			enableC.show.mvr.members.addSC("A.B.C.D", "IP for which to show membership");


+	enableC.show.addSC("ntp", "Network time protocol");


+		enableC.show.ntp.addSC("associations", "NTP associations");


+			enableC.show.ntp.associations.addSC("detail", "Show detail");


+		enableC.show.ntp.addSC("status", "NTP status");


+	enableC.show.addSC("pagp", "Port channel information");


+		enableC.show.pagp.addSC("<1-64>", "Channel group number");


+		enableC.show.pagp.addSC("counters", "Traffic information");


+		enableC.show.pagp.addSC("internal", "Internal information");


+		enableC.show.pagp.addSC("neighbor", "Neighbor information");


+	enableC.show.addSC("pm", "Show Port Manager commands");


+		enableC.show.pm.addSC("LINE", "...");


+	enableC.show.addSC("policy-map", "Show QoS Policy Map");


+	enableC.show.addSC("post", "post");


+		enableC.show.post.addSC("done", "post done");


+		enableC.show.post.addSC("start", "post start");


+	enableC.show.addSC("privilege", "Show current privilege level");


+	enableC.show.addSC("processes", "Active process statistics");


+		enableC.show.processes.addSC("cpu", "Show CPU use per process");


+		enableC.show.processes.addSC("memory", "Show memory use per process");


+			enableC.show.processes.memory.addSC("<1-4294967295>", "[pid]");


+	enableC.show.addSC("protocols", "Active network routing protocols");


+		enableC.show.protocols.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.protocols.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.protocols.addSC("Null", "Null interface");


+			enableC.show.protocols.Null.addSC("<0-0>", "Null interface number");


+		enableC.show.protocols.addSC("Vlan", "Catalyst Vlans");


+			enableC.show.protocols.Vlan.addSC("<1-1001>", "Vlan interface number");


+	enableC.show.addSC("queue", "Show queue contents");


+	enableC.show.addSC("queueing", "Show queueing configuration");


+	enableC.show.addSC("registry", "Function registry information");


+		enableC.show.registry.addSC("WORD", "Name of registry to examine");


+			enableC.show.registry.WORD.addSC("WORD", "Number of service to examine");


+		enableC.show.registry.addSC("brief", "List only a brief service description");


+		enableC.show.registry.addSC("statistics", "Function registry statistics");


+	enableC.show.addSC("reload", "Scheduled reload information");


+	enableC.show.addSC("rhosts", "Remote-host+user equivalences");


+	enableC.show.addSC("rmon", "rmon statistics");


+	enableC.show.addSC("route-map", "route-map information");


+		enableC.show["route-map"].addSC("WORD", "route-map name");


+	enableC.show.addSC("rps", "Show color of RPS led");


+	enableC.show.addSC("rtr", "Response Time Reporter (RTR)");


+		enableC.show.rtr.addSC("application", "RTR Application");


+		enableC.show.rtr.addSC("authentication", "RTR Authentication Information");


+	enableC.show.addSC("running-config", "Current operating configuration");


+		enableC.show["running-config"].addSC("interface", "Show interface configuration");


+			enableC.show["running-config"].interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				enableC.show["running-config"].interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+			enableC.show["running-config"].interface.addSC("Null", "Null interface");


+				enableC.show["running-config"].interface.Null.addSC("<0-0>", "Null interface number");


+			enableC.show["running-config"].interface.addSC("Vlan", "Catalyst Vlans");


+				enableC.show["running-config"].interface.Vlan.addSC("<1-1001>", "Vlan interface number");


+		enableC.show["running-config"].addSC("map-class", "Show map class information");


+	enableC.show.addSC("sdm", "vegas switch database management");


+	enableC.show.addSC("sessions", "Information about Telnet connections");


+	enableC.show.addSC("smf", "Software MAC filter");


+		enableC.show.smf.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.smf.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.smf.addSC("Null", "Null interface");


+			enableC.show.smf.Null.addSC("<0-0>", "Null interface number");


+		enableC.show.smf.addSC("Vlan", "Catalyst Vlans");


+			enableC.show.smf.Vlan.addSC("<1-1001>", "Vlan interface number");


+	enableC.show.addSC("snmp", "snmp statistics");


+		enableC.show.snmp.addSC("engineID", "show local and remote SNMP engine IDs");


+		enableC.show.snmp.addSC("group", "show SNMPv3 groups");


+		enableC.show.snmp.addSC("user", "show SNMPv3 users");


+	enableC.show.addSC("spanning-tree", "Spanning tree topology");


+	enableC.show.addSC("stacks", "Process stack utilization");


+		enableC.show.stacks.addSC("<1-8192>", "Process to show stack detail on");


+	enableC.show.addSC("standby", "Hot standby protocol information");


+		enableC.show.standby.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			enableC.show.standby.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+		enableC.show.standby.addSC("Vlan", "Catalyst Vlans");


+			enableC.show.standby.Vlan.addSC("<1-1001>", "Vlan interface number");


+				enableC.show.standby.Vlan["<1-1001>"].addSC("<0-255>", "group number");


+		enableC.show.standby.addSC("brief", "Brief output");


+	enableC.show.addSC("startup-config", "Contents of startup configuration");


+	enableC.show.addSC("subscriber-policy", "Subscriber policy");


+		enableC.show["subscriber-policy"].addSC("<1-100>", "Subcriber policy number");


+	enableC.show.addSC("subsys", "Show subsystem information");


+	enableC.show.addSC("system", "Show the system configuration");


+		enableC.show.system.addSC("mtu", "Show the Global Maximum Transmission Unit (MTU)");


+	enableC.show.addSC("tacacs", "Shows tacacs+ server statistics");


+	enableC.show.addSC("tcam", "TCAM Information");


+		enableC.show.tcam.addSC("inacl", "Show Ingress ACL TCAM");


+	enableC.show.addSC("tcp", "Status of TCP connections");


+		enableC.show.tcp.addSC("<0-16>", "Line number");


+		enableC.show.tcp.addSC("brief", "Brief display");


+			enableC.show.tcp.brief.addSC("all", "All end-points (even listeners)");


+		enableC.show.tcp.addSC("console", "Primary terminal line");


+			enableC.show.tcp.console.addSC("<0-0>", "Line number");


+		enableC.show.tcp.addSC("statistics", "TCP protocol statistics");


+	enableC.show.addSC("tech-support", "Show system information for Tech-Support");


+		enableC.show["tech-support"].addSC("cef", "CEF related information");


+	enableC.show.addSC("template", "Template information");


+		enableC.show.template.addSC("WORD", "Specify template name");


+	enableC.show.addSC("terminal", "Display terminal configuration parameters");


+	enableC.show.addSC("time-range", "Time range");


+		enableC.show["time-range"].addSC("WORD", "Name of entry to show");


+	enableC.show.addSC("udld", "UDLD information");


+		enableC.show.udld.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+	enableC.show.addSC("users", "Display information about terminal lines");


+		enableC.show.users.addSC("all", "Include information about inactive ports");


+		enableC.show.users.addSC("wide", "use wide format");


+	enableC.show.addSC("version", "System hardware and software status");


+	enableC.show.addSC("vlan", "VTP VLAN status");


+		enableC.show.vlan.addSC("access-map", "Vlan access-map");


+enableC.addSC("systat", "Display information about terminal lines");


+	enableC.systat.addSC("all", "Include information about inactive ports");


+enableC.addSC("telnet", "Open a telnet connection");


+	enableC.telnet.addSC("WORD", "IP address or hostname of a remote system");


+enableC.addSC("terminal", "Set terminal line parameters");


+enableC.addSC("test", "Test subsystems, memory, and interfaces");


+enableC.addSC("traceroute", "Trace route to destination");


+enableC.addSC("tunnel", "Open a tunnel connection");


+	enableC.tunnel.addSC("WORD", "Address or hostname of a remote system");


+		enableC.tunnel.WORD.addSC("debug", "Enable tunnel debugging output");


+enableC.addSC("udld", "UDLD protocol commands");


+	enableC.udld.addSC("reset", "Reset all interfaces which have been shutdown by UDLD");


+enableC.addSC("undebug", "Disable debugging functions (see also 'debug')");


+enableC.addSC("verify", "Verify a file");


+	enableC.verify.addSC("flash:", "File to be verified");


+enableC.addSC("vlan", "Configure VLAN parameters");


+	enableC.vlan.addSC("database", "Configure VLAN database");


+enableC.addSC("vmps", "VMPS actions");


+	enableC.vmps.addSC("reconfirm", "Reconfirm assignments with the VMPS");


+enableC.addSC("where", "List active connections");


+enableC.addSC("write", "Write running configuration to memory, network, or terminal");


+	enableC.write.addSC("erase", "Erase NV memory");


+	enableC.write.addSC("memory", "Write to NV memory");


+	enableC.write.addSC("network", "Write to network TFTP server");


+		enableC.write.network.addSC("flash:", "URL of destination file");


+		enableC.write.network.addSC("ftp:", "URL of destination file");


+		enableC.write.network.addSC("null:", "URL of destination file");


+		enableC.write.network.addSC("nvram:", "URL of destination file");


+		enableC.write.network.addSC("rcp:", "URL of destination file");


+		enableC.write.network.addSC("system:", "URL of destination file");


+		enableC.write.network.addSC("tftp:", "URL of destination file");


+		enableC.write.network.addSC("zflash:", "URL of destination file");


+	enableC.write.addSC("terminal", "Write to terminal");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_extNacl.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_extNacl.txt
new file mode 100644
index 0000000..f36c5be
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_extNacl.txt
@@ -0,0 +1,673 @@
+


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


+extNaclC.addSC("deny", "Specify packets to reject");


+	extNaclC.deny.addSC("<0-255>", "An IP protocol number");


+		extNaclC.deny["<0-255>"].addSC("A.B.C.D", "Source address");


+			extNaclC.deny["<0-255>"]["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny["<0-255>"].addSC("any", "Any source host");


+			extNaclC.deny["<0-255>"].any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny["<0-255>"].any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny["<0-255>"].any.addSC("any", "Any destination host");


+			extNaclC.deny["<0-255>"].any.addSC("host", "A single destination host");


+				extNaclC.deny["<0-255>"].any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny["<0-255>"].addSC("host", "A single source host");


+			extNaclC.deny["<0-255>"].host.addSC("Hostname or A.B.C.D", "Source address");


+	extNaclC.deny.addSC("ahp", "Authentication Header Protocol");


+		extNaclC.deny.ahp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.ahp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.ahp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ahp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ahp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.ahp.addSC("any", "Any source host");


+			extNaclC.deny.ahp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ahp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.ahp.any.addSC("any", "Any destination host");


+			extNaclC.deny.ahp.any.addSC("host", "A single destination host");


+				extNaclC.deny.ahp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.ahp.addSC("host", "A single source host");


+			extNaclC.deny.ahp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.ahp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ahp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ahp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("eigrp", "Cisco's EIGRP routing protocol");


+		extNaclC.deny.eigrp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.eigrp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.eigrp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.eigrp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.eigrp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.eigrp.addSC("any", "Any source host");


+			extNaclC.deny.eigrp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.eigrp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.eigrp.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.eigrp.any.addSC("host", "A single destination host");


+				extNaclC.deny.eigrp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.eigrp.addSC("host", "A single source host");


+			extNaclC.deny.eigrp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.eigrp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.eigrp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.eigrp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("esp", "Encapsulation Security Payload");


+		extNaclC.deny.esp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.esp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.esp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.esp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.esp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.esp.addSC("any", "Any source host");


+			extNaclC.deny.esp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.esp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.esp.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.esp.any.addSC("host", "A single destination host");


+				extNaclC.deny.esp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.esp.addSC("host", "A single source host");


+			extNaclC.deny.esp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.esp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.esp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.esp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("gre", "Cisco's GRE tunneling");


+		extNaclC.deny.gre.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.gre["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.gre["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.gre["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.gre["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.gre.addSC("any", "Any source host");


+			extNaclC.deny.gre.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.gre.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.gre.any.addSC("any", "Any destination host");


+			extNaclC.deny.gre.any.addSC("host", "A single destination host");


+				extNaclC.deny.gre.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.gre.addSC("host", "A single source host");


+			extNaclC.deny.gre.host.addSC("Hostname or A.B.C.D", "Source address");


+	extNaclC.deny.addSC("icmp", "Internet Control Message Protocol");


+		extNaclC.deny.icmp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.icmp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.icmp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.icmp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.icmp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.icmp.addSC("any", "Any source host");


+			extNaclC.deny.icmp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.icmp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.icmp.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.icmp.any.addSC("host", "A single destination host");


+				extNaclC.deny.icmp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.icmp.addSC("host", "A single source host");


+			extNaclC.deny.icmp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.icmp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.icmp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.icmp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("igmp", "Internet Gateway Message Protocol");


+		extNaclC.deny.igmp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.igmp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.igmp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igmp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.igmp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.igmp.addSC("any", "Any source host");


+			extNaclC.deny.igmp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igmp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.igmp.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.igmp.any.addSC("host", "A single destination host");


+				extNaclC.deny.igmp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.igmp.addSC("host", "A single source host");


+			extNaclC.deny.igmp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.igmp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igmp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.igmp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("igrp", "Cisco's IGRP routing protocol");


+		extNaclC.deny.igrp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.igrp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.igrp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igrp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.igrp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.igrp.addSC("any", "Any source host");


+			extNaclC.deny.igrp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igrp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.igrp.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.igrp.any.addSC("host", "A single destination host");


+				extNaclC.deny.igrp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.igrp.addSC("host", "A single source host");


+			extNaclC.deny.igrp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.igrp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.igrp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.igrp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("ip", "Any Internet Protocol");


+		extNaclC.deny.ip.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.ip["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.ip["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ip["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ip["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.ip.addSC("any", "Any source host");


+			extNaclC.deny.ip.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ip.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.ip.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.ip.any.addSC("host", "A single destination host");


+				extNaclC.deny.ip.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.ip.addSC("host", "A single source host");


+			extNaclC.deny.ip.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.ip.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ip.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ip.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("ipinip", "IP in IP tunneling");


+		extNaclC.deny.ipinip.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.ipinip["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+


+		extNaclC.deny.ipinip.addSC("any", "Any source host");


+			extNaclC.deny.ipinip.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ipinip.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.ipinip.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.ipinip.any.addSC("host", "A single destination host");


+				extNaclC.deny.ipinip.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.ipinip.addSC("host", "A single source host");


+			extNaclC.deny.ipinip.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.ipinip.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ipinip.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ipinip.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("nos", "KA9Q NOS compatible IP over IP tunneling");


+		extNaclC.deny.nos.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.nos["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.nos["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.nos["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.nos["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.nos.addSC("any", "Any source host");


+			extNaclC.deny.nos.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.nos.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.nos.any.addSC("any", "Any destination host");


+


+			extNaclC.deny.nos.any.addSC("host", "A single destination host");


+				extNaclC.deny.nos.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.nos.addSC("host", "A single source host");


+			extNaclC.deny.nos.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.nos.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.nos.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.nos.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("ospf", "OSPF routing protocol");


+		extNaclC.deny.ospf.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.ospf["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.ospf["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ospf["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ospf["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.ospf.addSC("any", "Any source host");


+			extNaclC.deny.ospf.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ospf.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.ospf.any.addSC("any", "Any destination host");


+			extNaclC.deny.ospf.any.addSC("host", "A single destination host");


+				extNaclC.deny.ospf.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.deny.ospf.addSC("host", "A single source host");


+			extNaclC.deny.ospf.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.ospf.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.ospf.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.ospf.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("pcp", "Payload Compression Protocol");


+		extNaclC.deny.pcp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.pcp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.pcp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.pcp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.pcp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.pcp.addSC("any", "Any source host");


+


+		extNaclC.deny.pcp.addSC("host", "A single source host");


+			extNaclC.deny.pcp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.deny.pcp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.pcp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.pcp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.deny.addSC("pim", "Protocol Independent Multicast");


+		extNaclC.deny.pim.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.pim["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.deny.pim["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.pim["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.deny.pim["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.deny.pim.addSC("any", "Any source host");


+


+		extNaclC.deny.pim.addSC("host", "A single source host");


+


+	extNaclC.deny.addSC("tcp", "Transmission Control Protocol");


+		extNaclC.deny.tcp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.tcp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+		extNaclC.deny.tcp.addSC("any", "Any source host");


+			extNaclC.deny.tcp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.deny.tcp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.deny.tcp.any.addSC("any", "Any destination host");


+			extNaclC.deny.tcp.any.addSC("eq", "Match only packets on a given port number");


+


+			extNaclC.deny.tcp.any.addSC("gt", "Match only packets with a greater port number");


+


+			extNaclC.deny.tcp.any.addSC("host", "A single destination host");


+				extNaclC.deny.tcp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+			extNaclC.deny.tcp.any.addSC("lt", "Match only packets with a lower port number");


+


+			extNaclC.deny.tcp.any.addSC("neq", "Match only packets not on a given port number");


+


+			extNaclC.deny.tcp.any.addSC("range", "Match only packets in the range of port numbers");


+


+		extNaclC.deny.tcp.addSC("host", "A single source host");


+			extNaclC.deny.tcp.host.addSC("Hostname or A.B.C.D", "Source address");


+


+	extNaclC.deny.addSC("udp", "User Datagram Protocol");


+		extNaclC.deny.udp.addSC("A.B.C.D", "Source address");


+			extNaclC.deny.udp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+


+		extNaclC.deny.udp.addSC("any", "Any source host");


+


+		extNaclC.deny.udp.addSC("host", "A single source host");


+			extNaclC.deny.udp.host.addSC("Hostname or A.B.C.D", "Source address");


+


+extNaclC.addSC("dynamic", "Specify a DYNAMIC list of PERMITs or DENYs");


+	extNaclC.dynamic.addSC("WORD", "Name of a Dynamic list");


+		extNaclC.dynamic.WORD.addSC("deny", "Specify packets to reject");


+			extNaclC.dynamic.WORD.deny.addSC("<0-255>", "An IP protocol number");


+				extNaclC.dynamic.WORD.deny["<0-255>"].addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny["<0-255>"].addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny["<0-255>"].addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("ahp", "Authentication Header Protocol");


+				extNaclC.dynamic.WORD.deny.ahp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.ahp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.ahp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("eigrp", "Cisco's EIGRP routing protocol");


+				extNaclC.dynamic.WORD.deny.eigrp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.eigrp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.eigrp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("esp", "Encapsulation Security Payload");


+				extNaclC.dynamic.WORD.deny.esp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.esp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.esp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("gre", "Cisco's GRE tunneling");


+				extNaclC.dynamic.WORD.deny.gre.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.gre.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.gre.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("icmp", "Internet Control Message Protocol");


+				extNaclC.dynamic.WORD.deny.icmp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.icmp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.icmp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("igmp", "Internet Gateway Message Protocol");


+				extNaclC.dynamic.WORD.deny.igmp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.igmp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.igmp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("igrp", "Cisco's IGRP routing protocol");


+				extNaclC.dynamic.WORD.deny.igrp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.igrp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.igrp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("ip", "Any Internet Protocol");


+				extNaclC.dynamic.WORD.deny.ip.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.ip.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.ip.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("ipinip", "IP in IP tunneling");


+				extNaclC.dynamic.WORD.deny.ipinip.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.ipinip.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.ipinip.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("nos", "KA9Q NOS compatible IP over IP tunneling");


+				extNaclC.dynamic.WORD.deny.nos.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.nos.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.nos.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("ospf", "OSPF routing protocol");


+				extNaclC.dynamic.WORD.deny.ospf.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.ospf.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.ospf.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("pcp", "Payload Compression Protocol");


+				extNaclC.dynamic.WORD.deny.pcp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.pcp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.pcp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("pim", "Protocol Independent Multicast");


+				extNaclC.dynamic.WORD.deny.pim.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.pim.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.pim.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("tcp", "Transmission Control Protocol");


+				extNaclC.dynamic.WORD.deny.tcp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.tcp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.tcp.addSC("host", "A single source host");


+			extNaclC.dynamic.WORD.deny.addSC("udp", "User Datagram Protocol");


+				extNaclC.dynamic.WORD.deny.udp.addSC("A.B.C.D", "Source address");


+				extNaclC.dynamic.WORD.deny.udp.addSC("any", "Any source host");


+				extNaclC.dynamic.WORD.deny.udp.addSC("host", "A single source host");


+		extNaclC.dynamic.WORD.addSC("timeout", "Maximum time for dynamic ACL to live");


+			extNaclC.dynamic.WORD.timeout.addSC("<1-9999>", "Maximum time to live");


+				extNaclC.dynamic.WORD.timeout["<1-9999>"].addSC("deny", "Specify packets to reject");


+extNaclC.addSC("evaluate", "Evaluate an access list");


+	extNaclC.evaluate.addSC("WORD", "IP reflexive access list name");


+extNaclC.addSC("exit", "Exit from access-list configuration mode");


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


+	extNaclC.no.addSC("deny", "Specify packets to reject");


+		extNaclC.no.deny.addSC("<0-255>", "An IP protocol number");


+


+		extNaclC.no.deny.addSC("ahp", "Authentication Header Protocol");


+


+		extNaclC.no.deny.addSC("eigrp", "Cisco's EIGRP routing protocol");


+


+		extNaclC.no.deny.addSC("esp", "Encapsulation Security Payload");


+


+		extNaclC.no.deny.addSC("gre", "Cisco's GRE tunneling");


+


+		extNaclC.no.deny.addSC("icmp", "Internet Control Message Protocol");


+


+		extNaclC.no.deny.addSC("igmp", "Internet Gateway Message Protocol");


+


+		extNaclC.no.deny.addSC("igrp", "Cisco's IGRP routing protocol");


+


+		extNaclC.no.deny.addSC("ip", "Any Internet Protocol");


+


+		extNaclC.no.deny.addSC("ipinip", "IP in IP tunneling");


+


+		extNaclC.no.deny.addSC("nos", "KA9Q NOS compatible IP over IP tunneling");


+


+		extNaclC.no.deny.addSC("ospf", "OSPF routing protocol");


+


+		extNaclC.no.deny.addSC("pcp", "Payload Compression Protocol");


+


+		extNaclC.no.deny.addSC("pim", "Protocol Independent Multicast");


+


+		extNaclC.no.deny.addSC("tcp", "Transmission Control Protocol");


+


+		extNaclC.no.deny.addSC("udp", "User Datagram Protocol");


+


+	extNaclC.no.addSC("dynamic", "Specify a DYNAMIC list of PERMITs or DENYs");


+		extNaclC.no.dynamic.addSC("WORD", "Name of a Dynamic list");


+			extNaclC.no.dynamic.WORD.addSC("deny", "Specify packets to reject");


+


+			extNaclC.no.dynamic.WORD.addSC("timeout", "Maximum time for dynamic ACL to live");


+				extNaclC.no.dynamic.WORD.timeout.addSC("<1-9999>", "Maximum time to live");


+	extNaclC.no.addSC("evaluate", "Evaluate an access list");


+		extNaclC.no.evaluate.addSC("WORD", "IP reflexive access list name");


+extNaclC.addSC("permit", "Specify packets to forward");


+	extNaclC.permit.addSC("<0-255>", "An IP protocol number");


+		extNaclC.permit["<0-255>"].addSC("A.B.C.D", "Source address");


+			extNaclC.permit["<0-255>"]["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit["<0-255>"]["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit["<0-255>"].addSC("any", "Any source host");


+			extNaclC.permit["<0-255>"].any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit["<0-255>"].any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit["<0-255>"].any.addSC("any", "Any destination host");


+


+			extNaclC.permit["<0-255>"].any.addSC("host", "A single destination host");


+				extNaclC.permit["<0-255>"].any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit["<0-255>"].addSC("host", "A single source host");


+			extNaclC.permit["<0-255>"].host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit["<0-255>"].host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit["<0-255>"].host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit["<0-255>"].host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("ahp", "Authentication Header Protocol");


+		extNaclC.permit.ahp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.ahp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.ahp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ahp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ahp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.ahp.addSC("any", "Any source host");


+			extNaclC.permit.ahp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ahp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.ahp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.ahp.any.addSC("host", "A single destination host");


+				extNaclC.permit.ahp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.ahp.addSC("host", "A single source host");


+			extNaclC.permit.ahp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.ahp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ahp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ahp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("eigrp", "Cisco's EIGRP routing protocol");


+		extNaclC.permit.eigrp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.eigrp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.eigrp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.eigrp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.eigrp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.eigrp.addSC("any", "Any source host");


+			extNaclC.permit.eigrp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.eigrp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.eigrp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.eigrp.any.addSC("host", "A single destination host");


+				extNaclC.permit.eigrp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.eigrp.addSC("host", "A single source host");


+			extNaclC.permit.eigrp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.eigrp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.eigrp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.eigrp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("esp", "Encapsulation Security Payload");


+		extNaclC.permit.esp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.esp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.esp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.esp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.esp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.esp.addSC("any", "Any source host");


+


+		extNaclC.permit.esp.addSC("host", "A single source host");


+


+	extNaclC.permit.addSC("gre", "Cisco's GRE tunneling");


+		extNaclC.permit.gre.addSC("A.B.C.D", "Source address");


+


+		extNaclC.permit.gre.addSC("any", "Any source host");


+


+		extNaclC.permit.gre.addSC("host", "A single source host");


+			extNaclC.permit.gre.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.gre.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.gre.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.gre.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("icmp", "Internet Control Message Protocol");


+		extNaclC.permit.icmp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.icmp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.icmp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.icmp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.icmp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.icmp.addSC("any", "Any source host");


+			extNaclC.permit.icmp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.icmp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.icmp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.icmp.any.addSC("host", "A single destination host");


+				extNaclC.permit.icmp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.icmp.addSC("host", "A single source host");


+			extNaclC.permit.icmp.host.addSC("Hostname or A.B.C.D", "Source address");


+


+	extNaclC.permit.addSC("igmp", "Internet Gateway Message Protocol");


+		extNaclC.permit.igmp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.igmp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+


+		extNaclC.permit.igmp.addSC("any", "Any source host");


+			extNaclC.permit.igmp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.igmp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.igmp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.igmp.any.addSC("host", "A single destination host");


+				extNaclC.permit.igmp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.igmp.addSC("host", "A single source host");


+			extNaclC.permit.igmp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.igmp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.igmp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.igmp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("igrp", "Cisco's IGRP routing protocol");


+		extNaclC.permit.igrp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.igrp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.igrp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.igrp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.igrp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.igrp.addSC("any", "Any source host");


+			extNaclC.permit.igrp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.igrp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.igrp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.igrp.any.addSC("host", "A single destination host");


+				extNaclC.permit.igrp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.igrp.addSC("host", "A single source host");


+			extNaclC.permit.igrp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.igrp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.igrp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.igrp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("ip", "Any Internet Protocol");


+		extNaclC.permit.ip.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.ip["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.ip["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ip["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ip["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.ip.addSC("any", "Any source host");


+			extNaclC.permit.ip.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ip.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.ip.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.ip.any.addSC("host", "A single destination host");


+				extNaclC.permit.ip.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.ip.addSC("host", "A single source host");


+			extNaclC.permit.ip.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.ip.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ip.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ip.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("ipinip", "IP in IP tunneling");


+		extNaclC.permit.ipinip.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.ipinip["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.ipinip["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ipinip["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ipinip["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.ipinip.addSC("any", "Any source host");


+			extNaclC.permit.ipinip.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ipinip.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.ipinip.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.ipinip.any.addSC("host", "A single destination host");


+				extNaclC.permit.ipinip.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.ipinip.addSC("host", "A single source host");


+			extNaclC.permit.ipinip.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.ipinip.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ipinip.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ipinip.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("nos", "KA9Q NOS compatible IP over IP tunneling");


+		extNaclC.permit.nos.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.nos["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.nos["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.nos["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.nos["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.nos.addSC("any", "Any source host");


+			extNaclC.permit.nos.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.nos.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.nos.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.nos.any.addSC("host", "A single destination host");


+				extNaclC.permit.nos.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.nos.addSC("host", "A single source host");


+			extNaclC.permit.nos.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.nos.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.nos.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.nos.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("ospf", "OSPF routing protocol");


+		extNaclC.permit.ospf.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.ospf["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.ospf["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ospf["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ospf["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.ospf.addSC("any", "Any source host");


+			extNaclC.permit.ospf.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ospf.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.ospf.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.ospf.any.addSC("host", "A single destination host");


+				extNaclC.permit.ospf.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.ospf.addSC("host", "A single source host");


+			extNaclC.permit.ospf.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.ospf.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.ospf.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.ospf.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("pcp", "Payload Compression Protocol");


+		extNaclC.permit.pcp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.pcp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.pcp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pcp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.pcp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.pcp.addSC("any", "Any source host");


+			extNaclC.permit.pcp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pcp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.pcp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.pcp.any.addSC("host", "A single destination host");


+				extNaclC.permit.pcp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.pcp.addSC("host", "A single source host");


+			extNaclC.permit.pcp.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.pcp.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pcp.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.pcp.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("pim", "Protocol Independent Multicast");


+		extNaclC.permit.pim.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.pim["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.pim["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pim["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.pim["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+		extNaclC.permit.pim.addSC("any", "Any source host");


+			extNaclC.permit.pim.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pim.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.pim.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.pim.any.addSC("host", "A single destination host");


+				extNaclC.permit.pim.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+		extNaclC.permit.pim.addSC("host", "A single source host");


+			extNaclC.permit.pim.host.addSC("Hostname or A.B.C.D", "Source address");


+				extNaclC.permit.pim.host["Hostname or A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.pim.host["Hostname or A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.pim.host["Hostname or A.B.C.D"].addSC("host", "A single destination host");


+	extNaclC.permit.addSC("tcp", "Transmission Control Protocol");


+		extNaclC.permit.tcp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.tcp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("any", "Any destination host");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("eq", "Match only packets on a given port number");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("gt", "Match only packets with a greater port number");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("host", "A single destination host");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("lt", "Match only packets with a lower port number");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("neq", "Match only packets not on a given port number");


+				extNaclC.permit.tcp["A.B.C.D"]["A.B.C.D"].addSC("range", "Match only packets in the range of port numbers");


+		extNaclC.permit.tcp.addSC("any", "Any source host");


+			extNaclC.permit.tcp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.tcp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.tcp.any.addSC("any", "Any destination host");


+


+			extNaclC.permit.tcp.any.addSC("eq", "Match only packets on a given port number");


+


+			extNaclC.permit.tcp.any.addSC("gt", "Match only packets with a greater port number");


+


+			extNaclC.permit.tcp.any.addSC("host", "A single destination host");


+				extNaclC.permit.tcp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+			extNaclC.permit.tcp.any.addSC("lt", "Match only packets with a lower port number");


+


+			extNaclC.permit.tcp.any.addSC("neq", "Match only packets not on a given port number");


+


+			extNaclC.permit.tcp.any.addSC("range", "Match only packets in the range of port numbers");


+


+		extNaclC.permit.tcp.addSC("host", "A single source host");


+			extNaclC.permit.tcp.host.addSC("Hostname or A.B.C.D", "Source address");


+


+	extNaclC.permit.addSC("udp", "User Datagram Protocol");


+		extNaclC.permit.udp.addSC("A.B.C.D", "Source address");


+			extNaclC.permit.udp["A.B.C.D"].addSC("A.B.C.D", "Source wildcard bits");


+


+		extNaclC.permit.udp.addSC("any", "Any source host");


+			extNaclC.permit.udp.any.addSC("A.B.C.D", "Destination address");


+				extNaclC.permit.udp.any["A.B.C.D"].addSC("A.B.C.D", "Destination wildcard bits");


+			extNaclC.permit.udp.any.addSC("any", "Any destination host");


+				extNaclC.permit.udp.any.any.addSC("dscp", "Match packets with given dscp value");


+				extNaclC.permit.udp.any.any.addSC("fragments", "Check non-initial fragments");


+				extNaclC.permit.udp.any.any.addSC("log", "Log matches against this entry");


+				extNaclC.permit.udp.any.any.addSC("log-input", "Log matches against this entry, including input interface");


+				extNaclC.permit.udp.any.any.addSC("precedence", "Match packets with given precedence value");


+				extNaclC.permit.udp.any.any.addSC("reflect", "Create reflexive access list entry");


+				extNaclC.permit.udp.any.any.addSC("time-range", "Specify a time-range");


+				extNaclC.permit.udp.any.any.addSC("tos", "Match packets with given TOS value");


+			extNaclC.permit.udp.any.addSC("eq", "Match only packets on a given port number");


+


+			extNaclC.permit.udp.any.addSC("gt", "Match only packets with a greater port number");


+


+			extNaclC.permit.udp.any.addSC("host", "A single destination host");


+				extNaclC.permit.udp.any.host.addSC("Hostname or A.B.C.D", "Destination address");


+			extNaclC.permit.udp.any.addSC("lt", "Match only packets with a lower port number");


+


+			extNaclC.permit.udp.any.addSC("neq", "Match only packets not on a given port number");


+


+			extNaclC.permit.udp.any.addSC("range", "Match only packets in the range of port numbers");


+


+		extNaclC.permit.udp.addSC("host", "A single source host");


+			extNaclC.permit.udp.host.addSC("Hostname or A.B.C.D", "Source address");


+


+extNaclC.addSC("remark", "Access list entry comment");


+	extNaclC.remark.addSC("LINE", "Comment up to 100 characters");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_global.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_global.txt
new file mode 100644
index 0000000..4e7fa3d
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_global.txt
@@ -0,0 +1,336 @@
+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("Hostname or A.B.C.D", "Address to match");


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


+			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>"].deny.host.addSC("Hostname or A.B.C.D", "Host address");


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


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


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


+			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>"].permit.host.addSC("Hostname or A.B.C.D", "Host address");


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


+			globalC["access-list"]["<1-99>"].remark.addSC("LINE", "Comment up to 100 characters");


+	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("ip", "Any Internet Protocol");


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


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


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


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


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


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


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


+			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>"].addSC("remark", "Access list entry comment");


+			globalC["access-list"]["<100-199>"].remark.addSC("LINE", "Comment up to 100 characters");


+	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>"].deny.addSC("Hostname or A.B.C.D", "Address to match");


+				globalC["access-list"]["<1300-1999>"].deny["Hostname or A.B.C.D"].addSC("A.B.C.D", "Wildcard bits");


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


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


+				globalC["access-list"]["<1300-1999>"].deny.host.addSC("Hostname or A.B.C.D", "Host address");


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


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


+


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


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


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


+	globalC.banner.addSC("exec", "Set EXEC process creation banner");


+	globalC.banner.addSC("incoming", "Set incoming terminal line banner");


+	globalC.banner.addSC("login", "Set login banner");


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


+	globalC.banner.addSC("prompt-timeout", "Set Message for login authentication timeout");


+	globalC.banner.addSC("slip-ppp", "Set Message for SLIP/PPP");


+globalC.addSC("boot", "Boot Commands");


+	globalC.boot.addSC("boothlpr", "Boot Helper System Image");


+		globalC.boot.boothlpr.addSC("WORD", "pathlist of boothlpr file(s) ... file1;file2;...");


+	globalC.boot.addSC("buffersize", "Specify the buffer size for filesystem-simulated NVRAM");


+		globalC.boot.buffersize.addSC("<4096-524288>", "Specify the NVRAM simulation buffer size for a config file");


+	globalC.boot.addSC("config-file", "Configuration File");


+		globalC.boot["config-file"].addSC("WORD", "config file name");


+	globalC.boot.addSC("enable-break", "Enable Break while booting");


+	globalC.boot.addSC("helper", "Helper Image(s)");


+	globalC.boot.addSC("helper-config-file", "Helper Configuration File");


+		globalC.boot["helper-config-file"].addSC("WORD", "helper config file name");


+	globalC.boot.addSC("manual", "Manual Boot");


+	globalC.boot.addSC("system", "System Image");


+		globalC.boot.system.addSC("WORD", "pathlist of boot file(s) ... file1;file2;...");


+


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


+


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


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


+	globalC.cdp.addSC("advertise-v2", "CDP sends version-2 advertisements");


+	globalC.cdp.addSC("holdtime", "Specify the holdtime (in sec) to be sent in packets");


+		globalC.cdp.holdtime.addSC("<10-255>", "Length  of time  (in sec) that receiver must keep this packet");


+	globalC.cdp.addSC("timer", "Specify the rate at which CDP packets are sent       (in sec)");


+		globalC.cdp.timer.addSC("<5-254>", "Rate at which CDP packets are sent (in  sec)");


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


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


+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["summer-time"].WORD.addSC("date", "Configure absolute summer time");


+				globalC.clock["summer-time"].WORD.date.addSC("<1-31>", "Date to start");


+				globalC.clock["summer-time"].WORD.date.addSC("MONTH", "Month to start");


+			globalC.clock["summer-time"].WORD.addSC("recurring", "Configure recurring summer time");


+				globalC.clock["summer-time"].WORD.recurring.addSC("<1-4>", "Week number to start");


+					globalC.clock["summer-time"].WORD.recurring["<1-4>"].addSC("DAY", "Weekday to start");


+				globalC.clock["summer-time"].WORD.recurring.addSC("first", "First week of the month");


+					globalC.clock["summer-time"].WORD.recurring.first.addSC("DAY", "Weekday to start");


+				globalC.clock["summer-time"].WORD.recurring.addSC("last", "Last week of the month");


+					globalC.clock["summer-time"].WORD.recurring.last.addSC("DAY", "Weekday to start");


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


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


+			globalC.clock.timezone.WORD.addSC("<-23 - 23>", "Hours offset from UTC");


+


+


+globalC.addSC("cluster", "Cluster configuration commands");


+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("dnsix-dmdp", "Provide DMDP service for DNSIX");


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


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


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


+	globalC.enable.addSC("last-resort", "Define enable action if no TACACS servers respond");


+		globalC.enable["last-resort"].addSC("password", "Enable by giving the local enable password");


+		globalC.enable["last-resort"].addSC("succeed", "Enable without further question");


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


+		globalC.enable.password.addSC("<0-0>", "Specifies an UNENCRYPTED password will follow");


+		globalC.enable.password.addSC("<7-7>", "Specifies a HIDDEN password will follow");


+			globalC.enable.password["<7-7>"].addSC("WORD", "The HIDDEN 'enable' password string");


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


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


+			globalC.enable.password.level.addSC("<1-15>", "Level number");


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


+		globalC.enable.secret.addSC("<0-0>", "Specifies an UNENCRYPTED password will follow");


+		globalC.enable.secret.addSC("5", "Specifies an ENCRYPTED secret will follow");


+			globalC.enable.secret["5"].addSC("LINE", "The ENCRYPTED 'enable' secret string");


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


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


+			globalC.enable.secret.level.addSC("<1-15>", "Level number");


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


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


+globalC.addSC("errdisable", "Error disable");


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


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


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


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


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


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


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


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


+	globalC.interface.addSC("BVI", "Bridge-Group Virtual Interface");


+		globalC.interface.BVI.addSC("<1-255>", "BVI 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("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		globalC.interface.GigabitEthernet.addMC("<1-6>", "GigabitEthernet interface number");


+			globalC.interface.GigabitEthernet["<1-6>"].addSIC("<1-24>", "GigabitEthernet interface number");


+				globalC.interface.GigabitEthernet["<1-6>"]["<1-24>"].addSC("<0-4294967295>");


+


+	globalC.interface.addSC("Group-Async", "Async Group interface");


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


+	globalC.interface.addSC("Lex", "Lex interface");


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


+	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("<0-2147483647>", "Multilink interface number");


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


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


+	globalC.interface.addSC("Port-channel", "Ethernet Channel of interfaces");


+		globalC.interface["Port-channel"].addSC("<1-6>", "Port-channel interface number");


+	globalC.interface.addSC("Tunnel", "Tunnel interface");


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


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


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


+	globalC.interface.addSC("Virtual-TokenRing", "Virtual TokenRing");


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


+	globalC.interface.addSC("Vlan", "Catalyst Vlans");


+		globalC.interface.Vlan.addSIC("<1-1001>", "Vlan interface number");


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


+


+	globalC.interface.addSC("range", "interface range command");


+		globalC.interface.range.addSC("macro", "macro keyword");


+			globalC.interface.range.macro.addSC("WORD", "upto 32 character string");


+


+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"].extended.addSC("<100-199>", "Extended IP access-list number");


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


+		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("WORD", "Access-list name");


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


+		globalC.ip["accounting-list"].addSC("A.B.C.D", "IP address of host");


+			globalC.ip["accounting-list"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");


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


+		globalC.ip["accounting-threshold"].addSC("<0-4294967295>", "Max acct entries");


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


+		globalC.ip["accounting-transits"].addSC("<0-32000>", "Max transit entries");


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


+		globalC.ip.alias.addSC("A.B.C.D", "IP address to alias to a port");


+			globalC.ip.alias["A.B.C.D"].addSC("<0-65535>", "IP port number");


+	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("dhcp-server", "Specify address of DHCP server to use");


+		globalC.ip["dhcp-server"].addSC("Hostname or A.B.C.D", "IP address or Name of DHCP server");


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


+		globalC.ip["domain-list"].addSC("WORD", "A domain name");


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


+		globalC.ip["domain-lookup"].addSC("nsap", "Enable IP DNS queries for CLNS NSAP addresses");


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


+		globalC.ip["domain-name"].addSC("WORD", "Default domain name");


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


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


+


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


+		globalC.ip.tcp.addSC("async-mobility", "Configure async-mobility");


+			globalC.ip.tcp["async-mobility"].addSC("server", "Enable async-mobility server");


+		globalC.ip.tcp.addSC("chunk-size", "TCP chunk size");


+			globalC.ip.tcp["chunk-size"].addSC("<0-4294967295>", "Chunk size");


+		globalC.ip.tcp.addSC("mss", "TCP initial maximum segment size");


+			globalC.ip.tcp.mss.addSC("<0-10000>", "MSS");


+		globalC.ip.tcp.addSC("path-mtu-discovery", "Enable path-MTU discovery on new TCP connections");


+			globalC.ip.tcp["path-mtu-discovery"].addSC("age-timer", "Set PMTU aging timer");


+				globalC.ip.tcp["path-mtu-discovery"]["age-timer"].addSC("<10-30>", "Aging time");


+				globalC.ip.tcp["path-mtu-discovery"]["age-timer"].addSC("infinite", "Disable pathmtu aging timer");


+		globalC.ip.tcp.addSC("queuemax", "Maximum queue of outgoing TCP packets");


+			globalC.ip.tcp.queuemax.addSC("<5-50>", "Number of packets");


+		globalC.ip.tcp.addSC("selective-ack", "Enable TCP selective-ACK");


+		globalC.ip.tcp.addSC("synwait-time", "Set time to wait on new TCP connections");


+			globalC.ip.tcp["synwait-time"].addSC("<5-300>", "Wait time");


+		globalC.ip.tcp.addSC("timestamp", "Enable TCP timestamp option");


+		globalC.ip.tcp.addSC("window-size", "TCP window size");


+			globalC.ip.tcp["window-size"].addSC("<0-65535>", "Window size");


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


+


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


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


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


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


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


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


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


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


+			globalC.line.vty["<0-15>"].addSC("<1-15>", "Last 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("console", "Set console logging level");


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


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


+


+globalC.addSC("mac", "Global MAC configuration subcommands");


+globalC.addSC("mac-address-table", "Configure the MAC address table");


+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("mls", "Global Multi-Layer Switching parameters");


+globalC.addSC("monitor", "Configure SPAN monitoring");


+globalC.addSC("mvr", "Enable/Disable MVR on the switch");


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


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


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


+globalC.addSC("port-channel", "EtherChannel configuration");


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


+	globalC["priority-list"].addSC("<1-16>", "Priority list number");


+		globalC["priority-list"]["<1-16>"].addSC("protocol", "priority queueing by protocol");


+			globalC["priority-list"]["<1-16>"].protocol.addSC("arp", "IP ARP");


+


+		globalC["priority-list"]["<1-16>"].addSC("default", "Set priority queue for unspecified datagrams");


+			globalC["priority-list"]["<1-16>"]["default"].addSC("high", "");


+			globalC["priority-list"]["<1-16>"]["default"].addSC("medium", "");


+			globalC["priority-list"]["<1-16>"]["default"].addSC("normal", "");


+			globalC["priority-list"]["<1-16>"]["default"].addSC("low", "");


+		globalC["priority-list"]["<1-16>"].addSC("interface", "Establish priorities for packets from a named interface");


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


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


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


+	globalC["queue-list"].addSC("<1-16>", "Queue list number");


+		globalC["queue-list"]["<1-16>"].addSC("default", "Set custom queue for unspecified datagrams");


+			globalC["queue-list"]["<1-16>"]["default"].addSC("<0-16>", "queue number");


+		globalC["queue-list"]["<1-16>"].addSC("interface", "Establish priorities for packets from a named interface");


+			globalC["queue-list"]["<1-16>"].interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				globalC["queue-list"]["<1-16>"].interface.GigabitEthernet.addSC("<0-2>", "GigabitEthernet interface number");


+			globalC["queue-list"]["<1-16>"].interface.addSC("Null", "Null interface");


+				globalC["queue-list"]["<1-16>"].interface.Null.addSC("<0-0>", "Null interface number");


+					globalC["queue-list"]["<1-16>"].interface.Null["<0-0>"].addSC("<0-16>", "queue number");


+			globalC["queue-list"]["<1-16>"].interface.addSC("Vlan", "Catalyst Vlans");


+				globalC["queue-list"]["<1-16>"].interface.Vlan.addSC("<1-1001>", "Vlan interface number");


+					globalC["queue-list"]["<1-16>"].interface.Vlan["<1-1001>"].addSC("<0-16>", "queue number");


+		globalC["queue-list"]["<1-16>"].addSC("lowest-custom", "Set lowest number of queue to be treated as custom");


+			globalC["queue-list"]["<1-16>"]["lowest-custom"].addSC("<0-16>", "queue number");


+		globalC["queue-list"]["<1-16>"].addSC("protocol", "priority queueing by protocol");


+			globalC["queue-list"]["<1-16>"].protocol.addSC("arp", "IP ARP");


+				globalC["queue-list"]["<1-16>"].protocol.arp.addSC("<0-16>", "queue number");


+					globalC["queue-list"]["<1-16>"].protocol.arp["<0-16>"].addSC("gt", "Classify packets greater than a specified size");


+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.deny.addSC("<0-65535>", "Sequence to insert to/delete from existing route-map entry");


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


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


+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("egp", "Exterior Gateway Protocol (EGP)");


+		globalC.router.egp.addSC("<0-65535>", "Remote 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("isis", "ISO IS-IS");


+		globalC.router.isis.addSC("WORD", "ISO routing area tag");


+	globalC.router.addSC("iso-igrp", "IGRP for OSI networks");


+		globalC.router["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	globalC.router.addSC("mobile", "Mobile routes");


+	globalC.router.addSC("odr", "On Demand stub Routes");


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


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


+			globalC.router.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				globalC.router.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+	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("sdm", "Switch database management");


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


+globalC.addSC("shutdown", "Shutdown system elements");


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


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


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


+globalC.addSC("switchcore", "switchcore configuration");


+globalC.addSC("system", "Set the system configuration");


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


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


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


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


+	globalC["time-range"].addSC("WORD", "Time range name");


+globalC.addSC("udld", "Configure global UDLD setting");


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


+	globalC.username.addSC("WORD", "User name");


+		globalC.username.WORD.addSC("access-class", "Restrict access by access-class");


+			globalC.username.WORD["access-class"].addSC("<1-199>", "Access-class number");


+globalC.addSC("vlan", "Vlan commands");


+globalC.addSC("vmps", "VMPS settings");


+globalC.addSC("vtp", "Configure global VTP state");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intE.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intE.txt
new file mode 100644
index 0000000..9d4ae91
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intE.txt
@@ -0,0 +1,172 @@
+


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


+intEC.addSC("backup", "Modify backup parameters");


+intEC.addSC("bandwidth", "Set bandwidth informational parameter");


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


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


+intEC.addSC("cdp", "CDP interface subcommands");


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


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


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


+intEC.addSC("delay", "Specify interface throughput delay");


+intEC.addSC("description", "Interface specific description");


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


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


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


+intEC.addSC("flowcontrol", "Configure flow operation.");


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


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


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


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


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


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


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


+intEC.addSC("keepalive", "Enable keepalive");


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


+intEC.addSC("logging", "Configure logging for interface");


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


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


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


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


+	intEC.no.addSC("backup", "Modify backup parameters");


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


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


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


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


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


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


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


+	intEC.no.addSC("description", "Interface specific description");


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


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


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


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


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


+			intEC.no.ip.address.addSC("A.B.C.D", "IP address");


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


+	intEC.no.addSC("keepalive", "Enable keepalive");


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


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


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


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


+	intEC.no.addSC("ntp", "Configure NTP");


+	intEC.no.addSC("pagp", "PAgP interface subcommands");


+	intEC.no.addSC("priority-group", "Assign a priority group to an interface");


+	intEC.no.addSC("qos", "QoS configuration");


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


+	intEC.no.addSC("rate-limit", "Rate Limit");


+	intEC.no.addSC("rmon", "Configure Remote Monitoring on an interface");


+	intEC.no.addSC("service-policy", "Configure QoS Service Policy");


+	intEC.no.addSC("shutdown", "Shutdown the selected interface");


+	intEC.no.addSC("snmp", "Modify SNMP interface parameters");


+	intEC.no.addSC("spanning-tree", "Spanning Tree Subsystem");


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


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


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


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


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


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


+				intEC.no["spanning-tree"].vlan["<1-1005>"].addSC("cost", "Change an interface's per VLAN spanning tree path cost");


+				intEC.no["spanning-tree"].vlan["<1-1005>"].addSC("port-priority", "Change an interface's spanning tree port priority");


+	intEC.no.addSC("speed", "Configure speed operation.");


+	intEC.no.addSC("switchport", "Set switching mode characteristics");


+		intEC.no.switchport.addSC("access", "Set access mode characteristics of the interface");


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


+		intEC.no.switchport.addSC("host", "Set port host");


+		intEC.no.switchport.addSC("mode", "Set trunking mode of the interface");


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


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


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


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


+		intEC.no.switchport.addSC("trunk", "Set trunking characteristics of the interface");


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


+				intEC.no.switchport.trunk.allowed.addSC("vlan", "Set allowed VLANs when interface is in trunking mode");


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


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


+				intEC.no.switchport.trunk.native.addSC("vlan", "Set native VLAN when interface is in trunking mode");


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


+				intEC.no.switchport.trunk.pruning.addSC("vlan", "Set VLANs enabled for pruning when interface is in trunking mode");


+	intEC.no.addSC("timeout", "Define timeout values for this interface");


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


+	intEC.no.addSC("transmit-interface", "Assign a transmit interface to a receive-only interface");


+	intEC.no.addSC("tx-queue", "Configure interface transmit queue");


+	intEC.no.addSC("tx-ring-limit", "Configure PA level transmit ring limit");


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


+intEC.addSC("ntp", "Configure NTP");


+intEC.addSC("pagp", "PAgP interface subcommands");


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


+intEC.addSC("qos", "QoS configuration");


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


+			intEC["spanning-tree"].vlan["<1-1005>"].addSC("cost", "Change an interface's per VLAN spanning tree path cost");


+				intEC["spanning-tree"].vlan["<1-1005>"].cost.addSC("<1-65535>", "Change an interface's per VLAN spanning tree path cost");


+			intEC["spanning-tree"].vlan["<1-1005>"].addSC("port-priority", "Change an interface's spanning tree port priority");


+				intEC["spanning-tree"].vlan["<1-1005>"]["port-priority"].addSC("<0-240>", "port priority in increments of 16");


+intEC.addSC("speed", "Configure speed operation.");


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


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


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


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


+			intEC.switchport.access.vlan.addSC("<1-1005>", "VLAN ID of the VLAN when this port is in access mode");


+	intEC.switchport.addSC("host", "Set port host");


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


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


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


+			intEC.switchport.mode.dynamic.addSC("auto", "Set trunking mode dynamic negotiation parameter to AUTO");


+			intEC.switchport.mode.dynamic.addSC("desirable", "Set trunking mode dynamic negotiation parameter to DESIRABLE");


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


+			intEC.switchport.mode["private-vlan"].addSC("host", "Set the mode to private-vlan host");


+			intEC.switchport.mode["private-vlan"].addSC("promiscuous", "Set the mode to private-vlan promiscuous");


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


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


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


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


+			intEC.switchport["private-vlan"]["host-association"].addSC("<2-1001>", "Primary VLAN ID of the private VLAN host port association");


+				intEC.switchport["private-vlan"]["host-association"]["<2-1001>"].addSC("<2-1001>", "Secondary VLAN ID of the private VLAN host port association");


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


+			intEC.switchport["private-vlan"].mapping.addSC("<2-1001>", "Primary VLAN ID of the private VLAN promiscuous port mapping");


+				intEC.switchport["private-vlan"].mapping["<2-1001>"].addSC("WORD", "Secondary VLAN IDs of the private VLAN promiscuous port mapping");


+				intEC.switchport["private-vlan"].mapping["<2-1001>"].addSC("add", "Add a VLAN to private VLAN list");


+				intEC.switchport["private-vlan"].mapping["<2-1001>"].addSC("remove", "Remove a VLAN from private VLAN list");


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


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


+			intEC.switchport.trunk.allowed.addSC("vlan", "Set allowed VLANs when interface is in trunking mode");


+				intEC.switchport.trunk.allowed.vlan.addSC("WORD", "VLAN IDs of the allowed VLANs when this port is in trunking mode");


+				intEC.switchport.trunk.allowed.vlan.addSC("add", "add VLANs to the current list");


+				intEC.switchport.trunk.allowed.vlan.addSC("all", "all VLANs");


+				intEC.switchport.trunk.allowed.vlan.addSC("except", "all VLANs except the following");


+				intEC.switchport.trunk.allowed.vlan.addSC("remove", "remove VLANs from the current list");


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


+			intEC.switchport.trunk.encapsulation.addSC("dot1q", "Interface uses only 802.1q trunking encapsulation when trunking");


+			intEC.switchport.trunk.encapsulation.addSC("isl", "Interface uses only ISL trunking encapsulation when trunking");


+			intEC.switchport.trunk.encapsulation.addSC("negotiate", "Device will negotiate trunking encapsulation with peer on interface");


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


+			intEC.switchport.trunk.native.addSC("vlan", "Set native VLAN when interface is in trunking mode");


+				intEC.switchport.trunk.native.vlan.addSC("<1-1005>", "VLAN ID of the native VLAN when this port is in trunking mode");


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


+			intEC.switchport.trunk.pruning.addSC("vlan", "Set VLANs enabled for pruning when interface is in trunking mode");


+				intEC.switchport.trunk.pruning.vlan.addSC("add", "add VLANs to the current list");


+				intEC.switchport.trunk.pruning.vlan.addSC("except", "all VLANs except the following");


+				intEC.switchport.trunk.pruning.vlan.addSC("none", "no VLANs");


+				intEC.switchport.trunk.pruning.vlan.addSC("remove", "remove VLANs from the current list");


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


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


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


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


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


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


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intG.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intG.txt
new file mode 100644
index 0000000..804a583
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intG.txt
@@ -0,0 +1,308 @@
+


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


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intLoopBack.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intLoopBack.txt
new file mode 100644
index 0000000..dbff6db
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intLoopBack.txt
@@ -0,0 +1,299 @@
+intLoopBackC.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");


+	intLoopBackC.arp.addSC("arpa", "Standard arp protocol");


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


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


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


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


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


+intLoopBackC.addSC("backup", "Modify backup parameters");


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


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


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


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


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


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


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


+		intLoopBackC.backup.interface.addSC("Async", "Async interface");


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


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


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


+		intLoopBackC.backup.interface.addSC("Dialer", "Dialer interface");


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


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


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


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


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


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


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


+		intLoopBackC.backup.interface.addSC("Lex", "Lex interface");


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


+		intLoopBackC.backup.interface.addSC("Loopback", "Loopback interface");


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


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


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


+


+intLoopBackC.addSC("bandwidth", "Set bandwidth informational parameter");


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


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


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


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


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


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


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


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


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


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


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


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


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


+intLoopBackC.addSC("cdp", "CDP interface subcommands");


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


+


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


+intLoopBackC.addSC("delay", "Specify interface throughput delay");


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


+intLoopBackC.addSC("description", "Interface specific description");


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


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


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


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


+


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


+	intLoopBackC.ip.addSC("access-group", "Specify access control for packets");


+		intLoopBackC.ip["access-group"].addSC("<1-199>", "IP access list (standard or extended)");


+			intLoopBackC.ip["access-group"]["<1-199>"].addSC("in", "inbound packets");


+			intLoopBackC.ip["access-group"]["<1-199>"].addSC("out", "outbound packets");


+		intLoopBackC.ip["access-group"].addSC("<1300-2699>", "IP expanded access list (standard or extended)");


+			intLoopBackC.ip["access-group"]["<1300-2699>"].addSC("in", "inbound packets");


+			intLoopBackC.ip["access-group"]["<1300-2699>"].addSC("out", "outbound packets");


+		intLoopBackC.ip["access-group"].addSC("WORD", "Access-list name");


+			intLoopBackC.ip["access-group"].WORD.addSC("in", "inbound packets");


+			intLoopBackC.ip["access-group"].WORD.addSC("out", "outbound packets");


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


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


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


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


+	intLoopBackC.ip.addSC("bgp", "BGP interface commands");


+		intLoopBackC.ip.bgp.addSC("fast-external-fallover", "Over-ride bgp global fast-failover whenexternal peer goes down");


+			intLoopBackC.ip.bgp["fast-external-fallover"].addSC("deny", "dis-allow fast fallover");


+			intLoopBackC.ip.bgp["fast-external-fallover"].addSC("permit", "allow fast fallover");


+	intLoopBackC.ip.addSC("broadcast-address", "Set the broadcast address of an interface");


+		intLoopBackC.ip["broadcast-address"].addSC("A.B.C.D", "IP broadcast address");


+	intLoopBackC.ip.addSC("cgmp", "Enable/disable CGMP");


+		intLoopBackC.ip.cgmp.addSC("proxy", "CGMP for hosts and proxy for multicast routers");


+		intLoopBackC.ip.cgmp.addSC("router-only", "CGMP proxy for multicast routers only");


+	intLoopBackC.ip.addSC("directed-broadcast", "Enable forwarding of directed broadcasts");


+		intLoopBackC.ip["directed-broadcast"].addSC("<1-199>", "A standard IP access list number");


+		intLoopBackC.ip["directed-broadcast"].addSC("<1300-2699>", "A standard IP expanded access list number");


+


+	intLoopBackC.ip.addSC("igmp", "IGMP interface commands");


+		intLoopBackC.ip.igmp.addSC("access-group", "IGMP group access group");


+			intLoopBackC.ip.igmp["access-group"].addSC("<1-99>", "Access list number");


+			intLoopBackC.ip.igmp["access-group"].addSC("WORD", "IP Named Standard Access list");


+		intLoopBackC.ip.igmp.addSC("helper-address", "IGMP helper address");


+			intLoopBackC.ip.igmp["helper-address"].addSC("A.B.C.D", "IGMP helper address");


+			intLoopBackC.ip.igmp["helper-address"].addSC("udl", "Unidirectional link to forward the report");


+


+	intLoopBackC.ip.addSC("multicast", "IP multicast interface commands");


+		intLoopBackC.ip.multicast.addSC("helper-map", "Broadcast to Multicast map OR Multicast to Broadcast map");


+			intLoopBackC.ip.multicast["helper-map"].addSC("A.B.C.D", "IP multicast address");


+				intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"].addSC("A.B.C.D", "IP multicast address or IP broadcast address");


+					intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("<100-199>", "access-list");


+					intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("<2000-2699>", "access-list (expanded range)");


+					intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("WORD", "IP Named Extended Access list");


+			intLoopBackC.ip.multicast["helper-map"].addSC("broadcast", "Broadcast address");


+				intLoopBackC.ip.multicast["helper-map"].broadcast.addSC("A.B.C.D", "IP multicast address or IP broadcast address");


+					intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("<100-199>", "access-list");


+					intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("<2000-2699>", "access-list (expanded range)");


+					intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("WORD", "IP Named Extended Access list");


+	intLoopBackC.ip.addSC("ospf", "OSPF interface commands");


+		intLoopBackC.ip.ospf.addSC("authentication", "Enable authentication");


+			intLoopBackC.ip.ospf.authentication.addSC("message-digest", "Use message-digest authentication");


+			intLoopBackC.ip.ospf.authentication.addSC("null", "Use no authentication");


+		intLoopBackC.ip.ospf.addSC("authentication-key", "Authentication password (key)");


+			intLoopBackC.ip.ospf["authentication-key"].addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+			intLoopBackC.ip.ospf["authentication-key"].addSC("LINE", "The OSPF password (key)");


+		intLoopBackC.ip.ospf.addSC("cost", "Interface cost");


+			intLoopBackC.ip.ospf.cost.addSC("<1-65535>", "Cost");


+		intLoopBackC.ip.ospf.addSC("database-filter", "Filter OSPF LSA during synchronization and flooding");


+			intLoopBackC.ip.ospf["database-filter"].addSC("all", "Filter all LSA");


+				intLoopBackC.ip.ospf["database-filter"].all.addSC("out", "Outgoing LSA");


+		intLoopBackC.ip.ospf.addSC("dead-interval", "Interval after which a neighbor is declared dead");


+			intLoopBackC.ip.ospf["dead-interval"].addSC("<1-65535>", "Seconds");


+		intLoopBackC.ip.ospf.addSC("demand-circuit", "OSPF demand circuit");


+		intLoopBackC.ip.ospf.addSC("hello-interval", "Time between HELLO packets");


+			intLoopBackC.ip.ospf["hello-interval"].addSC("<1-65535>", "Seconds");


+		intLoopBackC.ip.ospf.addSC("message-digest-key", "Message digest authentication password (key)");


+			intLoopBackC.ip.ospf["message-digest-key"].addSC("<1-255>", "Key ID");


+				intLoopBackC.ip.ospf["message-digest-key"]["<1-255>"].addSC("md5", "Use MD5 algorithm");


+					intLoopBackC.ip.ospf["message-digest-key"]["<1-255>"].md5.addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+					intLoopBackC.ip.ospf["message-digest-key"]["<1-255>"].md5.addSC("LINE", "The OSPF password (key)");


+		intLoopBackC.ip.ospf.addSC("mtu-ignore", "Ignores the MTU in DBD packets");


+		intLoopBackC.ip.ospf.addSC("network", "Network type");


+			intLoopBackC.ip.ospf.network.addSC("broadcast", "Specify OSPF broadcast multi-access network");


+			intLoopBackC.ip.ospf.network.addSC("non-broadcast", "Specify OSPF NBMA network");


+			intLoopBackC.ip.ospf.network.addSC("point-to-multipoint", "Specify OSPF point-to-multipoint network");


+				intLoopBackC.ip.ospf.network["point-to-multipoint"].addSC("non-broadcast", "Specify non-broadcast point-to-mpoint network");


+			intLoopBackC.ip.ospf.network.addSC("point-to-point", "Specify OSPF point-to-point network");


+		intLoopBackC.ip.ospf.addSC("priority", "Router priority");


+			intLoopBackC.ip.ospf.priority.addSC("<0-255>", "Priority");


+		intLoopBackC.ip.ospf.addSC("retransmit-interval", "Time between retransmitting lost link state advertisements");


+			intLoopBackC.ip.ospf["retransmit-interval"].addSC("<1-65535>", "Seconds");


+		intLoopBackC.ip.ospf.addSC("transmit-delay", "Link state transmit delay");


+			intLoopBackC.ip.ospf["transmit-delay"].addSC("<1-65535>", "Seconds");


+


+	intLoopBackC.ip.addSC("pim", "PIM interface commands");


+		intLoopBackC.ip.pim.addSC("bsr-border", "Border of PIM domain");


+		intLoopBackC.ip.pim.addSC("dense-mode", "Enable PIM dense-mode operation");


+			intLoopBackC.ip.pim["dense-mode"].addSC("proxy-register", "Send proxy registers");


+				intLoopBackC.ip.pim["dense-mode"]["proxy-register"].addSC("list", "Access list");


+					intLoopBackC.ip.pim["dense-mode"]["proxy-register"].list.addSC("<100-199>", "Extended access list number");


+					intLoopBackC.ip.pim["dense-mode"]["proxy-register"].list.addSC("<2000-2699>", "Extended access list number (expanded range)");


+					intLoopBackC.ip.pim["dense-mode"]["proxy-register"].list.addSC("WORD", "IP named extended access list");


+				intLoopBackC.ip.pim["dense-mode"]["proxy-register"].addSC("route-map", "Route-map");


+					intLoopBackC.ip.pim["dense-mode"]["proxy-register"]["route-map"].addSC("WORD", "Route-map reference");


+		intLoopBackC.ip.pim.addSC("nbma-mode", "Use Non-Broadcast Multi-Access (NBMA) mode on interface");


+		intLoopBackC.ip.pim.addSC("neighbor-filter", "PIM peering filter");


+			intLoopBackC.ip.pim["neighbor-filter"].addSC("<1-99>", "Access list number");


+			intLoopBackC.ip.pim["neighbor-filter"].addSC("WORD", "IP Named Standard Access list");


+		intLoopBackC.ip.pim.addSC("query-interval", "PIM router query interval");


+			intLoopBackC.ip.pim["query-interval"].addSC("<0-65535>", "Query interval in seconds");


+		intLoopBackC.ip.pim.addSC("sparse-dense-mode", "Enable PIM sparse-dense-mode operation");


+		intLoopBackC.ip.pim.addSC("sparse-mode", "Enable PIM sparse-mode operation");


+		intLoopBackC.ip.pim.addSC("version", "PIM version");


+			intLoopBackC.ip.pim.version.addSC("<1-2>", "version number");


+	intLoopBackC.ip.addSC("probe", "Enable HP Probe support");


+		intLoopBackC.ip.probe.addSC("proxy", "Proxy support");


+


+	intLoopBackC.ip.addSC("rip", "Router Information Protocol");


+		intLoopBackC.ip.rip.addSC("authentication", "Authentication control");


+			intLoopBackC.ip.rip.authentication.addSC("key-chain", "Authentication key-chain");


+				intLoopBackC.ip.rip.authentication["key-chain"].addSC("LINE", "name of key-chain");


+			intLoopBackC.ip.rip.authentication.addSC("mode", "Authentication mode");


+				intLoopBackC.ip.rip.authentication.mode.addSC("md5", "Keyed message digest");


+				intLoopBackC.ip.rip.authentication.mode.addSC("text", "Clear text authentication");


+		intLoopBackC.ip.rip.addSC("receive", "advertisement reception");


+			intLoopBackC.ip.rip.receive.addSC("version", "version control");


+				intLoopBackC.ip.rip.receive.version.addSC("<1-1>", "RIP version 1");


+				intLoopBackC.ip.rip.receive.version.addSC("<2-2>", "RIP version 2");


+


+		intLoopBackC.ip.rip.addSC("send", "advertisement transmission");


+			intLoopBackC.ip.rip.send.addSC("version", "version control");


+				intLoopBackC.ip.rip.send.version.addSC("<1-1>", "RIP version 1");


+				intLoopBackC.ip.rip.send.version.addSC("<2-2>", "RIP version 2");


+


+


+	intLoopBackC.ip.addSC("split-horizon", "Perform split horizon");


+		intLoopBackC.ip["split-horizon"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+			intLoopBackC.ip["split-horizon"].eigrp.addSC("<1-65535>", "Autonomous system number");


+	intLoopBackC.ip.addSC("summary-address", "Perform address summarization");


+		intLoopBackC.ip["summary-address"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+			intLoopBackC.ip["summary-address"].eigrp.addSC("<1-65535>", "Autonomous system number");


+				intLoopBackC.ip["summary-address"].eigrp["<1-65535>"].addSC("A.B.C.D", "IP address");


+					intLoopBackC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"].addSC("A.B.C.D", "IP network mask");


+						intLoopBackC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-255>", "Administrative distance");


+		intLoopBackC.ip["summary-address"].addSC("rip", "Routing Information Protocol (RIP)");


+			intLoopBackC.ip["summary-address"].rip.addSC("A.B.C.D", "IP address");


+				intLoopBackC.ip["summary-address"].rip["A.B.C.D"].addSC("A.B.C.D", "IP network mask");


+	intLoopBackC.ip.addSC("tcp", "TCP header compression parameters");


+		intLoopBackC.ip.tcp.addSC("compression-connections", "Maximum number of compressed connections");


+			intLoopBackC.ip.tcp["compression-connections"].addSC("<3-256>", "Number of connections");


+		intLoopBackC.ip.tcp.addSC("header-compression", "Enable TCP header compression");


+			intLoopBackC.ip.tcp["header-compression"].addSC("passive", "Compress only for destinations which send compressed headers");


+	intLoopBackC.ip.addSC("unnumbered", "Enable IP processing without an explicit address");


+intLoopBackC.addSC("keepalive", "Enable keepalive");


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


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


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


+intLoopBackC.addSC("logging", "Configure logging for interface");


+	intLoopBackC.logging.addSC("event", "Interface events");


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


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


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


+


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


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


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


+intLoopBackC.addSC("ntp", "Configure NTP");


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


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


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


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


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


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


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


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


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


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


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


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


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


+


+


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


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


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


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


+


+


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intVlan.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intVlan.txt
new file mode 100644
index 0000000..a3daf3d
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_intVlan.txt
@@ -0,0 +1,335 @@
+intVlanC.addSC("arp", "Set arp type (arpa, probe, snap) or timeout");


+	intVlanC.arp.addSC("arpa", "Standard arp protocol");


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


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


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


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


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


+intVlanC.addSC("backup", "Modify backup parameters");


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


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


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


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


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


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


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


+		intVlanC.backup.interface.addSC("Async", "Async interface");


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


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


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


+		intVlanC.backup.interface.addSC("Dialer", "Dialer interface");


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


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


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


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


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


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


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


+		intVlanC.backup.interface.addSC("Lex", "Lex interface");


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


+		intVlanC.backup.interface.addSC("Loopback", "Loopback interface");


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


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


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


+intVlanC.addSC("bandwidth", "Set bandwidth informational parameter");


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


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


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


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


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


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


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


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


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


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


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


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


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


+intVlanC.addSC("cdp", "CDP interface subcommands");


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


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


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


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


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


+


+


+intVlanC.addSC("delay", "Specify interface throughput delay");


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


+


+intVlanC.addSC("description", "Interface specific description");


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


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


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


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


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


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


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


+


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


+	intVlanC.ip.addSC("access-group", "Specify access control for packets");


+		intVlanC.ip["access-group"].addSC("<1-199>", "IP access list (standard or extended)");


+			intVlanC.ip["access-group"]["<1-199>"].addSC("in", "inbound packets");


+			intVlanC.ip["access-group"]["<1-199>"].addSC("out", "outbound packets");


+		intVlanC.ip["access-group"].addSC("<1300-2699>", "IP expanded access list (standard or extended)");


+			intVlanC.ip["access-group"]["<1300-2699>"].addSC("in", "inbound packets");


+			intVlanC.ip["access-group"]["<1300-2699>"].addSC("out", "outbound packets");


+		intVlanC.ip["access-group"].addSC("WORD", "Access-list name");


+			intVlanC.ip["access-group"].WORD.addSC("in", "inbound packets");


+			intVlanC.ip["access-group"].WORD.addSC("out", "outbound packets");


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


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


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


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


+


+	intVlanC.ip.addSC("bgp", "BGP interface commands");


+		intVlanC.ip.bgp.addSC("fast-external-fallover", "Over-ride bgp global fast-failover whenexternal peer goes down");


+			intVlanC.ip.bgp["fast-external-fallover"].addSC("deny", "dis-allow fast fallover");


+			intVlanC.ip.bgp["fast-external-fallover"].addSC("permit", "allow fast fallover");


+	intVlanC.ip.addSC("broadcast-address", "Set the broadcast address of an interface");


+		intVlanC.ip["broadcast-address"].addSC("A.B.C.D", "IP broadcast address");


+


+


+	intVlanC.ip.addSC("cgmp", "Enable/disable CGMP");


+		intVlanC.ip.cgmp.addSC("proxy", "CGMP for hosts and proxy for multicast routers");


+		intVlanC.ip.cgmp.addSC("router-only", "CGMP proxy for multicast routers only");


+	intVlanC.ip.addSC("hello-interval", "Configures IP-EIGRP hello interval");


+		intVlanC.ip["hello-interval"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+			intVlanC.ip["hello-interval"].eigrp.addSC("<1-65535>", "Autonomous system number");


+				intVlanC.ip["hello-interval"].eigrp["<1-65535>"].addSC("<1-65535>", "Seconds between hello transmissions");


+


+	intVlanC.ip.addSC("igmp", "IGMP interface commands");


+		intVlanC.ip.igmp.addSC("access-group", "IGMP group access group");


+			intVlanC.ip.igmp["access-group"].addSC("<1-99>", "Access list number");


+			intVlanC.ip.igmp["access-group"].addSC("WORD", "IP Named Standard Access list");


+		intVlanC.ip.igmp.addSC("helper-address", "IGMP helper address");


+			intVlanC.ip.igmp["helper-address"].addSC("A.B.C.D", "IGMP helper address");


+			intVlanC.ip.igmp["helper-address"].addSC("udl", "Unidirectional link to forward the report");


+


+	intVlanC.ip.addSC("multicast", "IP multicast interface commands");


+		intVlanC.ip.multicast.addSC("helper-map", "Broadcast to Multicast map OR Multicast to Broadcast map");


+			intVlanC.ip.multicast["helper-map"].addSC("A.B.C.D", "IP multicast address");


+				intVlanC.ip.multicast["helper-map"]["A.B.C.D"].addSC("A.B.C.D", "IP multicast address or IP broadcast address");


+					intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("<100-199>", "access-list");


+					intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("<2000-2699>", "access-list (expanded range)");


+					intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].addSC("WORD", "IP Named Extended Access list");


+			intVlanC.ip.multicast["helper-map"].addSC("broadcast", "Broadcast address");


+				intVlanC.ip.multicast["helper-map"].broadcast.addSC("A.B.C.D", "IP multicast address or IP broadcast address");


+					intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("<100-199>", "access-list");


+					intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("<2000-2699>", "access-list (expanded range)");


+					intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"].addSC("WORD", "IP Named Extended Access list");


+


+	intVlanC.ip.addSC("ospf", "OSPF interface commands");


+		intVlanC.ip.ospf.addSC("authentication", "Enable authentication");


+			intVlanC.ip.ospf.authentication.addSC("message-digest", "Use message-digest authentication");


+			intVlanC.ip.ospf.authentication.addSC("null", "Use no authentication");


+		intVlanC.ip.ospf.addSC("authentication-key", "Authentication password (key)");


+			intVlanC.ip.ospf["authentication-key"].addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+			intVlanC.ip.ospf["authentication-key"].addSC("LINE", "The OSPF password (key)");


+		intVlanC.ip.ospf.addSC("cost", "Interface cost");


+			intVlanC.ip.ospf.cost.addSC("<1-65535>", "Cost");


+		intVlanC.ip.ospf.addSC("database-filter", "Filter OSPF LSA during synchronization and flooding");


+			intVlanC.ip.ospf["database-filter"].addSC("all", "Filter all LSA");


+				intVlanC.ip.ospf["database-filter"].all.addSC("out", "Outgoing LSA");


+		intVlanC.ip.ospf.addSC("dead-interval", "Interval after which a neighbor is declared dead");


+			intVlanC.ip.ospf["dead-interval"].addSC("<1-65535>", "Seconds");


+		intVlanC.ip.ospf.addSC("demand-circuit", "OSPF demand circuit");


+		intVlanC.ip.ospf.addSC("hello-interval", "Time between HELLO packets");


+			intVlanC.ip.ospf["hello-interval"].addSC("<1-65535>", "Seconds");


+		intVlanC.ip.ospf.addSC("message-digest-key", "Message digest authentication password (key)");


+			intVlanC.ip.ospf["message-digest-key"].addSC("<1-255>", "Key ID");


+				intVlanC.ip.ospf["message-digest-key"]["<1-255>"].addSC("md5", "Use MD5 algorithm");


+					intVlanC.ip.ospf["message-digest-key"]["<1-255>"].md5.addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+					intVlanC.ip.ospf["message-digest-key"]["<1-255>"].md5.addSC("LINE", "The OSPF password (key)");


+		intVlanC.ip.ospf.addSC("mtu-ignore", "Ignores the MTU in DBD packets");


+		intVlanC.ip.ospf.addSC("network", "Network type");


+			intVlanC.ip.ospf.network.addSC("broadcast", "Specify OSPF broadcast multi-access network");


+			intVlanC.ip.ospf.network.addSC("non-broadcast", "Specify OSPF NBMA network");


+			intVlanC.ip.ospf.network.addSC("point-to-multipoint", "Specify OSPF point-to-multipoint network");


+				intVlanC.ip.ospf.network["point-to-multipoint"].addSC("non-broadcast", "Specify non-broadcast point-to-mpoint network");


+			intVlanC.ip.ospf.network.addSC("point-to-point", "Specify OSPF point-to-point network");


+		intVlanC.ip.ospf.addSC("priority", "Router priority");


+			intVlanC.ip.ospf.priority.addSC("<0-255>", "Priority");


+		intVlanC.ip.ospf.addSC("retransmit-interval", "Time between retransmitting lost link state advertisements");


+			intVlanC.ip.ospf["retransmit-interval"].addSC("<1-65535>", "Seconds");


+		intVlanC.ip.ospf.addSC("transmit-delay", "Link state transmit delay");


+			intVlanC.ip.ospf["transmit-delay"].addSC("<1-65535>", "Seconds");


+


+


+	intVlanC.ip.addSC("rip", "Router Information Protocol");


+		intVlanC.ip.rip.addSC("authentication", "Authentication control");


+			intVlanC.ip.rip.authentication.addSC("key-chain", "Authentication key-chain");


+				intVlanC.ip.rip.authentication["key-chain"].addSC("LINE", "name of key-chain");


+			intVlanC.ip.rip.authentication.addSC("mode", "Authentication mode");


+				intVlanC.ip.rip.authentication.mode.addSC("md5", "Keyed message digest");


+				intVlanC.ip.rip.authentication.mode.addSC("text", "Clear text authentication");


+		intVlanC.ip.rip.addSC("receive", "advertisement reception");


+			intVlanC.ip.rip.receive.addSC("version", "version control");


+				intVlanC.ip.rip.receive.version.addSC("<1-1>", "RIP version 1");


+				intVlanC.ip.rip.receive.version.addSC("<2-2>", "RIP version 2");


+					intVlanC.ip.rip.addSC("send", "advertisement transmission");


+			intVlanC.ip.rip.send.addSC("version", "version control");


+				intVlanC.ip.rip.send.version.addSC("<1-1>", "RIP version 1");


+				intVlanC.ip.rip.send.version.addSC("<2-2>", "RIP version 2");


+


+


+	intVlanC.ip.addSC("split-horizon", "Perform split horizon");


+		intVlanC.ip["split-horizon"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+			intVlanC.ip["split-horizon"].eigrp.addSC("<1-65535>", "Autonomous system number");


+	intVlanC.ip.addSC("summary-address", "Perform address summarization");


+		intVlanC.ip["summary-address"].addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+			intVlanC.ip["summary-address"].eigrp.addSC("<1-65535>", "Autonomous system number");


+				intVlanC.ip["summary-address"].eigrp["<1-65535>"].addSC("A.B.C.D", "IP address");


+					intVlanC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"].addSC("A.B.C.D", "IP network mask");


+						intVlanC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-255>", "Administrative distance");


+		intVlanC.ip["summary-address"].addSC("rip", "Routing Information Protocol (RIP)");


+			intVlanC.ip["summary-address"].rip.addSC("A.B.C.D", "IP address");


+				intVlanC.ip["summary-address"].rip["A.B.C.D"].addSC("A.B.C.D", "IP network mask");


+	intVlanC.ip.addSC("tcp", "TCP header compression parameters");


+		intVlanC.ip.tcp.addSC("compression-connections", "Maximum number of compressed connections");


+			intVlanC.ip.tcp["compression-connections"].addSC("<3-256>", "Number of connections");


+		intVlanC.ip.tcp.addSC("header-compression", "Enable TCP header compression");


+			intVlanC.ip.tcp["header-compression"].addSC("passive", "Compress only for destinations which send compressed headers");


+	intVlanC.ip.addSC("unnumbered", "Enable IP processing without an explicit address");


+


+


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


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


+intVlanC.addSC("logging", "Configure logging for interface");


+	intVlanC.logging.addSC("event", "Interface events");


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


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


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


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


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


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


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


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


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


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


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


+	intVlanC.no.addSC("backup", "Modify backup parameters");


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


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


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


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


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


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


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


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


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


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


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


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


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


+	intVlanC.no.addSC("description", "Interface specific description");


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


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


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


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


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


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


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


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


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


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


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


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


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


+intVlanC.addSC("ntp", "Configure NTP");


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


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


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


+intVlanC.addSC("private-vlan", "Configure private VLAN SVI interface settings");


+	intVlanC["private-vlan"].addSC("mapping", "Set the private VLAN SVI interface mapping");


+		intVlanC["private-vlan"].mapping.addSC("WORD", "Secondary VLAN IDs of the private VLAN SVI interface mapping");


+		intVlanC["private-vlan"].mapping.addSC("add", "Add a VLAN to private VLAN list");


+		intVlanC["private-vlan"].mapping.addSC("remove", "Remove a VLAN from private VLAN list");


+intVlanC.addSC("qos", "QoS configuration");


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


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


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


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


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


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


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


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


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


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


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


+		intVlanC["rate-limit"].output.addSC("qos-group", "Match qos-group ID");intVlanC.addSC("rmon", "Configure Remote Monitoring on an interface");


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


+		intVlanC.rmon.collection.addSC("history", "Configure history");


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


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


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


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


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


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


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


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


+


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


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


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


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


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


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


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


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


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


+intVlanC.addSC("standby", "Hot standby interface subcommands");


+	intVlanC.standby.addSC("<0-255>", "group number");


+	intVlanC.standby.addSC("authentication", "Authentication string");


+		intVlanC.standby.authentication.addSC("WORD", "authentication string");


+	intVlanC.standby.addSC("ip", "Enable hot standby protocol for IP");


+		intVlanC.standby.ip.addSC("A.B.C.D", "Hot standby IP address");


+			intVlanC.standby.ip["A.B.C.D"].addSC("secondary", "Specify an additional Hot standby IP address");


+	intVlanC.standby.addSC("mac-address", "Specify virtual MAC address for the virtual router");


+		intVlanC.standby["mac-address"].addSC("H.H.H", "Standby MAC address");


+	intVlanC.standby.addSC("mac-refresh", "Refresh MAC cache on switch by periodically sendingpacket from virtual mac address");


+		intVlanC.standby["mac-refresh"].addSC("<0-255>", "Interval to refresh MAC cache");


+	intVlanC.standby.addSC("name", "Name string");


+		intVlanC.standby.name.addSC("WORD", "name string");


+


+intVlanC.standby.addSC("priority", "Priority level");


+		intVlanC.standby.priority.addSC("<0-255>", "Priority value");


+			intVlanC.standby.priority["<0-255>"].addSC("preempt", "Overthrow lower priority designated routers");


+				intVlanC.standby.priority["<0-255>"].preempt.addSC("delay", "Wait before preempting");


+					intVlanC.standby.priority["<0-255>"].preempt.delay.addSC("<0-3600>", "Number of seconds to delay");


+					intVlanC.standby.priority["<0-255>"].preempt.delay.addSC("minimum", "Delay at least this long");


+						intVlanC.standby.priority["<0-255>"].preempt.delay.minimum.addSC("<0-3600>", "Number of seconds for minimum delay");


+							intVlanC.standby.priority["<0-255>"].preempt.delay.minimum["<0-3600>"].addSC("<0-3600>", "Number of seconds to delay");


+					intVlanC.standby.priority["<0-255>"].preempt.delay.addSC("sync", "Wait before sync to complete");


+						intVlanC.standby.priority["<0-255>"].preempt.delay.sync.addSC("<0-3600>", "Number of seconds for sync delay");


+							intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].addSC("<0-3600>", "Number of seconds to delay");


+							intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].addSC("minimum", "Delay at least this long");


+								intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].minimum.addSC("<0-3600>", "Number of seconds for minimum delay");


+									intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].minimum["<0-3600>"].addSC("<0-3600>", "Number of seconds to delay");


+	intVlanC.standby.addSC("timers", "Hot standby timers");


+		intVlanC.standby.timers.addSC("<1-255>", "Hello interval in seconds");


+			intVlanC.standby.timers["<1-255>"].addSC("<1-255>", "Holdtime in seconds");


+				intVlanC.standby.timers["<1-255>"]["<1-255>"].addSC("advertise", "Advertisement interval in seconds");


+					intVlanC.standby.timers["<1-255>"]["<1-255>"].advertise.addSC("<1-255>", "Advertisement interval in seconds");


+			intVlanC.standby.timers["<1-255>"].addSC("msec", "specify holdtime in milliseconds");


+				intVlanC.standby.timers["<1-255>"].msec.addSC("<20-1000>", "Holdtime in milliseconds");


+					intVlanC.standby.timers["<1-255>"].msec["<20-1000>"].addSC("advertise", "Advertisement interval in seconds");


+						intVlanC.standby.timers["<1-255>"].msec["<20-1000>"].advertise.addSC("<1-255>", "Advertisement interval in seconds");


+		intVlanC.standby.timers.addSC("msec", "specify hellotime in milliseconds");


+			intVlanC.standby.timers.msec.addSC("<20-1000>", "Hello interval in milliseconds");


+				intVlanC.standby.timers.msec["<20-1000>"].addSC("<1-255>", "Holdtime in seconds");


+					intVlanC.standby.timers.msec["<20-1000>"]["<1-255>"].addSC("advertise", "Advertisement interval in seconds");


+						intVlanC.standby.timers.msec["<20-1000>"]["<1-255>"].advertise.addSC("<1-255>", "Advertisement interval in seconds");


+				intVlanC.standby.timers.msec["<20-1000>"].addSC("msec", "specify holdtime in milliseconds");


+					intVlanC.standby.timers.msec["<20-1000>"].msec.addSC("<20-1000>", "Holdtime in milliseconds");


+						intVlanC.standby.timers.msec["<20-1000>"].msec["<20-1000>"].addSC("advertise", "Advertisement interval in seconds");


+							intVlanC.standby.timers.msec["<20-1000>"].msec["<20-1000>"].advertise.addSC("<1-255>", "Advertisement interval in seconds");


+


+


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


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


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


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


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


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


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


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


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_lineaux.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_lineaux.txt
new file mode 100644
index 0000000..83cc353
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_lineaux.txt
@@ -0,0 +1,291 @@
+// Commands


+


+// absolute-timeout


+// NOT IMPLEMENTED


+lineauxC.addSC("absolute-timeout", "Set absolute timeout for line disconnection");


+


+// access-class


+// NOT IMPLEMENTED


+lineauxC.addSC("access-class", "Filter connections based on an IP access list");


+


+// activation-character


+// NOT IMPLEMENTED


+lineauxC.addSC("activation-character", "Define the activation character");


+


+// arap


+// NOT IMPLEMENTED


+lineauxC.addSC("arap", "Appletalk Remote Access Protocol");


+


+// autocommand


+// NOT IMPLEMENTED


+lineauxC.addSC("autocommand", "Automatically execute an EXEC command");


+


+// autohangup


+// NOT IMPLEMENTED


+lineauxC.addSC("autohangup", "Automatically hangup when last connection closes");


+


+// autoselect


+// NOT IMPLEMENTED


+lineauxC.addSC("autoselect", "Set line to autoselect");


+


+// data-character-bits


+// NOT IMPLEMENTED


+lineauxC.addSC("data-character-bits", "Size of characters being handled");


+


+// databits


+// NOT IMPLEMENTED


+lineauxC.addSC("databits", "Set number of data bits per character");


+


+// default


+// NOT IMPLEMENTED


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


+


+// disconnect-character


+// NOT IMPLEMENTED


+lineauxC.addSC("disconnect-character", "Define the disconnect character");


+


+// dispatch-character


+// NOT IMPLEMENTED


+lineauxC.addSC("dispatch-character", "Define the dispatch character");


+


+// dispatch-machine


+// NOT IMPLEMENTED


+lineauxC.addSC("dispatch-machine", "Reference a TCP dispatch state machine");


+


+// dispatch-timeout


+// NOT IMPLEMENTED


+lineauxC.addSC("dispatch-timeout", "Set the dispatch timer");


+


+// domain-lookup


+// NOT IMPLEMENTED


+lineauxC.addSC("domain-lookup", "Enable domain lookups in show commands");


+


+// editing


+// NOT IMPLEMENTED


+lineauxC.addSC("editing", "Enable command line editing");


+


+// escape-character


+// NOT IMPLEMENTED


+lineauxC.addSC("escape-character", "Change the current line's escape character");


+


+// exec


+// NOT IMPLEMENTED


+lineauxC.addSC("exec", "Start an EXEC process");


+


+// exec-banner


+// NOT IMPLEMENTED


+lineauxC.addSC("exec-banner", "Enable the display of the EXEC banner");


+


+// exec-character-bits


+// NOT IMPLEMENTED


+lineauxC.addSC("exec-character-bits", "Size of characters to the command exec");


+


+// exec-timeout


+// NOT IMPLEMENTED


+lineauxC.addSC("exec-timeout", "Set the EXEC timeout");


+


+// exit


+lineauxC.addSC("exit","Exit from line-aux configuration mode");


+


+// flowcontrol


+// NOT IMPLEMENTED


+lineauxC.addSC("flowcontrol", "Set the flow control");


+


+// flush-at-activation


+// NOT IMPLEMENTED


+lineauxC.addSC("flush-at-activation", "Clear input stream at activation");


+


+// full-help


+// NOT IMPLEMENTED


+lineauxC.addSC("full-help", "Provide help to unprivileged user");


+


+// help


+// NOT IMPLEMENTED


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


+


+// history


+// NOT IMPLEMENTED


+lineauxC.addSC("history", "Enable and control the command history function");


+


+// hold-character


+// NOT IMPLEMENTED


+lineauxC.addSC("hold-character", "Define the hold character");


+


+// insecure


+// NOT IMPLEMENTED


+lineauxC.addSC("insecure", "Mark line as 'insecure' for LAT");


+


+// international


+// NOT IMPLEMENTED


+lineauxC.addSC("international", "Enable international 8-bit character support");


+


+// ip


+// NOT IMPLEMENTED


+lineauxC.addSC("ip", "IP options");


+


+// length


+// NOT IMPLEMENTED


+//lineauxC.addSC("length", "Set number of lines on a screen");


+


+// location


+// NOT IMPLEMENTED


+lineauxC.addSC("location", "Enter terminal location description");


+


+// lockable


+// NOT IMPLEMENTED


+lineauxC.addSC("lockable", "Allow users to lock a line");


+


+// logging


+// NOT IMPLEMENTED


+lineauxC.addSC("logging", "Modify message logging facilities");


+


+// login 


+lineauxC.addSC("login", "Enable password checking");


+	lineauxC.login.addSC("local", "Local password checking");


+	lineauxC.login.addSC("tacacs","Use tacacs server for password checking");


+


+


+// logout-warning


+// NOT IMPLEMENTED


+lineauxC.addSC("logout-warning", "Set Warning countdown for absolute timeout of    line");


+


+// modem


+// NOT IMPLEMENTED


+lineauxC.addSC("modem", "Configure the Modem Control Lines");


+


+// monitor


+// NOT IMPLEMENTED


+lineauxC.addSC("monitor", "Copy debug output to the current terminal line");


+


+// motd-banner


+// NOT IMPLEMENTED


+lineauxC.addSC("motd-banner", "Enable the display of the MOTD banner");


+


+// no


+// NOT IMPLEMENTED


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


+


+// notify


+// NOT IMPLEMENTED


+lineauxC.addSC("notify", "Inform users of output from concurrent sessions");


+


+// ntp


+// NOT IMPLEMENTED


+lineauxC.addSC("ntp", "Configure NTP");


+


+// padding


+// NOT IMPLEMENTED


+lineauxC.addSC("padding", "Set padding for a specified output character");


+


+// parity


+// NOT IMPLEMENTED


+lineauxC.addSC("parity", "Set terminal parity");


+


+// password


+lineauxC.addSC("password", "Set a password");


+	lineauxC.password.addSC("LINE", "The UNENCRYPTED (cleartext) line password", true);


+


+// private


+// NOT IMPLEMENTED


+lineauxC.addSC("private", "Configuration options that user can set will remain in effect between terminal sessions");


+


+// privilege


+// NOT IMPLEMENTED


+lineauxC.addSC("privilege", "Change privilege level for line");


+


+// refuse-message


+// NOT IMPLEMENTED


+lineauxC.addSC("refuse-message", "Define a refuse banner");


+


+// rotary


+// NOT IMPLEMENTED


+lineauxC.addSC("rotary", "Add line to a rotary group");


+


+// rxspeed


+// NOT IMPLEMENTED


+lineauxC.addSC("rxspeed", "Set the receive speed");


+


+// script


+// NOT IMPLEMENTED


+lineauxC.addSC("script", "specify event related chat scripts to run on the line");


+


+// session-disconnect-warning


+// NOT IMPLEMENTED


+lineauxC.addSC("session-disconnect-warning", "Set warning countdown for session-timeout");


+


+// session-limit


+// NOT IMPLEMENTED


+lineauxC.addSC("session-limit", "Set maximum number of sessions");


+


+// session-timeout


+// NOT IMPLEMENTED


+lineauxC.addSC("session-timeout", "Set interval for closing connection when there is no input traffic");


+


+// special-character-bits


+// NOT IMPLEMENTED


+lineauxC.addSC("special-character-bits", "Size of the escape (and other special) characters");


+


+// speed


+// NOT IMPLEMENTED


+lineauxC.addSC("speed", "Set the transmit and receive speeds");


+


+// start-character


+// NOT IMPLEMENTED


+lineauxC.addSC("start-character", "Define the start character");


+


+// stop-character


+// NOT IMPLEMENTED


+lineauxC.addSC("stop-character", "Define the stop character");


+


+// stopbits


+// NOT IMPLEMENTED


+lineauxC.addSC("stopbits", "Set async line stop bits");


+


+// telnet


+lineauxC.addSC("telnet", "Telnet protocol-specific configuration");


+


+	// telnet ip address


+//	lineauxC.telnet.addSC("WORD", "Telnet destination address or hostname", true);


+


+// terminal-type


+// NOT IMPLEMENTED


+lineauxC.addSC("terminal-type", "Set the terminal type");


+


+// timeout


+// NOT IMPLEMENTED


+lineauxC.addSC("timeout", "Timeouts for the line");


+


+// transport


+// NOT IMPLEMENTED


+lineauxC.addSC("transport", "Define transport protocols for line");


+


+// txspeed


+// NOT IMPLEMENTED


+lineauxC.addSC("txspeed", "Set the transmit speeds");


+


+// vacant-message


+// NOT IMPLEMENTED


+lineauxC.addSC("vacant-message", "Define a vacant banner");


+


+// width


+// NOT IMPLEMENTED


+lineauxC.addSC("width", "Set width of the display terminal");


+


+// x25


+// NOT IMPLEMENTED


+lineauxC.addSC("x25", "X25 protocol-specific configuration");


+


+


+


+// ********************


+


+commands_copyCommand("lineauxC","lineauxC.no",null,true);


+


+commands_deleteSubCommand("lineauxC.no","default");


+commands_deleteSubCommand("lineauxC.no","help");


+commands_deleteSubCommand("lineauxC.no","exit");


+


+// ********************


+// WARNING: THIS GROUP OF COMMANDS MUST BE AT THE END OF THIS FILE.


+// 			ONLY "NO" COMMANDS SHOULD BE BEYOND THIS POINT.


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linecon.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linecon.txt
new file mode 100644
index 0000000..adb815d
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linecon.txt
@@ -0,0 +1,261 @@
+


+linevtyC.addSC("access-class", "Filter connections based on an IP access list");


+    linevtyC["access-class"].addSC("<1-199>", "IP access list");


+        linevtyC["access-class"]["<1-199>"].addSC("in", "Filter incoming connections");


+        linevtyC["access-class"]["<1-199>"].addSC("out", "Filter outgoing connections");


+    linevtyC["access-class"].addSC("<1300-2699>", "IP expanded access list");


+        linevtyC["access-class"]["<1300-2699>"].addSC("in", "Filter incoming connections");


+        linevtyC["access-class"]["<1300-2699>"].addSC("out", "Filter outgoing connections");


+linevtyC.addSC("autocommand", "Automatically execute an EXEC command");


+    linevtyC.autocommand.addSC("LINE", "Appropriate EXEC command");


+    linevtyC.autocommand.addSC("no-suppress-linenumber", "Display service linenumber message");


+        linevtyC.autocommand["no-suppress-linenumber"].addSC("LINE", "Appropriate EXEC command");


+linevtyC.addSC("autocommand-options", "Autocommand options");


+    linevtyC["autocommand-options"].addSC("abort-character", "Autocommand abort character");


+        linevtyC["autocommand-options"]["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+    linevtyC["autocommand-options"].addSC("delay", "Delay autocommand execution");


+        linevtyC["autocommand-options"].delay.addSC("<0-120>", "Time in seconds");


+            linevtyC["autocommand-options"].delay["<0-120>"].addSC("abort-character", "Autocommand abort character");


+                linevtyC["autocommand-options"].delay["<0-120>"]["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+    linevtyC["autocommand-options"].addSC("nohangup", "No hangup after autocommand completion");


+        linevtyC["autocommand-options"].nohangup.addSC("abort-character", "Autocommand abort character");


+            linevtyC["autocommand-options"].nohangup["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+        linevtyC["autocommand-options"].nohangup.addSC("delay", "Delay autocommand execution");


+            linevtyC["autocommand-options"].nohangup.delay.addSC("<0-120>", "Time in seconds");


+                linevtyC["autocommand-options"].nohangup.delay["<0-120>"].addSC("abort-character", "Autocommand abort character");


+linevtyC.addSC("data-character-bits", "Size of characters being handled");


+    linevtyC["data-character-bits"].addSC("<7-8>", "Bits per character");


+linevtyC.addSC("databits", "Set number of data bits per character");


+    linevtyC.databits.addSC("5", "Number of data bits");


+    linevtyC.databits.addSC("6", "");


+    linevtyC.databits.addSC("<7-7>", "");


+    linevtyC.databits.addSC("8", "");


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


+    linevtyC["default"].addSC("access-class", "Filter connections based on an IP access list");


+        linevtyC["default"]["access-class"].addSC("<1-199>", "IP access list");


+        linevtyC["default"]["access-class"].addSC("<1300-2699>", "IP expanded access list");


+        linevtyC["default"]["access-class"].addSC("in", "Filter incoming connections");


+        linevtyC["default"]["access-class"].addSC("out", "Filter outgoing connections");


+    linevtyC["default"].addSC("autocommand", "Automatically execute an EXEC command");


+    linevtyC["default"].addSC("autocommand-options", "Autocommand options");


+        linevtyC["default"]["autocommand-options"].addSC("abort-character", "Autocommand abort character");


+            linevtyC["default"]["autocommand-options"]["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+        linevtyC["default"]["autocommand-options"].addSC("delay", "Delay autocommand execution");


+            linevtyC["default"]["autocommand-options"].delay.addSC("<0-120>", "Time in seconds");


+                linevtyC["default"]["autocommand-options"].delay["<0-120>"].addSC("abort-character", "Autocommand abort character");


+        linevtyC["default"]["autocommand-options"].addSC("nohangup", "No hangup after autocommand completion");


+            linevtyC["default"]["autocommand-options"].nohangup.addSC("abort-character", "Autocommand abort character");


+                linevtyC["default"]["autocommand-options"].nohangup["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+            linevtyC["default"]["autocommand-options"].nohangup.addSC("delay", "Delay autocommand execution");


+                linevtyC["default"]["autocommand-options"].nohangup.delay.addSC("<0-120>", "Time in seconds");


+    linevtyC["default"].addSC("data-character-bits", "Size of characters being handled");


+    linevtyC["default"].addSC("databits", "Set number of data bits per character");


+linevtyC.addSC("domain-lookup", "Enable domain lookups in show commands");


+linevtyC.addSC("editing", "Enable command line editing");


+linevtyC.addSC("escape-character", "Change the current line's escape character");


+    linevtyC["escape-character"].addSC("BREAK", "Cause escape on BREAK");


+    linevtyC["escape-character"].addSC("CHAR or <0-255>", "Escape character or its ASCII decimal equivalent");


+    linevtyC["escape-character"].addSC("DEFAULT", "Use default escape character");


+    linevtyC["escape-character"].addSC("NONE", "Disable escape entirely");


+    linevtyC["escape-character"].addSC("soft", "Set the soft escape character for this line");


+        linevtyC["escape-character"].soft.addSC("BREAK", "Cause escape on BREAK");


+        linevtyC["escape-character"].soft.addSC("CHAR or <0-255>", "Escape character or its ASCII decimal equivalent");


+        linevtyC["escape-character"].soft.addSC("DEFAULT", "Use default escape character");


+        linevtyC["escape-character"].soft.addSC("NONE", "Disable escape entirely");


+linevtyC.addSC("exec", "Start an EXEC process");


+linevtyC.addSC("exec-banner", "Enable the display of the EXEC banner");


+linevtyC.addSC("exec-character-bits", "Size of characters to the command exec");


+    linevtyC["exec-character-bits"].addSC("<7-8>", "Bits per character");


+linevtyC.addSC("exec-timeout", "Set the EXEC timeout");


+    linevtyC["exec-timeout"].addSC("<0-35791>", "Timeout in minutes");


+        linevtyC["exec-timeout"]["<0-35791>"].addSC("<0-2147483>", "Timeout in seconds");


+linevtyC.addSC("exit", "Exit from line configuration mode");


+linevtyC.addSC("flowcontrol", "Set the flow control");


+    linevtyC.flowcontrol.addSC("NONE", "Set no flow control");


+        linevtyC.flowcontrol.NONE.addSC("in", "Listen to flow control from the attached device");


+        linevtyC.flowcontrol.NONE.addSC("lock", "Ignore network host requests to change flow control");


+        linevtyC.flowcontrol.NONE.addSC("out", "Send flow control information to the attached device");


+            linevtyC.flowcontrol.NONE.out.addSC("lock", "Ignore network host requests to change flow control");


+    linevtyC.flowcontrol.addSC("software", "Set software flow control");


+        linevtyC.flowcontrol.software.addSC("in", "Listen to flow control from the attached device");


+        linevtyC.flowcontrol.software.addSC("lock", "Ignore network host requests to change flow control");


+        linevtyC.flowcontrol.software.addSC("out", "Send flow control information to the attached device");


+            linevtyC.flowcontrol.software.out.addSC("lock", "Ignore network host requests to change flow control");


+linevtyC.addSC("full-help", "Provide help to unprivileged user");


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


+linevtyC.addSC("history", "Enable and control the command history function");


+    linevtyC.history.addSC("size", "Set history buffer size");


+        linevtyC.history.size.addSC("<0-256>", "Size of history buffer");


+linevtyC.addSC("international", "Enable international 8-bit character support");


+linevtyC.addSC("ip", "IP options");


+    linevtyC.ip.addSC("netmask-format", "Change display of netmasks");


+        linevtyC.ip["netmask-format"].addSC("bit-count", "Display netmask as number of significant bits");


+        linevtyC.ip["netmask-format"].addSC("decimal", "Display netmask in dotted decimal");


+        linevtyC.ip["netmask-format"].addSC("hexadecimal", "Display netmask in hexadecimal");


+    linevtyC.ip.addSC("tcp", "TCP options");


+        linevtyC.ip.tcp.addSC("input-coalesce-threshold", "Set the threshold that triggers packet coalescing (20 default)");


+            linevtyC.ip.tcp["input-coalesce-threshold"].addSC("<5-255>", "Number of packets");


+linevtyC.addSC("location", "Enter terminal location description");


+    linevtyC.location.addSC("LINE", "One text line describing the terminal's location");


+linevtyC.addSC("logging", "Modify message logging facilities");


+    linevtyC.logging.addSC("synchronous", "Synchronized message output");


+        linevtyC.logging.synchronous.addSC("level", "Severity level to output asynchronously");


+            linevtyC.logging.synchronous.level.addSC("<0-7>", "Severity level; lower number for higher severity");


+            linevtyC.logging.synchronous.level.addSC("all", "Turn off all severity level for asynchronous output");


+        linevtyC.logging.synchronous.addSC("limit", "Messages queue size");


+            linevtyC.logging.synchronous.limit.addSC("<0-2147483647>", "Number of buffers");


+linevtyC.addSC("login", "Enable password checking");


+    linevtyC.login.addSC("local", "Local password checking");


+    linevtyC.login.addSC("tacacs", "Use tacacs server for password checking");


+linevtyC.addSC("modem", "Configure the Modem Control Lines");


+    linevtyC.modem.addSC("CTS-Alarm", "Alarm device which only uses CTS for call control");


+    linevtyC.modem.addSC("DTR-active", "Leave DTR low unless line has an active incoming connection or EXEC");


+    linevtyC.modem.addSC("Dialin", "Configure line for a modern dial-in modem");


+    linevtyC.modem.addSC("Host", "Devices that expect an incoming modem call");


+    linevtyC.modem.addSC("InOut", "Configure line for incoming AND outgoing use of modem");


+    linevtyC.modem.addSC("Printer", "Devices that require DSR/CD active");


+    linevtyC.modem.addSC("answer-timeout", "Set interval between raising DTR and CTS response");


+        linevtyC.modem["answer-timeout"].addSC("<0-65535>", "Answer timeout in seconds");


+    linevtyC.modem.addSC("dtr-delay", "Set interval during which DTR is held low");


+        linevtyC.modem["dtr-delay"].addSC("<0-65535>", "DTR delay in seconds");


+linevtyC.addSC("monitor", "Copy debug output to the current terminal line");


+linevtyC.addSC("motd-banner", "Enable the display of the MOTD banner");


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


+    linevtyC.no.addSC("access-class", "Filter connections based on an IP access list");


+        linevtyC.no["access-class"].addSC("<1-199>", "IP access list");


+        linevtyC.no["access-class"].addSC("<1300-2699>", "IP expanded access list");


+        linevtyC.no["access-class"].addSC("in", "Filter incoming connections");


+        linevtyC.no["access-class"].addSC("out", "Filter outgoing connections");


+    linevtyC.no.addSC("autocommand", "Automatically execute an EXEC command");


+    linevtyC.no.addSC("autocommand-options", "Autocommand options");


+        linevtyC.no["autocommand-options"].addSC("abort-character", "Autocommand abort character");


+            linevtyC.no["autocommand-options"]["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+        linevtyC.no["autocommand-options"].addSC("delay", "Delay autocommand execution");


+            linevtyC.no["autocommand-options"].delay.addSC("<0-120>", "Time in seconds");


+                linevtyC.no["autocommand-options"].delay["<0-120>"].addSC("abort-character", "Autocommand abort character");


+        linevtyC.no["autocommand-options"].addSC("nohangup", "No hangup after autocommand completion");


+            linevtyC.no["autocommand-options"].nohangup.addSC("abort-character", "Autocommand abort character");


+                linevtyC.no["autocommand-options"].nohangup["abort-character"].addSC("CHAR or <0-255>", "Abort character or its ASCII decimal equivalent");


+            linevtyC.no["autocommand-options"].nohangup.addSC("delay", "Delay autocommand execution");


+                linevtyC.no["autocommand-options"].nohangup.delay.addSC("<0-120>", "Time in seconds");


+    linevtyC.no.addSC("data-character-bits", "Size of characters being handled");


+    linevtyC.no.addSC("databits", "Set number of data bits per character");


+    linevtyC.no.addSC("domain-lookup", "Enable domain lookups in show commands");


+    linevtyC.no.addSC("editing", "Enable command line editing");


+    linevtyC.no.addSC("escape-character", "Change the current line's escape character");


+        linevtyC.no["escape-character"].addSC("soft", "Set the soft escape character for this line");


+    linevtyC.no.addSC("exec", "Start an EXEC process");


+    linevtyC.no.addSC("exec-banner", "Enable the display of the EXEC banner");


+    linevtyC.no.addSC("exec-character-bits", "Size of characters to the command exec");


+    linevtyC.no.addSC("exec-timeout", "Set the EXEC timeout");


+    linevtyC.no.addSC("flowcontrol", "Set the flow control");


+        linevtyC.no.flowcontrol.addSC("NONE", "Set no flow control");


+            linevtyC.no.flowcontrol.NONE.addSC("in", "Listen to flow control from the attached device");


+            linevtyC.no.flowcontrol.NONE.addSC("out", "Send flow control information to the attached device");


+        linevtyC.no.flowcontrol.addSC("lock", "Ignore network host requests to change flow control");


+        linevtyC.no.flowcontrol.addSC("software", "Set software flow control");


+            linevtyC.no.flowcontrol.software.addSC("in", "Listen to flow control from the attached device");


+            linevtyC.no.flowcontrol.software.addSC("lock", "Ignore network host requests to change flow control");


+            linevtyC.no.flowcontrol.software.addSC("out", "Send flow control information to the attached device");


+                linevtyC.no.flowcontrol.software.out.addSC("lock", "Ignore network host requests to change flow control");


+    linevtyC.no.addSC("full-help", "Provide help to unprivileged user");


+    linevtyC.no.addSC("history", "Enable and control the command history function");


+        linevtyC.no.history.addSC("size", "Set history buffer size");


+    linevtyC.no.addSC("international", "Enable international 8-bit character support");


+    linevtyC.no.addSC("ip", "IP options");


+        linevtyC.no.ip.addSC("netmask-format", "Change display of netmasks");


+            linevtyC.no.ip["netmask-format"].addSC("bit-count", "Display netmask as number of significant bits");


+            linevtyC.no.ip["netmask-format"].addSC("decimal", "Display netmask in dotted decimal");


+            linevtyC.no.ip["netmask-format"].addSC("hexadecimal", "Display netmask in hexadecimal");


+        linevtyC.no.ip.addSC("tcp", "TCP options");


+            linevtyC.no.ip.tcp.addSC("input-coalesce-threshold", "Set the threshold that triggers packet coalescing (20 default)");


+//    linevtyC.no.addSC("length", "Set number of lines on a screen");


+    linevtyC.no.addSC("location", "Enter terminal location description");


+    linevtyC.no.addSC("logging", "Modify message logging facilities");


+        linevtyC.no.logging.addSC("synchronous", "Synchronized message output");


+    linevtyC.no.addSC("login", "Enable password checking");


+        linevtyC.no.login.addSC("local", "Local password checking");


+        linevtyC.no.login.addSC("tacacs", "Use tacacs server for password checking");


+    linevtyC.no.addSC("modem", "Configure the Modem Control Lines");


+        linevtyC.no.modem.addSC("CTS-Alarm", "Alarm device which only uses CTS for call control");


+        linevtyC.no.modem.addSC("DTR-active", "Leave DTR low unless line has an active incoming connection or EXEC");


+        linevtyC.no.modem.addSC("Dialin", "Configure line for a modern dial-in modem");


+        linevtyC.no.modem.addSC("Host", "Devices that expect an incoming modem call");


+        linevtyC.no.modem.addSC("InOut", "Configure line for incoming AND outgoing use of modem");


+        linevtyC.no.modem.addSC("Printer", "Devices that require DSR/CD active");


+        linevtyC.no.modem.addSC("answer-timeout", "Set interval between raising DTR and CTS response");


+        linevtyC.no.modem.addSC("dtr-delay", "Set interval during which DTR is held low");


+    linevtyC.no.addSC("monitor", "Copy debug output to the current terminal line");


+    linevtyC.no.addSC("motd-banner", "Enable the display of the MOTD banner");


+linevtyC.addSC("notify", "Inform users of output from concurrent sessions");


+linevtyC.addSC("ntp", "Configure NTP");


+    linevtyC.ntp.addSC("pps-discipline", "Use PPS pulse to discipline system clock");


+    linevtyC.ntp.addSC("refclock", "NTP Reference Clock");


+        linevtyC.ntp.refclock.addSC("telecom-solutions", "Telecom Solutions GPS");


+            linevtyC.ntp.refclock["telecom-solutions"].addSC("pps", "Pulse-per-second signal line");


+                linevtyC.ntp.refclock["telecom-solutions"].pps.addSC("none", "No PPS signal available");


+        linevtyC.ntp.refclock.addSC("trimble", "Trimble Navigation TSIP Protocol");


+            linevtyC.ntp.refclock.trimble.addSC("pps", "Pulse-per-second signal line");


+                linevtyC.ntp.refclock.trimble.pps.addSC("none", "No PPS signal available");


+linevtyC.addSC("padding", "Set padding for a specified output character");


+    linevtyC.padding.addSC("CHAR or <0-127>", "Character to be padded");


+linevtyC.addSC("parity", "Set terminal parity");


+    linevtyC.parity.addSC("even", "Even parity");


+    linevtyC.parity.addSC("mark", "Mark parity");


+    linevtyC.parity.addSC("none", "No parity");


+    linevtyC.parity.addSC("odd", "Odd parity");


+    linevtyC.parity.addSC("space", "Space parity");


+linevtyC.addSC("password", "Set a password");


+    linevtyC.password.addSC("<0-0>", "Specifies an UNENCRYPTED password will follow");


+    linevtyC.password.addSC("<7-7>", "Specifies a HIDDEN password will follow");


+        linevtyC.password["<7-7>"].addSC("WORD", "The HIDDEN line password string");


+    linevtyC.password.addSC("LINE", "The UNENCRYPTED (cleartext) line password");


+linevtyC.addSC("privilege", "Change privilege level for line");


+    linevtyC.privilege.addSC("level", "Assign default privilege level for line");


+        linevtyC.privilege.level.addSC("<0-15>", "Default privilege level for line");


+linevtyC.addSC("refuse-message", "Define a refuse banner");


+    linevtyC["refuse-message"].addSC("LINE", "c refuse-text c, where 'c' is a delimiting character");


+linevtyC.addSC("rotary", "Add line to a rotary group");


+    linevtyC.rotary.addSC("<0-100>", "Rotary group to add line to");


+linevtyC.addSC("rxspeed", "Set the receive speed");


+    linevtyC.rxspeed.addSC("<0-4294967295>", "Receive speed");


+linevtyC.addSC("session-timeout", "Set interval for closing connection when there is no input traffic");


+    linevtyC["session-timeout"].addSC("<0-35791>", "Session timeout interval in minutes");


+        linevtyC["session-timeout"]["<0-35791>"].addSC("output", "Include output traffic as well as input traffic");


+linevtyC.addSC("special-character-bits", "Size of the escape (and other special) characters");


+    linevtyC["special-character-bits"].addSC("<7-8>", "Bits per character");


+linevtyC.addSC("speed", "Set the transmit and receive speeds");


+    linevtyC.speed.addSC("<0-4294967295>", "Transmit and receive speeds");


+linevtyC.addSC("start-character", "Define the start character");


+    linevtyC["start-character"].addSC("CHAR or <0-255>", "Start character or its decimal equivalent");


+linevtyC.addSC("stop-character", "Define the stop character");


+    linevtyC["stop-character"].addSC("CHAR or <0-255>", "Stop character or its decimal equivalent");


+linevtyC.addSC("stopbits", "Set async line stop bits");


+    linevtyC.stopbits.addSC("<1-1>", "One stop bit");


+    linevtyC.stopbits.addSC("1.5", "One and one-half stop bits");


+    linevtyC.stopbits.addSC("<2-2>", "Two stop bits");


+linevtyC.addSC("terminal-type", "Set the terminal type");


+    linevtyC["terminal-type"].addSC("WORD", "Terminal type");


+linevtyC.addSC("timeout", "Timeouts for the line");


+    linevtyC.timeout.addSC("login", "Timeouts related to the login sequence");


+        linevtyC.timeout.login.addSC("response", "Timeout for any user input during login sequences");


+            linevtyC.timeout.login.response.addSC("<0-300>", "Timeout in seconds");


+linevtyC.addSC("transport", "Define transport protocols for line");


+    linevtyC.transport.addSC("input", "Define which protocols to use when connecting to the terminal server");


+        linevtyC.transport.input.addSC("all", "All protocols");


+        linevtyC.transport.input.addSC("none", "No protocols");


+        linevtyC.transport.input.addSC("telnet", "TCP/IP Telnet protocol");


+    linevtyC.transport.addSC("output", "Define which protocols to use for outgoing connections");


+        linevtyC.transport.output.addSC("all", "All protocols");


+        linevtyC.transport.output.addSC("none", "No protocols");


+        linevtyC.transport.output.addSC("telnet", "TCP/IP Telnet protocol");


+    linevtyC.transport.addSC("preferred", "Specify the preferred protocol to use");


+        linevtyC.transport.preferred.addSC("all", "All protocols");


+        linevtyC.transport.preferred.addSC("none", "No protocols");


+        linevtyC.transport.preferred.addSC("telnet", "TCP/IP Telnet protocol");


+linevtyC.addSC("txspeed", "Set the transmit speeds");


+    linevtyC.txspeed.addSC("<0-4294967295>", "Transmit speed");


+linevtyC.addSC("vacant-message", "Define a vacant banner");


+    linevtyC["vacant-message"].addSC("LINE", "c vacant-text c, where 'c' is a delimiting character");


+linevtyC.addSC("width", "Set width of the display terminal");


+    linevtyC.width.addSC("<0-512>", "Number of characters on a screen line");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linevty.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linevty.txt
new file mode 100644
index 0000000..34e6890
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_linevty.txt
@@ -0,0 +1,295 @@
+// Commands


+


+// absolute-timeout


+// NOT IMPLEMENTED


+linevtyC.addSC("absolute-timeout", "Set absolute timeout for line disconnection");


+


+// access-class


+// NOT IMPLEMENTED


+linevtyC.addSC("access-class", "Filter connections based on an IP access list");


+


+// activation-character


+// NOT IMPLEMENTED


+linevtyC.addSC("activation-character", "Define the activation character");


+


+// arap


+// NOT IMPLEMENTED


+linevtyC.addSC("arap", "Appletalk Remote Access Protocol");


+


+// autobaud


+// NOT IMPLEMENTED


+linevtyC.addSC("autobaud", "Set line to autobaud");


+


+// autocommand


+// NOT IMPLEMENTED


+linevtyC.addSC("autocommand", "Automatically execute an EXEC command");


+


+// autohangup


+// NOT IMPLEMENTED


+linevtyC.addSC("autohangup", "Automatically hangup when last connection closes");


+


+// autoselect


+// NOT IMPLEMENTED


+linevtyC.addSC("autoselect", "Set line to autoselect");


+


+// data-character-bits


+// NOT IMPLEMENTED


+linevtyC.addSC("data-character-bits", "Size of characters being handled");


+


+// databits


+// NOT IMPLEMENTED


+linevtyC.addSC("databits", "Set number of data bits per character");


+


+// default


+// NOT IMPLEMENTED


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


+


+// disconnect-character


+// NOT IMPLEMENTED


+linevtyC.addSC("disconnect-character", "Define the disconnect character");


+


+// dispatch-character


+// NOT IMPLEMENTED


+linevtyC.addSC("dispatch-character", "Define the dispatch character");


+


+// dispatch-machine


+// NOT IMPLEMENTED


+linevtyC.addSC("dispatch-machine", "Reference a TCP dispatch state machine");


+


+// dispatch-timeout


+// NOT IMPLEMENTED


+linevtyC.addSC("dispatch-timeout", "Set the dispatch timer");


+


+// domain-lookup


+// NOT IMPLEMENTED


+linevtyC.addSC("domain-lookup", "Enable domain lookups in show commands");


+


+// editing


+// NOT IMPLEMENTED


+linevtyC.addSC("editing", "Enable command line editing");


+


+// escape-character


+// NOT IMPLEMENTED


+linevtyC.addSC("escape-character", "Change the current line's escape character");


+


+// exec


+// NOT IMPLEMENTED


+linevtyC.addSC("exec", "Start an EXEC process");


+


+// exec-banner


+// NOT IMPLEMENTED


+linevtyC.addSC("exec-banner", "Enable the display of the EXEC banner");


+


+// exec-character-bits


+// NOT IMPLEMENTED


+linevtyC.addSC("exec-character-bits", "Size of characters to the command exec");


+


+// exec-timeout


+// NOT IMPLEMENTED


+linevtyC.addSC("exec-timeout", "Set the EXEC timeout");


+


+// exit


+linevtyC.addSC("exit","Exit from vty configuration mode");


+


+// flowcontrol


+// NOT IMPLEMENTED


+linevtyC.addSC("flowcontrol", "Set the flow control");


+


+// flush-at-activation


+// NOT IMPLEMENTED


+linevtyC.addSC("flush-at-activation", "Clear input stream at activation");


+


+// full-help


+// NOT IMPLEMENTED


+linevtyC.addSC("full-help", "Provide help to unprivileged user");


+


+// help


+// NOT IMPLEMENTED


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


+


+// history


+// NOT IMPLEMENTED


+linevtyC.addSC("history", "Enable and control the command history function");


+


+// hold-character


+// NOT IMPLEMENTED


+linevtyC.addSC("hold-character", "Define the hold character");


+


+// insecure


+// NOT IMPLEMENTED


+linevtyC.addSC("insecure", "Mark line as 'insecure' for LAT");


+


+// international


+// NOT IMPLEMENTED


+linevtyC.addSC("international", "Enable international 8-bit character support");


+


+// ip


+// NOT IMPLEMENTED


+linevtyC.addSC("ip", "IP options");


+


+// length


+// NOT IMPLEMENTED


+//linevtyC.addSC("length", "Set number of lines on a screen");


+


+// location


+// NOT IMPLEMENTED


+linevtyC.addSC("location", "Enter terminal location description");


+


+// lockable


+// NOT IMPLEMENTED


+linevtyC.addSC("lockable", "Allow users to lock a line");


+


+// logging


+// NOT IMPLEMENTED


+linevtyC.addSC("logging", "Modify message logging facilities");


+


+// login


+linevtyC.addSC("login", "Enable password checking");


+	linevtyC.login.addSC("local", "Local password checking");


+	linevtyC.login.addSC("tacacs","Use tacacs server for password checking");


+


+


+// logout-warning


+// NOT IMPLEMENTED


+linevtyC.addSC("logout-warning", "Set Warning countdown for absolute timeout of    line");


+


+// modem


+// NOT IMPLEMENTED


+linevtyC.addSC("modem", "Configure the Modem Control Lines");


+


+// monitor


+// NOT IMPLEMENTED


+linevtyC.addSC("monitor", "Copy debug output to the current terminal line");


+


+// motd-banner


+// NOT IMPLEMENTED


+linevtyC.addSC("motd-banner", "Enable the display of the MOTD banner");


+


+// no


+// NOT IMPLEMENTED


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


+


+// notify


+// NOT IMPLEMENTED


+linevtyC.addSC("notify", "Inform users of output from concurrent sessions");


+


+// ntp


+// NOT IMPLEMENTED


+linevtyC.addSC("ntp", "Configure NTP");


+


+// padding


+// NOT IMPLEMENTED


+linevtyC.addSC("padding", "Set padding for a specified output character");


+


+// parity


+// NOT IMPLEMENTED


+linevtyC.addSC("parity", "Set terminal parity");


+


+// password


+linevtyC.addSC("password", "Set a password");


+	linevtyC.password.addSC("LINE", "The UNENCRYPTED (cleartext) line password", true);


+


+// private


+// NOT IMPLEMENTED


+linevtyC.addSC("private", "Configuration options that user can set will remain in effect between terminal sessions");


+


+// privilege


+// NOT IMPLEMENTED


+linevtyC.addSC("privilege", "Change privilege level for line");


+


+// refuse-message


+// NOT IMPLEMENTED


+linevtyC.addSC("refuse-message", "Define a refuse banner");


+


+// rotary


+// NOT IMPLEMENTED


+linevtyC.addSC("rotary", "Add line to a rotary group");


+


+// rxspeed


+// NOT IMPLEMENTED


+linevtyC.addSC("rxspeed", "Set the receive speed");


+


+// script


+// NOT IMPLEMENTED


+linevtyC.addSC("script", "specify event related chat scripts to run on the line");


+


+// session-disconnect-warning


+// NOT IMPLEMENTED


+linevtyC.addSC("session-disconnect-warning", "Set warning countdown for session-timeout");


+


+// session-limit


+// NOT IMPLEMENTED


+linevtyC.addSC("session-limit", "Set maximum number of sessions");


+


+// session-timeout


+// NOT IMPLEMENTED


+linevtyC.addSC("session-timeout", "Set interval for closing connection when there is no input traffic");


+


+// special-character-bits


+// NOT IMPLEMENTED


+linevtyC.addSC("special-character-bits", "Size of the escape (and other special) characters");


+


+// speed


+// NOT IMPLEMENTED


+linevtyC.addSC("speed", "Set the transmit and receive speeds");


+


+// start-character


+// NOT IMPLEMENTED


+linevtyC.addSC("start-character", "Define the start character");


+


+// stop-character


+// NOT IMPLEMENTED


+linevtyC.addSC("stop-character", "Define the stop character");


+


+// stopbits


+// NOT IMPLEMENTED


+linevtyC.addSC("stopbits", "Set async line stop bits");


+


+// telnet


+linevtyC.addSC("telnet", "Telnet protocol-specific configuration");


+


+	// telnet ip address


+//	linevtyC.telnet.addSC("WORD", "Telnet destination address or hostname", true);


+


+// terminal-type


+// NOT IMPLEMENTED


+linevtyC.addSC("terminal-type", "Set the terminal type");


+


+// timeout


+// NOT IMPLEMENTED


+linevtyC.addSC("timeout", "Timeouts for the line");


+


+// transport


+// NOT IMPLEMENTED


+linevtyC.addSC("transport", "Define transport protocols for line");


+


+// txspeed


+// NOT IMPLEMENTED


+linevtyC.addSC("txspeed", "Set the transmit speeds");


+


+// vacant-message


+// NOT IMPLEMENTED


+linevtyC.addSC("vacant-message", "Define a vacant banner");


+


+// width


+// NOT IMPLEMENTED


+linevtyC.addSC("width", "Set width of the display terminal");


+


+// x25


+// NOT IMPLEMENTED


+linevtyC.addSC("x25", "X25 protocol-specific configuration");


+


+


+


+// ********************


+


+commands_copyCommand("linevtyC","linevtyC.no",null,true);


+


+commands_deleteSubCommand("linevtyC.no","default");


+commands_deleteSubCommand("linevtyC.no","help");


+commands_deleteSubCommand("linevtyC.no","exit");


+


+// ********************


+// WARNING: THIS GROUP OF COMMANDS MUST BE AT THE END OF THIS FILE.


+// 			ONLY "NO" COMMANDS SHOULD BE BEYOND THIS POINT.


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_mapClass.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_mapClass.txt
new file mode 100644
index 0000000..da1852c
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_mapClass.txt
@@ -0,0 +1,112 @@
+

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

+mapClassC.addSC("exit-class", "Exit from static map class configuration mode");

+mapClassC.addSC("frame-relay", "Configure Map parameters");

+	mapClassC["frame-relay"].addSC("adaptive-shaping", "Adaptive traffic rate adjustment, Default = none");

+		mapClassC["frame-relay"]["adaptive-shaping"].addSC("becn", "Enable rate adjustment in response to BECN");

+		mapClassC["frame-relay"]["adaptive-shaping"].addSC("foresight", "Enable rate adjustment in response to ForeSight messages");

+	mapClassC["frame-relay"].addSC("bc", "Committed burst size (Bc), Default = 56000 bits");

+		mapClassC["frame-relay"].bc.addSC("<300-16000000>", "Applied to both Incoming/Outgoing Bc, Bits");

+		mapClassC["frame-relay"].bc.addSC("in", "Incoming Bc");

+			mapClassC["frame-relay"].bc["in"].addSC("<0-16000000>", "Bits");

+		mapClassC["frame-relay"].bc.addSC("out", "Outgoing Bc");

+			mapClassC["frame-relay"].bc.out.addSC("<300-16000000>", "Bits");

+	mapClassC["frame-relay"].addSC("be", "Excess burst size (Be), Default = 0 bits");

+		mapClassC["frame-relay"].be.addSC("<0-16000000>", "Applied to both Incoming/Outgoing Be, Bits");

+		mapClassC["frame-relay"].be.addSC("in", "Incoming Be");

+			mapClassC["frame-relay"].be["in"].addSC("<0-16000000>", "Bits");

+		mapClassC["frame-relay"].be.addSC("out", "Outgoing Be");

+			mapClassC["frame-relay"].be.out.addSC("<0-16000000>", "Bits");

+	mapClassC["frame-relay"].addSC("cir", "Committed Information Rate (CIR), Default = 56000 bps");

+		mapClassC["frame-relay"].cir.addSC("<1-45000000>", "Applied to both Incoming/Outgoing CIR, Bits per second");

+		mapClassC["frame-relay"].cir.addSC("in", "Incoming CIR");

+			mapClassC["frame-relay"].cir["in"].addSC("<0-45000000>", "Bits per second");

+		mapClassC["frame-relay"].cir.addSC("out", "Outgoing CIR");

+			mapClassC["frame-relay"].cir.out.addSC("<1-45000000>", "Bits per second");

+	mapClassC["frame-relay"].addSC("congestion", "Congestion management parameters");

+		mapClassC["frame-relay"].congestion.addSC("threshold", "Congestion thresholds");

+			mapClassC["frame-relay"].congestion.threshold.addSC("de", "DE discard threshold");

+				mapClassC["frame-relay"].congestion.threshold.de.addSC("<0-100>", "DE discard threshold, percentage of maximum queue size");

+			mapClassC["frame-relay"].congestion.threshold.addSC("ecn", "ECN congestion threshold");

+				mapClassC["frame-relay"].congestion.threshold.ecn.addSC("<0-100>", "ECN threshold, percentage of maximum queue size");

+	mapClassC["frame-relay"].addSC("custom-queue-list", "VC custom queueing");

+		mapClassC["frame-relay"]["custom-queue-list"].addSC("<1-16>", "Custom queue list number");

+	mapClassC["frame-relay"].addSC("end-to-end", "Configure frame-relay end-to-end VC parameters");

+		mapClassC["frame-relay"]["end-to-end"].addSC("keepalive", "Configure frame-relay end-to-end VC keepalive parameters");

+			mapClassC["frame-relay"]["end-to-end"].keepalive.addSC("error-threshold", "End-to-end keepalive error threshold");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].addSC("recv", "Error threshold for incoming end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].recv.addSC("<1-32>", "counts");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].addSC("send", "Error threshold for outgoing end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].send.addSC("<1-32>", "counts");

+			mapClassC["frame-relay"]["end-to-end"].keepalive.addSC("event-window", "End-to-end keepalive event window");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].addSC("recv", "Event window for incoming end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].recv.addSC("<1-32>", "counts");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].addSC("send", "Event window for outgoing end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].send.addSC("<1-32>", "counts");

+			mapClassC["frame-relay"]["end-to-end"].keepalive.addSC("mode", "End-to-end keepalive mode");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.mode.addSC("bidirectional", "Set bidirectional mode");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.mode.addSC("passive-reply", "Set passive-reply mode");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.mode.addSC("reply", "Set unidirectional reply mode");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.mode.addSC("request", "Set unidirectional request mode");

+			mapClassC["frame-relay"]["end-to-end"].keepalive.addSC("success-events", "End-to-end keepalive success events");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].addSC("recv", "Success events for incoming end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].recv.addSC("<1-32>", "counts");

+				mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].addSC("send", "Success events for outgoing end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].send.addSC("<1-32>", "counts");

+			mapClassC["frame-relay"]["end-to-end"].keepalive.addSC("timer", "End-to-end keepalive timer");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.timer.addSC("recv", "Interval timer for incoming end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive.timer.recv.addSC("<1-10000>", "seconds");

+				mapClassC["frame-relay"]["end-to-end"].keepalive.timer.addSC("send", "Interval timer for outgoing end-to-end Keepalive REQUESTS");

+					mapClassC["frame-relay"]["end-to-end"].keepalive.timer.send.addSC("<1-10000>", "seconds");

+	mapClassC["frame-relay"].addSC("fair-queue", "VC fair queueing");

+		mapClassC["frame-relay"]["fair-queue"].addSC("<1-4096>", "Congestive Discard Threshold");

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

+				mapClassC["frame-relay"]["fair-queue"]["<1-4096>"]["<16-4096>"].addSC("<0-100>", "Number Reservable Conversation Queues");

+					mapClassC["frame-relay"]["fair-queue"]["<1-4096>"]["<16-4096>"]["<0-100>"].addSC("<0-4096>", "Max Buffer Size for Fair Queues");

+	mapClassC["frame-relay"].addSC("fecn-adapt", "Enable Traffic Shaping reflection of FECN as BECN");

+	mapClassC["frame-relay"].addSC("fragment", "fragmentation - Requires Frame Relay traffic-shaping to be configured at the interface level");

+		mapClassC["frame-relay"].fragment.addSC("<16-1600>", "Define fragment size");

+	mapClassC["frame-relay"].addSC("holdq", "Hold queue size for VC");

+		mapClassC["frame-relay"].holdq.addSC("<1-1024>", "Size");

+	mapClassC["frame-relay"].addSC("idle-timer", "Idle timeout for a SVC, Default = 120 sec");

+		mapClassC["frame-relay"]["idle-timer"].addSC("<0-2000000>", "Applied to both Incoming/Outgoing traffic, Seconds");

+		mapClassC["frame-relay"]["idle-timer"].addSC("in", "Idle timeout for incoming traffic");

+			mapClassC["frame-relay"]["idle-timer"]["in"].addSC("<0-2000000>", "Seconds");

+		mapClassC["frame-relay"]["idle-timer"].addSC("out", "Idle timeout for outgoing traffic");

+			mapClassC["frame-relay"]["idle-timer"].out.addSC("<0-2000000>", "Seconds");

+	mapClassC["frame-relay"].addSC("interface-queue", "PVC interface queue parameters");

+		mapClassC["frame-relay"]["interface-queue"].addSC("priority", "PVC priority");

+			mapClassC["frame-relay"]["interface-queue"].priority.addSC("high", "");

+			mapClassC["frame-relay"]["interface-queue"].priority.addSC("medium", "");

+			mapClassC["frame-relay"]["interface-queue"].priority.addSC("normal", "");

+			mapClassC["frame-relay"]["interface-queue"].priority.addSC("low", "");

+	mapClassC["frame-relay"].addSC("ip", "Assign a priority queue for RTP streams");

+		mapClassC["frame-relay"].ip.addSC("rtp", "RTP special handling");

+			mapClassC["frame-relay"].ip.rtp.addSC("priority", "Strict priority for RTP packets");

+				mapClassC["frame-relay"].ip.rtp.priority.addSC("<2000-65535>", "Lower bound of UDP destination port");

+					mapClassC["frame-relay"].ip.rtp.priority["<2000-65535>"].addSC("<0-16383>", "Range of UDP ports");

+						mapClassC["frame-relay"].ip.rtp.priority["<2000-65535>"]["<0-16383>"].addSC("<0-2000>", "Maximum allowed bandwidth in kbps");

+	mapClassC["frame-relay"].addSC("mincir", "Minimum acceptable CIR, Default = CIR/2 bps");

+		mapClassC["frame-relay"].mincir.addSC("<1000-45000000>", "Applied to both Incoming/Outgoing CIR, Bits per second");

+		mapClassC["frame-relay"].mincir.addSC("in", "Incoming minimum acceptable CIR (Frame-Relay SVC only)");

+			mapClassC["frame-relay"].mincir["in"].addSC("<1000-45000000>", "Bits per second");

+		mapClassC["frame-relay"].mincir.addSC("out", "Outgoing minimum acceptable CIR");

+			mapClassC["frame-relay"].mincir.out.addSC("<1000-45000000>", "Bits per second");

+	mapClassC["frame-relay"].addSC("priority-group", "VC priority queueing");

+		mapClassC["frame-relay"]["priority-group"].addSC("<1-16>", "Priority group number");

+	mapClassC["frame-relay"].addSC("tc", "Policing Measurement Interval (Tc)");

+		mapClassC["frame-relay"].tc.addSC("<10-10000>", "Tc, milliseconds");

+	mapClassC["frame-relay"].addSC("traffic-rate", "VC traffic rate");

+		mapClassC["frame-relay"]["traffic-rate"].addSC("<600-45000000>", "Committed Information Rate (CIR)");

+			mapClassC["frame-relay"]["traffic-rate"]["<600-45000000>"].addSC("<0-45000000>", "Peak rate (CIR + EIR)");

+	mapClassC["frame-relay"].addSC("voice", "voice options");

+		mapClassC["frame-relay"].voice.addSC("bandwidth", "Total bandwidth reserved for voice");

+			mapClassC["frame-relay"].voice.bandwidth.addSC("<8000-45000000>", "bps reserved - value should be less than or equal to cir value");

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

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

+	mapClassC.no.addSC("frame-relay", "Configure Map parameters");

+mapClassC.addSC("service-policy", "class-based service policy");

+	mapClassC["service-policy"].addSC("input", "input policy");

+		mapClassC["service-policy"].input.addSC("WORD", "policy name");

+	mapClassC["service-policy"].addSC("output", "output policy");

+		mapClassC["service-policy"].output.addSC("WORD", "policy name");

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMap.txt
new file mode 100644
index 0000000..a7fc5dd
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMap.txt
@@ -0,0 +1,92 @@
+

+policyMapC.addSC("class", "policy criteria");

+	policyMapC.class.addSC("WORD", "class-map name");

+		policyMapC.class.WORD.addSC("access-group", "Access group");

+			policyMapC.class.WORD["access-group"].addSC("<1-2699>", "Access list number");

+			policyMapC.class.WORD["access-group"].addSC("name", "Named Access List");

+				policyMapC.class.WORD["access-group"].name.addSC("WORD", "Access List name");

+		policyMapC.class.WORD.addSC("any", "Any packets");

+		policyMapC.class.WORD.addSC("destination-address", "Destination address");

+			policyMapC.class.WORD["destination-address"].addSC("mac", "MAC address");

+				policyMapC.class.WORD["destination-address"].mac.addSC("H.H.H", "MAC address");

+		policyMapC.class.WORD.addSC("dscp", "Match IP DSCP (DiffServ CodePoints)");

+			policyMapC.class.WORD.dscp.addSC("<0-63>", "Enter up to 8 DSCP values separated by white-spaces");

+		policyMapC.class.WORD.addSC("input-interface", "Select an input interface to match");

+			policyMapC.class.WORD["input-interface"].addSC("Async", "Async interface");

+				policyMapC.class.WORD["input-interface"].Async.addSC("<1-129>", "Async interface number");

+			policyMapC.class.WORD["input-interface"].addSC("BRI", "ISDN Basic Rate Interface");

+				policyMapC.class.WORD["input-interface"].BRI.addSC("<0-6>", "BRI interface number");

+			policyMapC.class.WORD["input-interface"].addSC("BVI", "Bridge-Group Virtual Interface");

+				policyMapC.class.WORD["input-interface"].BVI.addSC("<1-255>", "BVI interface number");

+			policyMapC.class.WORD["input-interface"].addSC("CTunnel", "CTunnel interface");

+				policyMapC.class.WORD["input-interface"].CTunnel.addSC("<0-2147483647>", "CTunnel interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Dialer", "Dialer interface");

+				policyMapC.class.WORD["input-interface"].Dialer.addSC("<0-799>", "Dialer interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Ethernet", "IEEE 802.3");

+				policyMapC.class.WORD["input-interface"].Ethernet.addSC("<0-6>", "Ethernet interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Group-Async", "Async Group interface");

+				policyMapC.class.WORD["input-interface"]["Group-Async"].addSC("<0-129>", "Group-Async interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Lex", "Lex interface");

+				policyMapC.class.WORD["input-interface"].Lex.addSC("<0-2147483647>", "Lex interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Loopback", "Loopback interface");

+				policyMapC.class.WORD["input-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Multilink", "Multilink-group interface");

+				policyMapC.class.WORD["input-interface"].Multilink.addSC("<1-2147483647>", "Multilink interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Null", "Null interface");

+				policyMapC.class.WORD["input-interface"].Null.addSC("<0-0>", "Null interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Serial", "Serial");

+				policyMapC.class.WORD["input-interface"].Serial.addSC("<0-6>", "Serial interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Tunnel", "Tunnel interface");

+				policyMapC.class.WORD["input-interface"].Tunnel.addSC("<0-2147483647>", "Tunnel interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Vif", "PGM Multicast Host interface");

+				policyMapC.class.WORD["input-interface"].Vif.addSC("<1-1>", "Vif interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Virtual-Template", "Virtual Template interface");

+				policyMapC.class.WORD["input-interface"]["Virtual-Template"].addSC("<1-25>", "Virtual-Template interface number");

+			policyMapC.class.WORD["input-interface"].addSC("Virtual-TokenRing", "Virtual TokenRing");

+				policyMapC.class.WORD["input-interface"]["Virtual-TokenRing"].addSC("<0-2147483647>", "Virtual-TokenRing interface number");

+		policyMapC.class.WORD.addSC("precedence", "IP precedence");

+			policyMapC.class.WORD.precedence.addSC("<0-7>", "Enter up to 4 precedence values separated by white-spaces");

+		policyMapC.class.WORD.addSC("protocol", "Protocol");

+			policyMapC.class.WORD.protocol.addSC("aarp", "AppleTalk ARP");

+			policyMapC.class.WORD.protocol.addSC("apollo", "Apollo Domain");

+			policyMapC.class.WORD.protocol.addSC("appletalk", "AppleTalk");

+			policyMapC.class.WORD.protocol.addSC("arp", "IP ARP");

+			policyMapC.class.WORD.protocol.addSC("bridge", "Bridging");

+			policyMapC.class.WORD.protocol.addSC("bstun", "Block Serial Tunnel");

+			policyMapC.class.WORD.protocol.addSC("cdp", "Cisco Discovery Protocol");

+			policyMapC.class.WORD.protocol.addSC("clns", "ISO CLNS");

+			policyMapC.class.WORD.protocol.addSC("clns_es", "ISO CLNS End System");

+			policyMapC.class.WORD.protocol.addSC("clns_is", "ISO CLNS Intermediate System");

+			policyMapC.class.WORD.protocol.addSC("cmns", "ISO CMNS");

+			policyMapC.class.WORD.protocol.addSC("compressedtcp", "Compressed TCP");

+			policyMapC.class.WORD.protocol.addSC("decnet", "DECnet");

+			policyMapC.class.WORD.protocol.addSC("decnet_node", "DECnet Node");

+			policyMapC.class.WORD.protocol.addSC("decnet_router-l1", "DECnet Router L1");

+			policyMapC.class.WORD.protocol.addSC("decnet_router-l2", "DECnet Router L2");

+			policyMapC.class.WORD.protocol.addSC("dlsw", "Data Link Switching");

+			policyMapC.class.WORD.protocol.addSC("ip", "IP");

+			policyMapC.class.WORD.protocol.addSC("ipx", "Novell IPX");

+			policyMapC.class.WORD.protocol.addSC("llc2", "llc2");

+			policyMapC.class.WORD.protocol.addSC("pad", "PAD links");

+			policyMapC.class.WORD.protocol.addSC("pppoe", "PPP over Ethernet");

+			policyMapC.class.WORD.protocol.addSC("qllc", "qllc protocol");

+			policyMapC.class.WORD.protocol.addSC("rsrb", "Remote Source-Route Bridging");

+			policyMapC.class.WORD.protocol.addSC("snapshot", "Snapshot routing support");

+			policyMapC.class.WORD.protocol.addSC("stun", "Serial Tunnel");

+			policyMapC.class.WORD.protocol.addSC("vines", "Banyan VINES");

+			policyMapC.class.WORD.protocol.addSC("xns", "Xerox Network Services");

+		policyMapC.class.WORD.addSC("qos-group", "Qos-group");

+			policyMapC.class.WORD["qos-group"].addSC("<0-99>", "Qos Group value");

+		policyMapC.class.WORD.addSC("source-address", "Source address");

+			policyMapC.class.WORD["source-address"].addSC("mac", "MAC address");

+				policyMapC.class.WORD["source-address"].mac.addSC("H.H.H", "MAC address");

+policyMapC.addSC("description", "Policy-Map description");

+	policyMapC.description.addSC("LINE", "Description of this policy-map (up to 200 characters)");

+policyMapC.addSC("exit", "Exit from QoS policy-map configuration mode");

+policyMapC.addSC("no", "Negate or set default values of a command");

+	policyMapC.no.addSC("class", "policy criteria");

+		policyMapC.no.class.addSC("WORD", "class-map name");

+	policyMapC.no.addSC("description", "Policy-Map description");

+	policyMapC.no.addSC("exit", "Exit from QoS policy-map configuration mode");

+policyMapC.addSC("rename", "Rename this policy-map");

+	policyMapC.rename.addSC("WORD", "new policy-map name");

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMapClass.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMapClass.txt
new file mode 100644
index 0000000..b49971c
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_policyMapClass.txt
@@ -0,0 +1,132 @@
+

+policyMapClassC.addSC("bandwidth", "Bandwidth");

+	policyMapClassC.bandwidth.addSC("<8-2000000>", "Kilo Bits per second");

+	policyMapClassC.bandwidth.addSC("percent", "% of Available Bandwidth");

+		policyMapClassC.bandwidth.percent.addSC("<1-100>", "Percentage");

+policyMapClassC.addSC("exit", "Exit from QoS class action configuration mode");

+policyMapClassC.addSC("no", "Negate or set default values of a command");

+	policyMapClassC.no.addSC("bandwidth", "Bandwidth");

+	policyMapClassC.no.addSC("exit", "Exit from QoS class action configuration mode");

+policyMapClassC.addSC("police", "Police");

+	policyMapClassC.police.addSC("<8000-200000000>", "Bits per second");

+		policyMapClassC.police["<8000-200000000>"].addSC("<1000-51200000>", "Normal burst bytes");

+			policyMapClassC.police["<8000-200000000>"]["<1000-51200000>"].addSC("<1000-51200000>", "Maximum burst bytes");

+		policyMapClassC.police["<8000-200000000>"].addSC("conform-action", "action when rate is less than normal burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("drop", "drop packet");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"].drop.addSC("exceed-action", "action when rate is within normal and max burst");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].drop["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("set-clp-transmit", "set atm clp and send it");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"].addSC("exceed-action", "action when rate is within normal and max burst");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"]["exceed-action"].addSC("drop", "drop packet");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"]["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"]["exceed-action"]["violate-action"].addSC("drop", "drop packet");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("set-dscp-transmit", "set dscp and send it");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"].addSC("<0-63>", "new dscp");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"].addSC("exceed-action", "action when rate is within normal and max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"]["exceed-action"].addSC("drop", "drop packet");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"]["exceed-action"].addSC("set-clp-transmit", "set atm clp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"]["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("set-mpls-exp-transmit", "set exp and send it");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"].addSC("<0-7>", "new exp");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"].addSC("exceed-action", "action when rate is within normal and max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"]["exceed-action"].addSC("drop", "drop packet");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"]["exceed-action"].addSC("set-clp-transmit", "set atm clp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"]["exceed-action"].addSC("set-dscp-transmit", "set dscp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"]["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("set-prec-transmit", "rewrite packet precedence and send it");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"].addSC("<0-7>", "new precedence");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"].addSC("exceed-action", "action when rate is within normal and max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].addSC("drop", "drop packet");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].addSC("set-clp-transmit", "set atm clp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].addSC("set-dscp-transmit", "set dscp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].addSC("set-mpls-exp-transmit", "set exp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("set-qos-transmit", "set qos-group and send it");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"].addSC("<0-99>", "new qos-group");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"].addSC("exceed-action", "action when rate is within normal and max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("drop", "drop packet");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("set-clp-transmit", "set atm clp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("set-dscp-transmit", "set dscp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("set-mpls-exp-transmit", "set exp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("set-prec-transmit", "rewrite packet precedence and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+			policyMapClassC.police["<8000-200000000>"]["conform-action"].addSC("transmit", "transmit packet");

+				policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit.addSC("exceed-action", "action when rate is within normal and max burst");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("drop", "drop packet");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("set-clp-transmit", "set atm clp and send it");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("set-dscp-transmit", "set dscp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["set-dscp-transmit"].addSC("<0-63>", "new dscp");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("set-mpls-exp-transmit", "set exp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["set-mpls-exp-transmit"].addSC("<0-7>", "new exp");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("set-prec-transmit", "rewrite packet precedence and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["set-prec-transmit"].addSC("<0-7>", "new precedence");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("set-qos-transmit", "set qos-group and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["set-qos-transmit"].addSC("<0-99>", "new qos-group");

+					policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].addSC("violate-action", "action when rate is greater than max burst");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("drop", "drop packet");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("set-clp-transmit", "set atm clp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("set-dscp-transmit", "set dscp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("set-mpls-exp-transmit", "set exp and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("set-prec-transmit", "rewrite packet precedence and send it");

+						policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["violate-action"].addSC("set-qos-transmit", "set qos-group and send it");

+policyMapClassC.addSC("priority", "Strict Scheduling Priority for this Class");

+	policyMapClassC.priority.addSC("<8-2000000>", "Kilo Bits per second");

+		policyMapClassC.priority["<8-2000000>"].addSC("<32-2000000>", "Burst in bytes");

+policyMapClassC.addSC("queue-limit", "Queue Max Threshold for Tail Drop");

+	policyMapClassC["queue-limit"].addSC("<1-512>", "Packets");

+policyMapClassC.addSC("random-detect", "Enable Random Early Detection as drop policy");

+	policyMapClassC["random-detect"].addSC("dscp", "parameters for each dscp value");

+	policyMapClassC["random-detect"].addSC("dscp-based", "Enable dscp-based WRED as drop policy");

+	policyMapClassC["random-detect"].addSC("exponential-weighting-constant", "weight for mean queue depth calculation");

+	policyMapClassC["random-detect"].addSC("prec-based", "Enable precedence-based WRED as drop policy");

+	policyMapClassC["random-detect"].addSC("precedence", "parameters for each precedence value");

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

+	policyMapClassC["service-policy"].addSC("WORD", "policy-map name");

+policyMapClassC.addSC("shape", "Traffic Shaping");

+	policyMapClassC.shape.addSC("average", "configure token bucket: CIR (bps) [Bc (bits) [Be (bits)]], send out Bc only per interval");

+	policyMapClassC.shape.addSC("max-buffers", "Set Maximum Buffer Limit");

+	policyMapClassC.shape.addSC("peak", "configure token bucket: CIR (bps) [Bc (bits) [Be (bits)]], send out Bc+Be per interval");

+policyMapClassC.addSC("set", "Set QoS values");

+	policyMapClassC.set.addSC("atm-clp", "Set ATM CLP bit to 1");

+	policyMapClassC.set.addSC("cos", "Set IEEE 802.1Q/ISL class of service/user priority");

+		policyMapClassC.set.cos.addSC("<0-7>", "cos value");

+	policyMapClassC.set.addSC("ip", "Set IP specific values");

+		policyMapClassC.set.ip.addSC("dscp", "Set IP DSCP (DiffServ CodePoint)");

+			policyMapClassC.set.ip.dscp.addSC("<0-63>", "Differentiated services codepoint value");

+			policyMapClassC.set.ip.dscp.addSC("af11", "Match packets with AF11 dscp (001010)");

+			policyMapClassC.set.ip.dscp.addSC("af12", "Match packets with AF12 dscp (001100)");

+			policyMapClassC.set.ip.dscp.addSC("af13", "Match packets with AF13 dscp (001110)");

+			policyMapClassC.set.ip.dscp.addSC("af21", "Match packets with AF21 dscp (010010)");

+			policyMapClassC.set.ip.dscp.addSC("af22", "Match packets with AF22 dscp (010100)");

+			policyMapClassC.set.ip.dscp.addSC("af23", "Match packets with AF23 dscp (010110)");

+			policyMapClassC.set.ip.dscp.addSC("af31", "Match packets with AF31 dscp (011010)");

+			policyMapClassC.set.ip.dscp.addSC("af32", "Match packets with AF32 dscp (011100)");

+			policyMapClassC.set.ip.dscp.addSC("af33", "Match packets with AF33 dscp (011110)");

+			policyMapClassC.set.ip.dscp.addSC("af41", "Match packets with AF41 dscp (100010)");

+			policyMapClassC.set.ip.dscp.addSC("af42", "Match packets with AF42 dscp (100100)");

+			policyMapClassC.set.ip.dscp.addSC("af43", "Match packets with AF43 dscp (100110)");

+			policyMapClassC.set.ip.dscp.addSC("cs1", "Match packets with CS1(precedence 1) dscp (001000)");

+			policyMapClassC.set.ip.dscp.addSC("cs2", "Match packets with CS2(precedence 2) dscp (010000)");

+			policyMapClassC.set.ip.dscp.addSC("cs3", "Match packets with CS3(precedence 3) dscp (011000)");

+			policyMapClassC.set.ip.dscp.addSC("cs4", "Match packets with CS4(precedence 4) dscp (100000)");

+			policyMapClassC.set.ip.dscp.addSC("cs5", "Match packets with CS5(precedence 5) dscp (101000)");

+			policyMapClassC.set.ip.dscp.addSC("cs6", "Match packets with CS6(precedence 6) dscp (110000)");

+			policyMapClassC.set.ip.dscp.addSC("cs7", "Match packets with CS7(precedence 7) dscp (111000)");

+			policyMapClassC.set.ip.dscp.addSC("default", "Match packets with default dscp (000000)");

+			policyMapClassC.set.ip.dscp.addSC("ef", "Match packets with EF dscp (101110)");

+		policyMapClassC.set.ip.addSC("precedence", "Set IP precedence");

+			policyMapClassC.set.ip.precedence.addSC("<0-7>", "IP precedence");

+			policyMapClassC.set.ip.precedence.addSC("<0-7>", "Precedence value");

+			policyMapClassC.set.ip.precedence.addSC("critical", "Set packets with critical precedence (5)");

+			policyMapClassC.set.ip.precedence.addSC("flash", "Set packets with flash precedence (3)");

+			policyMapClassC.set.ip.precedence.addSC("flash-override", "Set packets with flash override precedence (4)");

+			policyMapClassC.set.ip.precedence.addSC("immediate", "Set packets with immediate precedence (2)");

+			policyMapClassC.set.ip.precedence.addSC("internet", "Set packets with internetwork control precedence (6)");

+			policyMapClassC.set.ip.precedence.addSC("network", "Set packets with network control precedence (7)");

+			policyMapClassC.set.ip.precedence.addSC("priority", "Set packets with priority precedence (1)");

+			policyMapClassC.set.ip.precedence.addSC("routine", "Set packets with routine precedence (0)");

+	policyMapClassC.set.addSC("mpls", "Set MPLS specific values");

+		policyMapClassC.set.mpls.addSC("experimental", "Set Experimental value");

+			policyMapClassC.set.mpls.experimental.addSC("<0-7>", "Experimental value");

+	policyMapClassC.set.addSC("qos-group", "Set QoS Group");

+		policyMapClassC.set["qos-group"].addSC("<0-99>", "QoS Group value");

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routeMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routeMap.txt
new file mode 100644
index 0000000..0313cf1
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routeMap.txt
@@ -0,0 +1,142 @@
+


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


+routeMapC.addSC("description", "Route-map comment");


+	routeMapC.description.addSC("LINE", "Comment up to 100 characters");


+routeMapC.addSC("exit", "Exit from route-map configuration mode");


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


+routeMapC.addSC("match", "Match values from routing table");


+	


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


+	routeMapC.no.addSC("description", "Route-map comment");


+	routeMapC.no.addSC("match", "Match values from routing table");


+		


+routeMapC.addSC("set", "Set values in destination routing protocol");


+	routeMapC.set.addSC("as-path", "Prepend string for a BGP AS-path attribute");


+		routeMapC.set["as-path"].addSC("prepend", "Prepend to the as-path");


+			routeMapC.set["as-path"].prepend.addSC("<1-65535>", "AS number");


+		routeMapC.set["as-path"].addSC("tag", "Set the tag as an AS-path attribute");


+	routeMapC.set.addSC("automatic-tag", "Automatically compute TAG value");


+	routeMapC.set.addSC("comm-list", "set BGP community list (for deletion)");


+		routeMapC.set["comm-list"].addSC("<1-99>", "Community-list number (standard)");


+			routeMapC.set["comm-list"]["<1-99>"].addSC("delete", "Delete matching communities");


+		routeMapC.set["comm-list"].addSC("<100-199>", "Communitly-list number (expanded)");


+			routeMapC.set["comm-list"]["<100-199>"].addSC("delete", "Delete matching communities");


+		routeMapC.set["comm-list"].addSC("WORD", "Community-list name");


+			routeMapC.set["comm-list"].WORD.addSC("delete", "Delete matching communities");


+	routeMapC.set.addSC("community", "BGP community attribute");


+		routeMapC.set.community.addSC("<1-4294967295>", "community number");


+		routeMapC.set.community.addSC("aa:nn", "community number in aa:nn format");


+		routeMapC.set.community.addSC("additive", "Add to the existing community");


+		routeMapC.set.community.addSC("local-AS", "Do not send outside local AS (well-known community)");


+			routeMapC.set.community["local-AS"].addSC("<1-4294967295>", "community number");


+			routeMapC.set.community["local-AS"].addSC("aa:nn", "community number in aa:nn format");


+			routeMapC.set.community["local-AS"].addSC("additive", "Add to the existing community");


+		routeMapC.set.community.addSC("no-advertise", "Do not advertise to any peer (well-known community)");


+			routeMapC.set.community["no-advertise"].addSC("<1-4294967295>", "community number");


+			routeMapC.set.community["no-advertise"].addSC("aa:nn", "community number in aa:nn format");


+			routeMapC.set.community["no-advertise"].addSC("additive", "Add to the existing community");


+			routeMapC.set.community["no-advertise"].addSC("local-AS", "Do not send outside local AS (well-known community)");


+				routeMapC.set.community["no-advertise"]["local-AS"].addSC("<1-4294967295>", "community number");


+				routeMapC.set.community["no-advertise"]["local-AS"].addSC("aa:nn", "community number in aa:nn format");


+				routeMapC.set.community["no-advertise"]["local-AS"].addSC("additive", "Add to the existing community");


+		routeMapC.set.community.addSC("no-export", "Do not export to next AS (well-known community)");


+			routeMapC.set.community["no-export"].addSC("<1-4294967295>", "community number");


+			routeMapC.set.community["no-export"].addSC("aa:nn", "community number in aa:nn format");


+			routeMapC.set.community["no-export"].addSC("additive", "Add to the existing community");


+			routeMapC.set.community["no-export"].addSC("local-AS", "Do not send outside local AS (well-known community)");


+				routeMapC.set.community["no-export"]["local-AS"].addSC("<1-4294967295>", "community number");


+				routeMapC.set.community["no-export"]["local-AS"].addSC("aa:nn", "community number in aa:nn format");


+				routeMapC.set.community["no-export"]["local-AS"].addSC("additive", "Add to the existing community");


+			routeMapC.set.community["no-export"].addSC("no-advertise", "Do not advertise to any peer (well-known community)");


+				routeMapC.set.community["no-export"]["no-advertise"].addSC("<1-4294967295>", "community number");


+				routeMapC.set.community["no-export"]["no-advertise"].addSC("aa:nn", "community number in aa:nn format");


+				routeMapC.set.community["no-export"]["no-advertise"].addSC("additive", "Add to the existing community");


+				routeMapC.set.community["no-export"]["no-advertise"].addSC("local-AS", "Do not send outside local AS (well-known community)");


+					routeMapC.set.community["no-export"]["no-advertise"]["local-AS"].addSC("<1-4294967295>", "community number");


+					routeMapC.set.community["no-export"]["no-advertise"]["local-AS"].addSC("aa:nn", "community number in aa:nn format");


+					routeMapC.set.community["no-export"]["no-advertise"]["local-AS"].addSC("additive", "Add to the existing community");


+		routeMapC.set.community.addSC("none", "No community attribute");


+	routeMapC.set.addSC("dampening", "Set BGP route flap dampening parameters");


+		routeMapC.set.dampening.addSC("<1-45>", "half-life time for the penalty");


+			routeMapC.set.dampening["<1-45>"].addSC("<1-20000>", "penalty to start reusing a route");


+				routeMapC.set.dampening["<1-45>"]["<1-20000>"].addSC("<1-20000>", "penalty to start suppressing a route");


+					routeMapC.set.dampening["<1-45>"]["<1-20000>"]["<1-20000>"].addSC("<1-255>", "Maximum duration to suppress a stable route");


+	routeMapC.set.addSC("extcommunity", "BGP extended community attribute");


+		routeMapC.set.extcommunity.addSC("rt", "Route Target extended community");


+			routeMapC.set.extcommunity.rt.addSC("ASN:nn or IP-address:nn", "VPN extended community");


+		routeMapC.set.extcommunity.addSC("soo", "Site-of-Origin extended community");


+			routeMapC.set.extcommunity.soo.addSC("ASN:nn or IP-address:nn", "VPN extended community");


+	routeMapC.set.addSC("interface", "Output interface");


+		routeMapC.set.interface.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+			routeMapC.set.interface["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+		routeMapC.set.interface.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			routeMapC.set.interface.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+		routeMapC.set.interface.addSC("Loopback", "Loopback interface");


+			routeMapC.set.interface.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+		routeMapC.set.interface.addSC("Null", "Null interface");


+			routeMapC.set.interface.Null.addSC("<0-0>", "Null interface number");


+				routeMapC.set.interface.Null["<0-0>"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routeMapC.set.interface.Null["<0-0>"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routeMapC.set.interface.Null["<0-0>"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routeMapC.set.interface.Null["<0-0>"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routeMapC.set.interface.Null["<0-0>"].addSC("Loopback", "Loopback interface");


+					routeMapC.set.interface.Null["<0-0>"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+		routeMapC.set.interface.addSC("Vlan", "Catalyst Vlans");


+			routeMapC.set.interface.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routeMapC.set.interface.Vlan["<1-1001>"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routeMapC.set.interface.Vlan["<1-1001>"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routeMapC.set.interface.Vlan["<1-1001>"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routeMapC.set.interface.Vlan["<1-1001>"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routeMapC.set.interface.Vlan["<1-1001>"].addSC("Loopback", "Loopback interface");


+					routeMapC.set.interface.Vlan["<1-1001>"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routeMapC.set.interface.Vlan["<1-1001>"].addSC("Null", "Null interface");


+					routeMapC.set.interface.Vlan["<1-1001>"].Null.addSC("<0-0>", "Null interface number");


+						routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+							routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+						routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+							routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+						routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].addSC("Loopback", "Loopback interface");


+							routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+	routeMapC.set.addSC("ip", "IP specific information");


+		routeMapC.set.ip.addSC("df", "Set DF bit");


+			routeMapC.set.ip.df.addSC("<0-1>", "DF bit");


+		routeMapC.set.ip.addSC("next-hop", "Next hop address");


+			routeMapC.set.ip["next-hop"].addSC("A.B.C.D", "IP address of next hop");


+			routeMapC.set.ip["next-hop"].addSC("peer-address", "Use peer address (for BGP only)");


+			routeMapC.set.ip["next-hop"].addSC("verify-availability", "Verify if nexthop is a CDP neighbor");


+		routeMapC.set.ip.addSC("precedence", "Set precedence field");


+			


+		routeMapC.set.ip.addSC("qos-group", "Set QOS Group ID");


+			routeMapC.set.ip["qos-group"].addSC("<0-99>", "QOS Group ID");


+	routeMapC.set.addSC("level", "Where to import route");


+		routeMapC.set.level.addSC("backbone", "Import into OSPF backbone area");


+		routeMapC.set.level.addSC("level-1", "Import into a level-1 area");


+		routeMapC.set.level.addSC("level-1-2", "Import into level-1 and level-2");


+		routeMapC.set.level.addSC("level-2", "Import into level-2 sub-domain");


+		routeMapC.set.level.addSC("stub-area", "Import into OSPF NSSA area");


+	routeMapC.set.addSC("local-preference", "BGP local preference path attribute");


+		routeMapC.set["local-preference"].addSC("<0-4294967295>", "Preference value");


+	routeMapC.set.addSC("metric", "Metric value for destination routing protocol");


+		routeMapC.set.metric.addSC("+/-<metric>", "Add or subtract metric");


+		routeMapC.set.metric.addSC("<0-4294967295>", "Metric value or Bandwidth in Kbits per second");


+			routeMapC.set.metric["<0-4294967295>"].addSC("+/-<delay>", "Add or subtract delay");


+			routeMapC.set.metric["<0-4294967295>"].addSC("<1-4294967295>", "IGRP delay metric, in 10 microsecond units");


+				routeMapC.set.metric["<0-4294967295>"]["<1-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+					routeMapC.set.metric["<0-4294967295>"]["<1-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+						routeMapC.set.metric["<0-4294967295>"]["<1-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routeMapC.set.addSC("metric-type", "Type of metric for destination routing protocol");


+		routeMapC.set["metric-type"].addSC("external", "IS-IS external metric");


+		routeMapC.set["metric-type"].addSC("internal", "Use IGP metric as the MED for BGP");


+		routeMapC.set["metric-type"].addSC("type-1", "OSPF external type 1 metric");


+		routeMapC.set["metric-type"].addSC("type-2", "OSPF external type 2 metric");


+	routeMapC.set.addSC("origin", "BGP origin code");


+		routeMapC.set.origin.addSC("egp", "remote EGP");


+			routeMapC.set.origin.egp.addSC("<0-65535>", "remote AS");


+		routeMapC.set.origin.addSC("igp", "local IGP");


+		routeMapC.set.origin.addSC("incomplete", "unknown heritage");


+	routeMapC.set.addSC("tag", "Tag value for destination routing protocol");


+		routeMapC.set.tag.addSC("<0-4294967295>", "Tag value");


+	routeMapC.set.addSC("traffic-index", "BGP traffic classification number for accounting");


+		routeMapC.set["traffic-index"].addSC("<1-8>", "Bucket number");


+	routeMapC.set.addSC("weight", "BGP weight for routing table");


+		routeMapC.set.weight.addSC("<0-4294967295>", "Weight value");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerAF.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerAF.txt
new file mode 100644
index 0000000..b2f67e6
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerAF.txt
@@ -0,0 +1,393 @@
+


+routerAFC.addSC("aggregate-address", "Configure BGP aggregate entries");


+	routerAFC["aggregate-address"].addSC("A.B.C.D", "Aggregate address");


+		routerAFC["aggregate-address"]["A.B.C.D"].addSC("A.B.C.D", "Aggregate mask");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("advertise-map", "Set condition to advertise attribute");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("as-set", "Generate AS set path information");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("attribute-map", "Set attributes of aggregate");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].addSC("WORD", "Route map for parameter control");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("route-map", "Set parameters of aggregate");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].addSC("WORD", "Route map for parameter control");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("summary-only", "Filter more specific routes from updates");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("advertise-map", "Set condition to advertise attribute");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("as-set", "Generate AS set path information");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("attribute-map", "Set attributes of aggregate");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].addSC("WORD", "Route map for parameter control");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].addSC("route-map", "Set parameters of aggregate");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].addSC("WORD", "Route map for parameter control");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");


+			routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].addSC("suppress-map", "Conditionally filter more specific routes from updates");


+				routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].addSC("WORD", "Route map for suppression");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("as-set", "Generate AS set path information");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("attribute-map", "Set attributes of aggregate");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].addSC("WORD", "Route map for parameter control");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+									routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("route-map", "Set parameters of aggregate");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].addSC("WORD", "Route map for parameter control");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD.addSC("as-set", "Generate AS set path information");


+					routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.addSC("summary-only", "Filter more specific routes from updates");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("advertise-map", "Set condition to advertise attribute");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("as-set", "Generate AS set path information");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"]["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("attribute-map", "Set attributes of aggregate");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].addSC("WORD", "Route map for parameter control");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.addSC("advertise-map", "Set condition to advertise attribute");


+									routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["advertise-map"].addSC("WORD", "Route map to control attribute advertisement");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.addSC("as-set", "Generate AS set path information");


+									routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["as-set"].addSC("advertise-map", "Set condition to advertise attribute");


+						routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].addSC("route-map", "Set parameters of aggregate");


+							routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].addSC("WORD", "Route map for parameter control");


+								routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD.addSC("as-set", "Generate AS set path information");


+routerAFC.addSC("auto-summary", "Enable automatic network number summarization");


+routerAFC.addSC("bgp", "BGP specific commands");


+	routerAFC.bgp.addSC("always-compare-med", "Allow comparing MED from different neighbors");


+	routerAFC.bgp.addSC("bestpath", "Change the default bestpath selection");


+		routerAFC.bgp.bestpath.addSC("compare-routerid", "Compare router-id for identical EBGP paths");


+		routerAFC.bgp.bestpath.addSC("med", "MED attribute");


+	routerAFC.bgp.addSC("client-to-client", "Configure client to client route reflection");


+		routerAFC.bgp["client-to-client"].addSC("reflection", "reflection of routes allowed");


+	routerAFC.bgp.addSC("cluster-id", "Configure Route-Reflector Cluster-id");


+		routerAFC.bgp["cluster-id"].addSC("<1-4294967295>", "Route-Reflector Cluster-id as 32 bit quantity");


+		routerAFC.bgp["cluster-id"].addSC("A.B.C.D", "Route-Reflector Cluster-id in IP address format");


+	routerAFC.bgp.addSC("confederation", "AS confederation parameters");


+		routerAFC.bgp.confederation.addSC("identifier", "as number");


+		routerAFC.bgp.confederation.addSC("peers", "Peer ASs in BGP confederation");


+	routerAFC.bgp.addSC("dampening", "Enable route-flap dampening");


+		routerAFC.bgp.dampening.addSC("<1-45>", "Half-life time for the penalty");


+		routerAFC.bgp.dampening.addSC("route-map", "Route-map to specify criteria for dampening");


+	routerAFC.bgp.addSC("default", "Configure BGP defaults");


+		routerAFC.bgp["default"].addSC("ipv4-unicast", "Activate ipv4-unicast for a peer by default");


+		routerAFC.bgp["default"].addSC("local-preference", "local preference (higher=more preferred)");


+	routerAFC.bgp.addSC("deterministic-med", "Pick the best-MED path among paths advertised from the neighboring AS");


+	routerAFC.bgp.addSC("fast-external-fallover", "Immediately reset session if a link to a directly connected external peer goes down");


+	routerAFC.bgp.addSC("log-neighbor-changes", "Log neighbor up/down and reset reason");


+	routerAFC.bgp.addSC("redistribute-internal", "Allow redistribution of iBGP into IGPs (dangerous)");


+	routerAFC.bgp.addSC("router-id", "Override configured router identifier");


+		routerAFC.bgp["router-id"].addSC("A.B.C.D", "Manually configured router identifier");


+	routerAFC.bgp.addSC("scan-time", "Configure background scanner interval");


+		routerAFC.bgp["scan-time"].addSC("<5-60>", "Scanner interval (seconds)");


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


+	routerAFC["default"].addSC("aggregate-address", "Configure BGP aggregate entries");


+		routerAFC["default"]["aggregate-address"].addSC("A.B.C.D", "Aggregate address");


+	routerAFC["default"].addSC("auto-summary", "Enable automatic network number summarization");


+	routerAFC["default"].addSC("bgp", "BGP specific commands");


+		routerAFC["default"].bgp.addSC("always-compare-med", "Allow comparing MED from different neighbors");


+		routerAFC["default"].bgp.addSC("bestpath", "Change the default bestpath selection");


+		routerAFC["default"].bgp.addSC("client-to-client", "Configure client to client route reflection");


+		routerAFC["default"].bgp.addSC("cluster-id", "Configure Route-Reflector Cluster-id");


+		routerAFC["default"].bgp.addSC("confederation", "AS confederation parameters");


+		routerAFC["default"].bgp.addSC("dampening", "Enable route-flap dampening");


+		routerAFC["default"].bgp.addSC("default", "Configure BGP defaults");


+		routerAFC["default"].bgp.addSC("deterministic-med", "Pick the best-MED path among paths advertised from the neighboring AS");


+		routerAFC["default"].bgp.addSC("fast-external-fallover", "Immediately reset session if a link to a directly connected external peer goes down");


+		routerAFC["default"].bgp.addSC("log-neighbor-changes", "Log neighbor up/down and reset reason");


+		routerAFC["default"].bgp.addSC("redistribute-internal", "Allow redistribution of iBGP into IGPs (dangerous)");


+		routerAFC["default"].bgp.addSC("router-id", "Override configured router identifier");


+		routerAFC["default"].bgp.addSC("scan-time", "Configure background scanner interval");


+routerAFC.addSC("default-information", "Control distribution of default information");


+	routerAFC["default-information"].addSC("originate", "Distribute a default route");


+routerAFC.addSC("default-metric", "Set metric of redistributed routes");


+	routerAFC["default-metric"].addSC("<1-4294967295>", "Default metric");


+routerAFC.addSC("distance", "Define an administrative distance");


+	routerAFC.distance.addSC("<1-255>", "Administrative distance");


+		routerAFC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");


+	routerAFC.distance.addSC("bgp", "BGP distance");


+		routerAFC.distance.bgp.addSC("<1-255>", "Distance for routes external to the AS");


+routerAFC.addSC("distribute-list", "Filter networks in routing updates");


+	routerAFC["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerAFC["distribute-list"]["<1-199>"].addSC("in", "Filter incoming routing updates");


+		routerAFC["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing routing updates");


+	routerAFC["distribute-list"].addSC("<1300-2699>", "IP expanded access list number");


+		routerAFC["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming routing updates");


+		routerAFC["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing routing updates");


+	routerAFC["distribute-list"].addSC("WORD", "Access-list name");


+		routerAFC["distribute-list"].WORD.addSC("in", "Filter incoming routing updates");


+		routerAFC["distribute-list"].WORD.addSC("out", "Filter outgoing routing updates");


+	routerAFC["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerAFC["distribute-list"].gateway.addSC("WORD", "Name of an IP prefix-list");


+	routerAFC["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+		routerAFC["distribute-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+routerAFC.addSC("exit-address-family", "Exit from Address Family configuration mode");


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


+routerAFC.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerAFC["maximum-paths"].addSC("<1-8>", "Number of paths");


+routerAFC.addSC("neighbor", "Specify a neighbor router");


+	routerAFC.neighbor.addSC("A.B.C.D", "Neighbor address");


+		routerAFC.neighbor["A.B.C.D"].addSC("activate", "Enable the Address Family for this Neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("advertise-map", "specify route-map for conditional advertisement");


+			routerAFC.neighbor["A.B.C.D"]["advertise-map"].addSC("WORD", "advertise route-map name");


+				routerAFC.neighbor["A.B.C.D"]["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");


+					routerAFC.neighbor["A.B.C.D"]["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");


+		routerAFC.neighbor["A.B.C.D"].addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");


+			routerAFC.neighbor["A.B.C.D"]["advertisement-interval"].addSC("<0-600>", "time in seconds");


+		routerAFC.neighbor["A.B.C.D"].addSC("allowas-in", "Accept as-path with my AS present in it");


+			routerAFC.neighbor["A.B.C.D"]["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");


+		routerAFC.neighbor["A.B.C.D"].addSC("default-originate", "Originate default route to this neighbor");


+			routerAFC.neighbor["A.B.C.D"]["default-originate"].addSC("route-map", "Route-map to specify criteria to originate default");


+				routerAFC.neighbor["A.B.C.D"]["default-originate"]["route-map"].addSC("WORD", "route-map name");


+		routerAFC.neighbor["A.B.C.D"].addSC("description", "Neighbor specific description");


+			routerAFC.neighbor["A.B.C.D"].description.addSC("LINE", "Up to 80 characters describing this neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("distribute-list", "Filter updates to/from this neighbor");


+			routerAFC.neighbor["A.B.C.D"]["distribute-list"].addSC("<1-199>", "IP access list number");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].addSC("in", "Filter incoming updates");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing updates");


+			routerAFC.neighbor["A.B.C.D"]["distribute-list"].addSC("<1300-2699>", "IP access list number (expanded range)");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming updates");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing updates");


+			routerAFC.neighbor["A.B.C.D"]["distribute-list"].addSC("WORD", "IP Access-list name");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"].WORD.addSC("in", "Filter incoming updates");


+				routerAFC.neighbor["A.B.C.D"]["distribute-list"].WORD.addSC("out", "Filter outgoing updates");


+		routerAFC.neighbor["A.B.C.D"].addSC("ebgp-multihop", "Allow EBGP neighbors not on directly connected networks");


+			routerAFC.neighbor["A.B.C.D"]["ebgp-multihop"].addSC("<1-255>", "maximum hop count");


+		routerAFC.neighbor["A.B.C.D"].addSC("filter-list", "Establish BGP filters");


+			routerAFC.neighbor["A.B.C.D"]["filter-list"].addSC("<1-199>", "AS path access list");


+				routerAFC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].addSC("in", "Filter incoming routes");


+				routerAFC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].addSC("out", "Filter outgoing routes");


+		routerAFC.neighbor["A.B.C.D"].addSC("local-as", "Specify a local-as number");


+			routerAFC.neighbor["A.B.C.D"]["local-as"].addSC("<1-65535>", "AS number used as local AS");


+		routerAFC.neighbor["A.B.C.D"].addSC("maximum-prefix", "Maximum number of prefix accept from this peer");


+			routerAFC.neighbor["A.B.C.D"]["maximum-prefix"].addSC("<1-4294967295>", "maximum no. of prefix limit");


+				routerAFC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].addSC("<1-100>", "Threshold value (%) at which to generate a warning msg");


+				routerAFC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].addSC("warning-only", "Only give warning message when limit is exceeded");


+		routerAFC.neighbor["A.B.C.D"].addSC("next-hop-propagate", "Propagate the next hop for this neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("next-hop-self", "Disable the next hop calculation for this neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("password", "Set a password");


+			routerAFC.neighbor["A.B.C.D"].password.addSC("<0-7>", "Encryption type (0 to disable encryption, 7 for proprietary)");


+			routerAFC.neighbor["A.B.C.D"].password.addSC("LINE", "The password");


+		routerAFC.neighbor["A.B.C.D"].addSC("peer-group", "Member of the peer-group");


+			routerAFC.neighbor["A.B.C.D"]["peer-group"].addSC("WORD", "peer-group name");


+		routerAFC.neighbor["A.B.C.D"].addSC("prefix-list", "Filter updates to/from this neighbor");


+			routerAFC.neighbor["A.B.C.D"]["prefix-list"].addSC("WORD", "Name of a prefix list");


+				routerAFC.neighbor["A.B.C.D"]["prefix-list"].WORD.addSC("in", "Filter incoming updates");


+				routerAFC.neighbor["A.B.C.D"]["prefix-list"].WORD.addSC("out", "Filter outgoing updates");


+		routerAFC.neighbor["A.B.C.D"].addSC("remote-as", "Specify a BGP neighbor");


+			routerAFC.neighbor["A.B.C.D"]["remote-as"].addSC("<1-65535>", "AS of remote neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("remove-private-AS", "Remove private AS number from outbound updates");


+		routerAFC.neighbor["A.B.C.D"].addSC("route-map", "Apply route map to neighbor");


+			routerAFC.neighbor["A.B.C.D"]["route-map"].addSC("WORD", "Name of route map");


+				routerAFC.neighbor["A.B.C.D"]["route-map"].WORD.addSC("in", "Apply map to incoming routes");


+				routerAFC.neighbor["A.B.C.D"]["route-map"].WORD.addSC("out", "Apply map to outbound routes");


+		routerAFC.neighbor["A.B.C.D"].addSC("route-reflector-client", "Configure a neighbor as Route Reflector client");


+		routerAFC.neighbor["A.B.C.D"].addSC("send-community", "Send Community attribute to this neighbor");


+			routerAFC.neighbor["A.B.C.D"]["send-community"].addSC("both", "Send Standard and Extended Community attributes");


+			routerAFC.neighbor["A.B.C.D"]["send-community"].addSC("extended", "Send Extended Community attribute");


+			routerAFC.neighbor["A.B.C.D"]["send-community"].addSC("standard", "Send Standard Community attribute");


+		routerAFC.neighbor["A.B.C.D"].addSC("shutdown", "Administratively shut down this neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("soft-reconfiguration", "Per neighbor soft reconfiguration");


+			routerAFC.neighbor["A.B.C.D"]["soft-reconfiguration"].addSC("inbound", "Allow inbound soft reconfiguration for this neighbor");


+		routerAFC.neighbor["A.B.C.D"].addSC("timers", "BGP per neighbor timers");


+			routerAFC.neighbor["A.B.C.D"].timers.addSC("<1-4294967295>", "Keepalive interval");


+				routerAFC.neighbor["A.B.C.D"].timers["<1-4294967295>"].addSC("<1-4294967295>", "Holdtime");


+		routerAFC.neighbor["A.B.C.D"].addSC("unsuppress-map", "Route-map to selectively unsuppress suppressed routes");


+			routerAFC.neighbor["A.B.C.D"]["unsuppress-map"].addSC("WORD", "Name of route map");


+		routerAFC.neighbor["A.B.C.D"].addSC("update-source", "Source of routing updates");


+			routerAFC.neighbor["A.B.C.D"]["update-source"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerAFC.neighbor["A.B.C.D"]["update-source"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerAFC.neighbor["A.B.C.D"]["update-source"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerAFC.neighbor["A.B.C.D"]["update-source"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerAFC.neighbor["A.B.C.D"]["update-source"].addSC("Loopback", "Loopback interface");


+				routerAFC.neighbor["A.B.C.D"]["update-source"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerAFC.neighbor["A.B.C.D"]["update-source"].addSC("Null", "Null interface");


+				routerAFC.neighbor["A.B.C.D"]["update-source"].Null.addSC("<0-0>", "Null interface number");


+			routerAFC.neighbor["A.B.C.D"]["update-source"].addSC("Vlan", "Catalyst Vlans");


+				routerAFC.neighbor["A.B.C.D"]["update-source"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerAFC.neighbor["A.B.C.D"].addSC("version", "Set the BGP version to match a neighbor");


+			routerAFC.neighbor["A.B.C.D"].version.addSC("<4-4>", "Neighbor's BGP version");


+		routerAFC.neighbor["A.B.C.D"].addSC("weight", "Set default weight for routes from this neighbor");


+			routerAFC.neighbor["A.B.C.D"].weight.addSC("<0-65535>", "default weight");


+	routerAFC.neighbor.addSC("WORD", "Neighbor tag");


+		routerAFC.neighbor.WORD.addSC("activate", "Enable the Address Family for this Neighbor");


+		routerAFC.neighbor.WORD.addSC("advertise-map", "specify route-map for conditional advertisement");


+			routerAFC.neighbor.WORD["advertise-map"].addSC("WORD", "advertise route-map name");


+				routerAFC.neighbor.WORD["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");


+					routerAFC.neighbor.WORD["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");


+		routerAFC.neighbor.WORD.addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");


+			routerAFC.neighbor.WORD["advertisement-interval"].addSC("<0-600>", "time in seconds");


+		routerAFC.neighbor.WORD.addSC("allowas-in", "Accept as-path with my AS present in it");


+			routerAFC.neighbor.WORD["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");


+		routerAFC.neighbor.WORD.addSC("default-originate", "Originate default route to this neighbor");


+			routerAFC.neighbor.WORD["default-originate"].addSC("route-map", "Route-map to specify criteria to originate default");


+				routerAFC.neighbor.WORD["default-originate"]["route-map"].addSC("WORD", "route-map name");


+		routerAFC.neighbor.WORD.addSC("description", "Neighbor specific description");


+			routerAFC.neighbor.WORD.description.addSC("LINE", "Up to 80 characters describing this neighbor");


+		routerAFC.neighbor.WORD.addSC("distribute-list", "Filter updates to/from this neighbor");


+			routerAFC.neighbor.WORD["distribute-list"].addSC("<1-199>", "IP access list number");


+				routerAFC.neighbor.WORD["distribute-list"]["<1-199>"].addSC("in", "Filter incoming updates");


+				routerAFC.neighbor.WORD["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing updates");


+			routerAFC.neighbor.WORD["distribute-list"].addSC("<1300-2699>", "IP access list number (expanded range)");


+				routerAFC.neighbor.WORD["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming updates");


+				routerAFC.neighbor.WORD["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing updates");


+			routerAFC.neighbor.WORD["distribute-list"].addSC("WORD", "IP Access-list name");


+				routerAFC.neighbor.WORD["distribute-list"].WORD.addSC("in", "Filter incoming updates");


+				routerAFC.neighbor.WORD["distribute-list"].WORD.addSC("out", "Filter outgoing updates");


+		routerAFC.neighbor.WORD.addSC("ebgp-multihop", "Allow EBGP neighbors not on directly connected networks");


+			routerAFC.neighbor.WORD["ebgp-multihop"].addSC("<1-255>", "maximum hop count");


+		routerAFC.neighbor.WORD.addSC("filter-list", "Establish BGP filters");


+			routerAFC.neighbor.WORD["filter-list"].addSC("<1-199>", "AS path access list");


+				routerAFC.neighbor.WORD["filter-list"]["<1-199>"].addSC("in", "Filter incoming routes");


+				routerAFC.neighbor.WORD["filter-list"]["<1-199>"].addSC("out", "Filter outgoing routes");


+		routerAFC.neighbor.WORD.addSC("local-as", "Specify a local-as number");


+			routerAFC.neighbor.WORD["local-as"].addSC("<1-65535>", "AS number used as local AS");


+		routerAFC.neighbor.WORD.addSC("maximum-prefix", "Maximum number of prefix accept from this peer");


+			routerAFC.neighbor.WORD["maximum-prefix"].addSC("<1-4294967295>", "maximum no. of prefix limit");


+				routerAFC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].addSC("<1-100>", "Threshold value (%) at which to generate a warning msg");


+				routerAFC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].addSC("warning-only", "Only give warning message when limit is exceeded");


+		routerAFC.neighbor.WORD.addSC("next-hop-propagate", "Propagate the next hop for this neighbor");


+		routerAFC.neighbor.WORD.addSC("next-hop-self", "Disable the next hop calculation for this neighbor");


+		routerAFC.neighbor.WORD.addSC("password", "Set a password");


+			routerAFC.neighbor.WORD.password.addSC("<0-7>", "Encryption type (0 to disable encryption, 7 for proprietary)");


+			routerAFC.neighbor.WORD.password.addSC("LINE", "The password");


+		routerAFC.neighbor.WORD.addSC("peer-group", "Configure peer-group");


+		routerAFC.neighbor.WORD.addSC("prefix-list", "Filter updates to/from this neighbor");


+			routerAFC.neighbor.WORD["prefix-list"].addSC("WORD", "Name of a prefix list");


+				routerAFC.neighbor.WORD["prefix-list"].WORD.addSC("in", "Filter incoming updates");


+				routerAFC.neighbor.WORD["prefix-list"].WORD.addSC("out", "Filter outgoing updates");


+		routerAFC.neighbor.WORD.addSC("remote-as", "Specify a BGP neighbor");


+			routerAFC.neighbor.WORD["remote-as"].addSC("<1-65535>", "AS of remote neighbor");


+		routerAFC.neighbor.WORD.addSC("remove-private-AS", "Remove private AS number from outbound updates");


+		routerAFC.neighbor.WORD.addSC("route-map", "Apply route map to neighbor");


+			routerAFC.neighbor.WORD["route-map"].addSC("WORD", "Name of route map");


+				routerAFC.neighbor.WORD["route-map"].WORD.addSC("in", "Apply map to incoming routes");


+				routerAFC.neighbor.WORD["route-map"].WORD.addSC("out", "Apply map to outbound routes");


+		routerAFC.neighbor.WORD.addSC("route-reflector-client", "Configure a neighbor as Route Reflector client");


+		routerAFC.neighbor.WORD.addSC("send-community", "Send Community attribute to this neighbor");


+			routerAFC.neighbor.WORD["send-community"].addSC("both", "Send Standard and Extended Community attributes");


+			routerAFC.neighbor.WORD["send-community"].addSC("extended", "Send Extended Community attribute");


+			routerAFC.neighbor.WORD["send-community"].addSC("standard", "Send Standard Community attribute");


+		routerAFC.neighbor.WORD.addSC("shutdown", "Administratively shut down this neighbor");


+		routerAFC.neighbor.WORD.addSC("soft-reconfiguration", "Per neighbor soft reconfiguration");


+			routerAFC.neighbor.WORD["soft-reconfiguration"].addSC("inbound", "Allow inbound soft reconfiguration for this neighbor");


+		routerAFC.neighbor.WORD.addSC("timers", "BGP per neighbor timers");


+			routerAFC.neighbor.WORD.timers.addSC("<1-4294967295>", "Keepalive interval");


+				routerAFC.neighbor.WORD.timers["<1-4294967295>"].addSC("<1-4294967295>", "Holdtime");


+		routerAFC.neighbor.WORD.addSC("unsuppress-map", "Route-map to selectively unsuppress suppressed routes");


+			routerAFC.neighbor.WORD["unsuppress-map"].addSC("WORD", "Name of route map");


+		routerAFC.neighbor.WORD.addSC("update-source", "Source of routing updates");


+			routerAFC.neighbor.WORD["update-source"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerAFC.neighbor.WORD["update-source"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerAFC.neighbor.WORD["update-source"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerAFC.neighbor.WORD["update-source"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerAFC.neighbor.WORD["update-source"].addSC("Loopback", "Loopback interface");


+				routerAFC.neighbor.WORD["update-source"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerAFC.neighbor.WORD["update-source"].addSC("Null", "Null interface");


+				routerAFC.neighbor.WORD["update-source"].Null.addSC("<0-0>", "Null interface number");


+			routerAFC.neighbor.WORD["update-source"].addSC("Vlan", "Catalyst Vlans");


+				routerAFC.neighbor.WORD["update-source"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerAFC.neighbor.WORD.addSC("version", "Set the BGP version to match a neighbor");


+			routerAFC.neighbor.WORD.version.addSC("<4-4>", "Neighbor's BGP version");


+		routerAFC.neighbor.WORD.addSC("weight", "Set default weight for routes from this neighbor");


+			routerAFC.neighbor.WORD.weight.addSC("<0-65535>", "default weight");


+routerAFC.addSC("network", "Specify a network to announce via BGP");


+	routerAFC.network.addSC("A.B.C.D", "Network number");


+		routerAFC.network["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");


+		routerAFC.network["A.B.C.D"].addSC("mask", "Network mask");


+			routerAFC.network["A.B.C.D"].mask.addSC("A.B.C.D", "Network mask");


+				routerAFC.network["A.B.C.D"].mask["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");


+		routerAFC.network["A.B.C.D"].addSC("route-map", "Route-map to modify the attributes");


+			routerAFC.network["A.B.C.D"]["route-map"].addSC("WORD", "Name of the route map");


+				routerAFC.network["A.B.C.D"]["route-map"].WORD.addSC("backdoor", "Specify a BGP backdoor route");


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


+	routerAFC.no.addSC("aggregate-address", "Configure BGP aggregate entries");


+		routerAFC.no["aggregate-address"].addSC("A.B.C.D", "Aggregate address");


+	routerAFC.no.addSC("auto-summary", "Enable automatic network number summarization");


+	routerAFC.no.addSC("bgp", "BGP specific commands");


+		routerAFC.no.bgp.addSC("always-compare-med", "Allow comparing MED from different neighbors");


+		routerAFC.no.bgp.addSC("bestpath", "Change the default bestpath selection");


+		routerAFC.no.bgp.addSC("client-to-client", "Configure client to client route reflection");


+		routerAFC.no.bgp.addSC("cluster-id", "Configure Route-Reflector Cluster-id");


+		routerAFC.no.bgp.addSC("confederation", "AS confederation parameters");


+		routerAFC.no.bgp.addSC("dampening", "Enable route-flap dampening");


+		routerAFC.no.bgp.addSC("default", "Configure BGP defaults");


+		routerAFC.no.bgp.addSC("deterministic-med", "Pick the best-MED path among paths advertised from the neighboring AS");


+		routerAFC.no.bgp.addSC("fast-external-fallover", "Immediately reset session if a link to a directly connected external peer goes down");


+		routerAFC.no.bgp.addSC("log-neighbor-changes", "Log neighbor up/down and reset reason");


+		routerAFC.no.bgp.addSC("redistribute-internal", "Allow redistribution of iBGP into IGPs (dangerous)");


+		routerAFC.no.bgp.addSC("router-id", "Override configured router identifier");


+		routerAFC.no.bgp.addSC("scan-time", "Configure background scanner interval");


+	routerAFC.no.addSC("default-information", "Control distribution of default information");


+		routerAFC.no["default-information"].addSC("originate", "Distribute a default route");


+	routerAFC.no.addSC("default-metric", "Set metric of redistributed routes");


+	routerAFC.no.addSC("distance", "Define an administrative distance");


+		routerAFC.no.distance.addSC("<1-255>", "Administrative distance");


+		routerAFC.no.distance.addSC("bgp", "BGP distance");


+	routerAFC.no.addSC("distribute-list", "Filter networks in routing updates");


+		routerAFC.no["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerAFC.no["distribute-list"].addSC("<1300-2699>", "IP expanded access list number");


+		routerAFC.no["distribute-list"].addSC("WORD", "Access-list name");


+		routerAFC.no["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerAFC.no["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+	routerAFC.no.addSC("help", "Description of the interactive help system");


+	routerAFC.no.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerAFC.no.addSC("neighbor", "Specify a neighbor router");


+		routerAFC.no.neighbor.addSC("A.B.C.D", "Neighbor address");


+		routerAFC.no.neighbor.addSC("WORD", "Neighbor tag");


+	routerAFC.no.addSC("network", "Specify a network to announce via BGP");


+		routerAFC.no.network.addSC("A.B.C.D", "Network number");


+routerAFC.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerAFC.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerAFC.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+	routerAFC.redistribute.addSC("connected", "Connected");


+		routerAFC.redistribute.connected.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.connected.addSC("route-map", "Route map reference");


+	routerAFC.redistribute.addSC("dvmrp", "Redistribution of DVMRP into BGP IPv4 Multicast");


+		routerAFC.redistribute.dvmrp.addSC("route-map", "Route map reference");


+	routerAFC.redistribute.addSC("egp", "Exterior Gateway Protocol (EGP)");


+		routerAFC.redistribute.egp.addSC("<0-65535>", "Remote autonomous system number");


+	routerAFC.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerAFC.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+	routerAFC.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerAFC.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+	routerAFC.redistribute.addSC("isis", "ISO IS-IS");


+		routerAFC.redistribute.isis.addSC("level-1", "IS-IS level-1 routes only");


+		routerAFC.redistribute.isis.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+		routerAFC.redistribute.isis.addSC("level-2", "IS-IS level-2 routes only");


+		routerAFC.redistribute.isis.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.isis.addSC("route-map", "Route map reference");


+		routerAFC.redistribute.isis.addSC("WORD", "ISO routing area tag");


+	routerAFC.redistribute.addSC("iso-igrp", "IGRP for OSI networks");


+		routerAFC.redistribute["iso-igrp"].addSC("route-map", "Route map reference");


+		routerAFC.redistribute["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	routerAFC.redistribute.addSC("mobile", "Mobile routes");


+		routerAFC.redistribute.mobile.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.mobile.addSC("route-map", "Route map reference");


+	routerAFC.redistribute.addSC("odr", "On Demand stub Routes");


+		routerAFC.redistribute.odr.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.odr.addSC("route-map", "Route map reference");


+	routerAFC.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerAFC.redistribute.ospf.addSC("<1-65535>", "Process ID");


+	routerAFC.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+		routerAFC.redistribute.rip.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.rip.addSC("route-map", "Route map reference");


+	routerAFC.redistribute.addSC("static", "Static routes");


+		routerAFC.redistribute.static.addSC("metric", "Metric for redistributed routes");


+		routerAFC.redistribute.static.addSC("route-map", "Route map reference");


+routerAFC.addSC("synchronization", "Perform IGP synchronization");


+routerAFC.addSC("table-map", "Map external entry attributes into routing table");


+	routerAFC["table-map"].addSC("WORD", "route-map name");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerBGP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerBGP.txt
new file mode 100644
index 0000000..524fdd1
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerBGP.txt
@@ -0,0 +1,153 @@
+routerBGPC.addSC("address-family", "Enter Address Family command mode");


+	routerBGPC["address-family"].addSC("ipv4", "Address family");


+		routerBGPC["address-family"].ipv4.addSC("multicast", "Address Family modifier");


+		routerBGPC["address-family"].ipv4.addSC("unicast", "Address Family modifier");


+		routerBGPC["address-family"].ipv4.addSC("vrf", "Specify parameters for a VPN Routing/Forwarding instance");


+			routerBGPC["address-family"].ipv4.vrf.addSC("WORD", "VPN Routing/Forwarding instance name");


+	routerBGPC["address-family"].addSC("vpnv4", "Address family");


+		routerBGPC["address-family"].vpnv4.addSC("unicast", "Address Family Modifier");


+routerBGPC.addSC("aggregate-address", "Configure BGP aggregate entries");


+	routerBGPC["aggregate-address"].addSC("A.B.C.D", "Aggregate address");


+		routerBGPC["aggregate-address"]["A.B.C.D"].addSC("A.B.C.D", "Aggregate mask");


+


+routerBGPC.addSC("auto-summary", "Enable automatic network number summarization");


+routerBGPC.addSC("bgp", "BGP specific commands");


+


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


+routerBGPC.addSC("default-information", "Control distribution of default information");


+	routerBGPC["default-information"].addSC("originate", "Distribute a default route");


+routerBGPC.addSC("default-metric", "Set metric of redistributed routes");


+routerBGPC.addSC("distance", "Define an administrative distance");


+	routerBGPC.distance.addSC("<1-255>", "Administrative distance");


+		routerBGPC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");


+			routerBGPC.distance["<1-255>"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");


+				routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-99>", "IP Standard access list number");


+				routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1300-1999>", "IP Standard expanded access list number");


+	routerBGPC.distance.addSC("bgp", "BGP distance");


+		routerBGPC.distance.bgp.addSC("<1-255>", "Distance for routes external to the AS");


+			routerBGPC.distance.bgp["<1-255>"].addSC("<1-255>", "Distance for routes internal to the AS");


+				routerBGPC.distance.bgp["<1-255>"]["<1-255>"].addSC("<1-255>", "Distance for local routes");


+routerBGPC.addSC("distribute-list", "Filter networks in routing updates");


+	routerBGPC["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerBGPC["distribute-list"]["<1-199>"].addSC("in", "Filter incoming routing updates");


+			routerBGPC["distribute-list"]["<1-199>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerBGPC["distribute-list"]["<1-199>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerBGPC["distribute-list"]["<1-199>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerBGPC["distribute-list"]["<1-199>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+


+	routerBGPC["distribute-list"].addSC("WORD", "Access-list name");


+		routerBGPC["distribute-list"].WORD.addSC("in", "Filter incoming routing updates");


+		routerBGPC["distribute-list"].WORD.addSC("out", "Filter outgoing routing updates");


+	routerBGPC["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerBGPC["distribute-list"].gateway.addSC("WORD", "Name of an IP prefix-list");


+


+	routerBGPC["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+routerBGPC.addSC("exit", "Exit from routing protocol configuration mode");


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


+routerBGPC.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerBGPC["maximum-paths"].addSC("<1-8>", "Number of paths");


+routerBGPC.addSC("neighbor", "Specify a neighbor router");


+	routerBGPC.neighbor.addSC("A.B.C.D", "Neighbor address");


+		routerBGPC.neighbor["A.B.C.D"].addSC("activate", "Enable the Address Family for this Neighbor");


+		routerBGPC.neighbor["A.B.C.D"].addSC("advertise-map", "specify route-map for conditional advertisement");


+			routerBGPC.neighbor["A.B.C.D"]["advertise-map"].addSC("WORD", "advertise route-map name");


+				routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");


+					routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");


+		routerBGPC.neighbor["A.B.C.D"].addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");


+			routerBGPC.neighbor["A.B.C.D"]["advertisement-interval"].addSC("<0-600>", "time in seconds");


+		routerBGPC.neighbor["A.B.C.D"].addSC("allowas-in", "Accept as-path with my AS present in it");


+			routerBGPC.neighbor["A.B.C.D"]["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");


+		routerBGPC.neighbor["A.B.C.D"].addSC("default-originate", "Originate default route to this neighbor");


+		routerBGPC.neighbor["A.B.C.D"].addSC("description", "Neighbor specific description");


+		routerBGPC.neighbor["A.B.C.D"].addSC("distribute-list", "Filter updates to/from this neighbor");


+		routerBGPC.neighbor["A.B.C.D"].addSC("ebgp-multihop", "Allow EBGP neighbors not on directly connected networks");


+


+	routerBGPC.neighbor.addSC("WORD", "Neighbor tag");


+		routerBGPC.neighbor.WORD.addSC("activate", "Enable the Address Family for this Neighbor");


+		routerBGPC.neighbor.WORD.addSC("advertise-map", "specify route-map for conditional advertisement");


+			routerBGPC.neighbor.WORD["advertise-map"].addSC("WORD", "advertise route-map name");


+				routerBGPC.neighbor.WORD["advertise-map"].WORD.addSC("non-exist-map", "advertise prefix only if prefix in the condition does not exist");


+					routerBGPC.neighbor.WORD["advertise-map"].WORD["non-exist-map"].addSC("WORD", "condition route-map name");


+		routerBGPC.neighbor.WORD.addSC("advertisement-interval", "Minimum interval between sending BGP routing updates");


+			routerBGPC.neighbor.WORD["advertisement-interval"].addSC("<0-600>", "time in seconds");


+		routerBGPC.neighbor.WORD.addSC("allowas-in", "Accept as-path with my AS present in it");


+			routerBGPC.neighbor.WORD["allowas-in"].addSC("<1-10>", "Number of occurances of AS number");


+		routerBGPC.neighbor.WORD.addSC("default-originate", "Originate default route to this neighbor");


+


+routerBGPC.addSC("network", "Specify a network to announce via BGP");


+	routerBGPC.network.addSC("A.B.C.D", "Network number");


+		routerBGPC.network["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");


+		routerBGPC.network["A.B.C.D"].addSC("mask", "Network mask");


+			routerBGPC.network["A.B.C.D"].mask.addSC("A.B.C.D", "Network mask");


+				routerBGPC.network["A.B.C.D"].mask["A.B.C.D"].addSC("backdoor", "Specify a BGP backdoor route");


+		routerBGPC.network["A.B.C.D"].addSC("route-map", "Route-map to modify the attributes");


+			routerBGPC.network["A.B.C.D"]["route-map"].addSC("WORD", "Name of the route map");


+				routerBGPC.network["A.B.C.D"]["route-map"].WORD.addSC("backdoor", "Specify a BGP backdoor route");


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


+


+routerBGPC.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerBGPC.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerBGPC.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerBGPC.redistribute.bgp["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerBGPC.redistribute.bgp["<1-65535>"].metric.addSC("<0-4294967295>", "Default metric");


+			routerBGPC.redistribute.bgp["<1-65535>"].addSC("route-map", "Route map reference");


+				routerBGPC.redistribute.bgp["<1-65535>"]["route-map"].addSC("WORD", "Pointer to route-map entries");


+					routerBGPC.redistribute.bgp["<1-65535>"]["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+						routerBGPC.redistribute.bgp["<1-65535>"]["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+	routerBGPC.redistribute.addSC("connected", "Connected");


+		routerBGPC.redistribute.connected.addSC("metric", "Metric for redistributed routes");


+			routerBGPC.redistribute.connected.metric.addSC("<0-4294967295>", "Default metric");


+		routerBGPC.redistribute.connected.addSC("route-map", "Route map reference");


+			routerBGPC.redistribute.connected["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerBGPC.redistribute.connected["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerBGPC.redistribute.connected["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+	routerBGPC.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerBGPC.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerBGPC.redistribute.eigrp["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerBGPC.redistribute.eigrp["<1-65535>"].metric.addSC("<0-4294967295>", "Default metric");


+			routerBGPC.redistribute.eigrp["<1-65535>"].addSC("route-map", "Route map reference");


+				routerBGPC.redistribute.eigrp["<1-65535>"]["route-map"].addSC("WORD", "Pointer to route-map entries");


+					routerBGPC.redistribute.eigrp["<1-65535>"]["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+						routerBGPC.redistribute.eigrp["<1-65535>"]["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+	routerBGPC.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerBGPC.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerBGPC.redistribute.igrp["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerBGPC.redistribute.igrp["<1-65535>"].metric.addSC("<0-4294967295>", "Default metric");


+			routerBGPC.redistribute.igrp["<1-65535>"].addSC("route-map", "Route map reference");


+				routerBGPC.redistribute.igrp["<1-65535>"]["route-map"].addSC("WORD", "Pointer to route-map entries");


+					routerBGPC.redistribute.igrp["<1-65535>"]["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+						routerBGPC.redistribute.igrp["<1-65535>"]["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+


+	routerBGPC.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerBGPC.redistribute.ospf.addSC("<1-65535>", "Process ID");


+			routerBGPC.redistribute.ospf["<1-65535>"].addSC("match", "Redistribution of OSPF routes");


+				routerBGPC.redistribute.ospf["<1-65535>"].match.addSC("external", "Redistribute OSPF external routes");


+				routerBGPC.redistribute.ospf["<1-65535>"].match.addSC("internal", "Redistribute OSPF internal routes");


+				routerBGPC.redistribute.ospf["<1-65535>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+			routerBGPC.redistribute.ospf["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerBGPC.redistribute.ospf["<1-65535>"].metric.addSC("<0-4294967295>", "Default metric");


+			routerBGPC.redistribute.ospf["<1-65535>"].addSC("route-map", "Route map reference");


+				routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].addSC("WORD", "Pointer to route-map entries");


+					routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.addSC("match", "Redistribution of OSPF routes");


+			routerBGPC.redistribute.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				routerBGPC.redistribute.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+	routerBGPC.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+		routerBGPC.redistribute.rip.addSC("metric", "Metric for redistributed routes");


+			routerBGPC.redistribute.rip.metric.addSC("<0-4294967295>", "Default metric");


+		routerBGPC.redistribute.rip.addSC("route-map", "Route map reference");


+			routerBGPC.redistribute.rip["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerBGPC.redistribute.rip["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerBGPC.redistribute.rip["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+	routerBGPC.redistribute.addSC("static", "Static routes");


+		routerBGPC.redistribute.static.addSC("metric", "Metric for redistributed routes");


+			routerBGPC.redistribute.static.metric.addSC("<0-4294967295>", "Default metric");


+		routerBGPC.redistribute.static.addSC("route-map", "Route map reference");


+			routerBGPC.redistribute.static["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerBGPC.redistribute.static["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerBGPC.redistribute.static["route-map"].WORD.metric.addSC("<0-4294967295>", "Default metric");


+routerBGPC.addSC("synchronization", "Perform IGP synchronization");


+routerBGPC.addSC("table-map", "Map external entry attributes into routing table");


+routerBGPC.addSC("timers", "Adjust routing timers");


+	routerBGPC.timers.addSC("bgp", "BGP timers");


+		routerBGPC.timers.bgp.addSC("<1-4294967295>", "Keepalive interval");


+			routerBGPC.timers.bgp["<1-4294967295>"].addSC("<1-4294967295>", "Holdtime");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerEIGRP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerEIGRP.txt
new file mode 100644
index 0000000..fdf62c2
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerEIGRP.txt
@@ -0,0 +1,408 @@
+


+routerEIGRPC.addSC("auto-summary", "Enable automatic network number summarization");


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


+routerEIGRPC.addSC("default-information", "Control distribution of default information");


+	routerEIGRPC["default-information"].addSC("allowed", "Allow default information");


+	routerEIGRPC["default-information"].addSC("in", "Accept default routing information");


+		routerEIGRPC["default-information"]["in"].addSC("<1-99>", "A standard IP access list number");


+		routerEIGRPC["default-information"]["in"].addSC("<1300-1999>", "A standard expanded IP access list number");


+		routerEIGRPC["default-information"]["in"].addSC("WORD", "Standard Access-list name");


+	routerEIGRPC["default-information"].addSC("out", "Output default routing information");


+		routerEIGRPC["default-information"].out.addSC("<1-99>", "A standard IP access list number");


+		routerEIGRPC["default-information"].out.addSC("<1300-1999>", "A standard expanded IP access list number");


+		routerEIGRPC["default-information"].out.addSC("WORD", "Standard Access-list name");


+routerEIGRPC.addSC("default-metric", "Set metric of redistributed routes");


+routerEIGRPC.addSC("distance", "Define an administrative distance");


+	routerEIGRPC.distance.addSC("<1-255>", "Administrative distance");


+		routerEIGRPC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");


+			routerEIGRPC.distance["<1-255>"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");


+				routerEIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-99>", "IP Standard access list number");


+				routerEIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1300-1999>", "IP Standard expanded access list number");


+	routerEIGRPC.distance.addSC("eigrp", "IP-EIGRP distance");


+		routerEIGRPC.distance.eigrp.addSC("<1-255>", "Distance for internal routes");


+			routerEIGRPC.distance.eigrp["<1-255>"].addSC("<1-255>", "Distance for external routes");


+routerEIGRPC.addSC("distribute-list", "Filter networks in routing updates");


+	routerEIGRPC["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerEIGRPC["distribute-list"]["<1-199>"].addSC("in", "Filter incoming routing updates");


+			routerEIGRPC["distribute-list"]["<1-199>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1-199>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1-199>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"]["<1-199>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"]["<1-199>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"]["<1-199>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerEIGRPC["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing routing updates");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1-199>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("connected", "Connected");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerEIGRPC["distribute-list"]["<1-199>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerEIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerEIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerEIGRPC["distribute-list"]["<1-199>"].out.addSC("static", "Static routes");


+	routerEIGRPC["distribute-list"].addSC("<1300-2699>", "IP expanded access list number");


+		routerEIGRPC["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming routing updates");


+			routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1300-2699>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerEIGRPC["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing routing updates");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("connected", "Connected");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerEIGRPC["distribute-list"]["<1300-2699>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerEIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerEIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerEIGRPC["distribute-list"]["<1300-2699>"].out.addSC("static", "Static routes");


+	routerEIGRPC["distribute-list"].addSC("WORD", "Access-list name");


+		routerEIGRPC["distribute-list"].WORD.addSC("in", "Filter incoming routing updates");


+			routerEIGRPC["distribute-list"].WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"].WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"].WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"].WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"].WORD["in"].addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"].WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"].WORD["in"].addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"].WORD["in"].Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"].WORD["in"].addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"].WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerEIGRPC["distribute-list"].WORD.addSC("out", "Filter outgoing routing updates");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerEIGRPC["distribute-list"].WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerEIGRPC["distribute-list"].WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("Loopback", "Loopback interface");


+				routerEIGRPC["distribute-list"].WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("Null", "Null interface");


+				routerEIGRPC["distribute-list"].WORD.out.Null.addSC("<0-0>", "Null interface number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("Vlan", "Catalyst Vlans");


+				routerEIGRPC["distribute-list"].WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerEIGRPC["distribute-list"].WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("connected", "Connected");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerEIGRPC["distribute-list"].WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerEIGRPC["distribute-list"].WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerEIGRPC["distribute-list"].WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerEIGRPC["distribute-list"].WORD.out.ospf.addSC("<1-65535>", "Process ID");


+					routerEIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerEIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerEIGRPC["distribute-list"].WORD.out.addSC("static", "Static routes");


+	routerEIGRPC["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerEIGRPC["distribute-list"].gateway.addSC("WORD", "Name of an IP prefix-list");


+			routerEIGRPC["distribute-list"].gateway.WORD.addSC("in", "Filter incoming routing updates");


+				routerEIGRPC["distribute-list"].gateway.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerEIGRPC["distribute-list"].gateway.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerEIGRPC["distribute-list"].gateway.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerEIGRPC["distribute-list"].gateway.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD["in"].addSC("Null", "Null interface");


+					routerEIGRPC["distribute-list"].gateway.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerEIGRPC["distribute-list"].gateway.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerEIGRPC["distribute-list"].gateway.WORD.addSC("out", "Filter outgoing routing updates");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerEIGRPC["distribute-list"].gateway.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("Loopback", "Loopback interface");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("Null", "Null interface");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("connected", "Connected");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerEIGRPC["distribute-list"].gateway.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerEIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerEIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerEIGRPC["distribute-list"].gateway.WORD.out.addSC("static", "Static routes");


+	routerEIGRPC["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+		routerEIGRPC["distribute-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+			routerEIGRPC["distribute-list"].prefix.WORD.addSC("gateway", "Filtering incoming updates based on gateway");


+			routerEIGRPC["distribute-list"].prefix.WORD.addSC("in", "Filter incoming routing updates");


+				routerEIGRPC["distribute-list"].prefix.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerEIGRPC["distribute-list"].prefix.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerEIGRPC["distribute-list"].prefix.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerEIGRPC["distribute-list"].prefix.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD["in"].addSC("Null", "Null interface");


+					routerEIGRPC["distribute-list"].prefix.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerEIGRPC["distribute-list"].prefix.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerEIGRPC["distribute-list"].prefix.WORD.addSC("out", "Filter outgoing routing updates");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerEIGRPC["distribute-list"].prefix.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("Loopback", "Loopback interface");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("Null", "Null interface");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("connected", "Connected");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerEIGRPC["distribute-list"].prefix.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerEIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerEIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerEIGRPC["distribute-list"].prefix.WORD.out.addSC("static", "Static routes");


+routerEIGRPC.addSC("eigrp", "EIGRP specific commands");


+	routerEIGRPC.eigrp.addSC("log-neighbor-changes", "Enable/Disable IP-EIGRP neighbor logging");


+	routerEIGRPC.eigrp.addSC("log-neighbor-warnings", "Enable/Disable IP-EIGRP neighbor warnings");


+		routerEIGRPC.eigrp["log-neighbor-warnings"].addSC("<1-65535>", "Neighbor warning interval in seconds");


+	routerEIGRPC.eigrp.addSC("router-id", "router-id for this EIGRP process");


+		routerEIGRPC.eigrp["router-id"].addSC("A.B.C.D", "EIGRP Router-ID in IP address format");


+	routerEIGRPC.eigrp.addSC("stub", "Set IP-EIGRP as stubbed router");


+		routerEIGRPC.eigrp.stub.addSC("connected", "Do advertise connected routes");


+		routerEIGRPC.eigrp.stub.addSC("receive-only", "Set IP-EIGRP as receive only neighbor");


+		routerEIGRPC.eigrp.stub.addSC("static", "Do advertise static routes");


+			routerEIGRPC.eigrp.stub.static.addSC("connected", "Do advertise connected routes");


+		routerEIGRPC.eigrp.stub.addSC("summary", "Do advertise summary routes");


+			routerEIGRPC.eigrp.stub.summary.addSC("connected", "Do advertise connected routes");


+			routerEIGRPC.eigrp.stub.summary.addSC("static", "Do advertise static routes");


+				routerEIGRPC.eigrp.stub.summary.static.addSC("connected", "Do advertise connected routes");


+routerEIGRPC.addSC("exit", "Exit from routing protocol configuration mode");


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


+routerEIGRPC.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerEIGRPC["maximum-paths"].addSC("<1-8>", "Number of paths");


+routerEIGRPC.addSC("metric", "Modify IGRP routing metrics and parameters");


+	routerEIGRPC.metric.addSC("holddown", "Enable IGRP holddown");


+	routerEIGRPC.metric.addSC("maximum-hops", "Advertise IGRP routes greater than <hops> as unreachable");


+		routerEIGRPC.metric["maximum-hops"].addSC("<1-255>", "Hop count");


+	routerEIGRPC.metric.addSC("weights", "Modify IGRP metric coefficients");


+		routerEIGRPC.metric.weights.addSC("<0-8>", "Type Of Service (Only TOS 0 supported)");


+			routerEIGRPC.metric.weights["<0-8>"].addSC("<0-4294967295>", "K1");


+				routerEIGRPC.metric.weights["<0-8>"]["<0-4294967295>"].addSC("<0-4294967295>", "K2");


+					routerEIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K3");


+						routerEIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K4");


+							routerEIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K5");


+routerEIGRPC.addSC("neighbor", "Specify a neighbor router");


+	routerEIGRPC.neighbor.addSC("A.B.C.D", "Neighbor address");


+		routerEIGRPC.neighbor["A.B.C.D"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+			routerEIGRPC.neighbor["A.B.C.D"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+		routerEIGRPC.neighbor["A.B.C.D"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+			routerEIGRPC.neighbor["A.B.C.D"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+		routerEIGRPC.neighbor["A.B.C.D"].addSC("Loopback", "Loopback interface");


+			routerEIGRPC.neighbor["A.B.C.D"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+		routerEIGRPC.neighbor["A.B.C.D"].addSC("Null", "Null interface");


+			routerEIGRPC.neighbor["A.B.C.D"].Null.addSC("<0-0>", "Null interface number");


+		routerEIGRPC.neighbor["A.B.C.D"].addSC("Vlan", "Catalyst Vlans");


+			routerEIGRPC.neighbor["A.B.C.D"].Vlan.addSC("<1-1001>", "Vlan interface number");


+routerEIGRPC.addSC("network", "Enable routing on an IP network");


+	routerEIGRPC.network.addSC("A.B.C.D", "Network number");


+		routerEIGRPC.network["A.B.C.D"].addSC("A.B.C.D", "EIGRP wild card bits");


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


+routerEIGRPC.addSC("offset-list", "Add or subtract offset from IGRP or RIP metrics");


+routerEIGRPC.addSC("passive-interface", "Suppress routing updates on an interface");


+	routerEIGRPC["passive-interface"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+		routerEIGRPC["passive-interface"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+	routerEIGRPC["passive-interface"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		routerEIGRPC["passive-interface"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+	routerEIGRPC["passive-interface"].addSC("Loopback", "Loopback interface");


+		routerEIGRPC["passive-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+	routerEIGRPC["passive-interface"].addSC("Null", "Null interface");


+		routerEIGRPC["passive-interface"].Null.addSC("<0-0>", "Null interface number");


+	routerEIGRPC["passive-interface"].addSC("Vlan", "Catalyst Vlans");


+		routerEIGRPC["passive-interface"].Vlan.addSC("<1-1001>", "Vlan interface number");


+	routerEIGRPC["passive-interface"].addSC("default", "Suppress routing updates on all interfaces");


+routerEIGRPC.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerEIGRPC.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerEIGRPC.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+	routerEIGRPC.redistribute.addSC("connected", "Connected");


+	routerEIGRPC.redistribute.addSC("egp", "Exterior Gateway Protocol (EGP)");


+		routerEIGRPC.redistribute.egp.addSC("<0-65535>", "Remote autonomous system number");


+	routerEIGRPC.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerEIGRPC.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+	routerEIGRPC.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerEIGRPC.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+	routerEIGRPC.redistribute.addSC("isis", "ISO IS-IS");


+		routerEIGRPC.redistribute.isis.addSC("level-1", "IS-IS level-1 routes only");


+		routerEIGRPC.redistribute.isis.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+		routerEIGRPC.redistribute.isis.addSC("level-2", "IS-IS level-2 routes only");


+		routerEIGRPC.redistribute.isis.addSC("WORD", "ISO routing area tag");


+			routerEIGRPC.redistribute.isis.WORD.addSC("level-1", "IS-IS level-1 routes only");


+			routerEIGRPC.redistribute.isis.WORD.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+			routerEIGRPC.redistribute.isis.WORD.addSC("level-2", "IS-IS level-2 routes only");


+	routerEIGRPC.redistribute.addSC("iso-igrp", "IGRP for OSI networks");


+		routerEIGRPC.redistribute["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	routerEIGRPC.redistribute.addSC("metric", "Metric for redistributed routes");


+		routerEIGRPC.redistribute.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+			routerEIGRPC.redistribute.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+				routerEIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+					routerEIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+						routerEIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerEIGRPC.redistribute.addSC("mobile", "Mobile routes");


+		routerEIGRPC.redistribute.mobile.addSC("metric", "Metric for redistributed routes");


+			routerEIGRPC.redistribute.mobile.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerEIGRPC.redistribute.mobile.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerEIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerEIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerEIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerEIGRPC.redistribute.addSC("odr", "On Demand stub Routes");


+		routerEIGRPC.redistribute.odr.addSC("metric", "Metric for redistributed routes");


+			routerEIGRPC.redistribute.odr.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerEIGRPC.redistribute.odr.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerEIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerEIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerEIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerEIGRPC.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerEIGRPC.redistribute.ospf.addSC("<1-65535>", "Process ID");


+			routerEIGRPC.redistribute.ospf["<1-65535>"].addSC("match", "Redistribution of OSPF routes");


+				routerEIGRPC.redistribute.ospf["<1-65535>"].match.addSC("external", "Redistribute OSPF external routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerEIGRPC.redistribute.ospf["<1-65535>"].match.addSC("internal", "Redistribute OSPF internal routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match.internal.addSC("external", "Redistribute OSPF external routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerEIGRPC.redistribute.ospf["<1-65535>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+			routerEIGRPC.redistribute.ospf["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerEIGRPC.redistribute.ospf["<1-65535>"].metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+									routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].addSC("match", "Redistribution of OSPF routes");


+			routerEIGRPC.redistribute.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("match", "Redistribution of OSPF routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("external", "Redistribute OSPF external routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("internal", "Redistribute OSPF internal routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+									routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("metric", "Metric for redistributed routes");


+						routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+							routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+								routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+									routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+	routerEIGRPC.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+		routerEIGRPC.redistribute.rip.addSC("metric", "Metric for redistributed routes");


+			routerEIGRPC.redistribute.rip.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerEIGRPC.redistribute.rip.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerEIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerEIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerEIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerEIGRPC.redistribute.addSC("route-map", "Route map reference");


+		routerEIGRPC.redistribute["route-map"].addSC("WORD", "Pointer to route-map entries");


+			routerEIGRPC.redistribute["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+				routerEIGRPC.redistribute["route-map"].WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+					routerEIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+						routerEIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+							routerEIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+								routerEIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerEIGRPC.redistribute.addSC("static", "Static routes");


+		routerEIGRPC.redistribute.static.addSC("metric", "Metric for redistributed routes");


+			routerEIGRPC.redistribute.static.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerEIGRPC.redistribute.static.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerEIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerEIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerEIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+		routerEIGRPC.redistribute.static.addSC("route-map", "Route map reference");


+			routerEIGRPC.redistribute.static["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerEIGRPC.redistribute.static["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerEIGRPC.redistribute.static["route-map"].WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+						routerEIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+							routerEIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+								routerEIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+									routerEIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+routerEIGRPC.addSC("timers", "Adjust routing timers");


+	routerEIGRPC.timers.addSC("active-time", "EIGRP time limit for active state");


+		routerEIGRPC.timers["active-time"].addSC("<1-4294967295>", "EIGRP active-state time limit in minutes");


+		routerEIGRPC.timers["active-time"].addSC("disabled", "disable EIGRP time limit for active state");


+routerEIGRPC.addSC("traffic-share", "How to compute traffic share over alternate paths");


+	routerEIGRPC["traffic-share"].addSC("balanced", "Share inversely proportional to metric");


+	routerEIGRPC["traffic-share"].addSC("min", "All traffic shared among min metric paths");


+		routerEIGRPC["traffic-share"].min.addSC("across-interfaces", "Use different interfaces for equal-cost paths");


+routerEIGRPC.addSC("variance", "Control load balancing variance");


+	routerEIGRPC.variance.addSC("<1-128>", "Metric variance multiplier");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerIGRP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerIGRP.txt
new file mode 100644
index 0000000..2cc7288
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerIGRP.txt
@@ -0,0 +1,384 @@
+


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


+routerIGRPC.addSC("default-information", "Control distribution of default information");


+	routerIGRPC["default-information"].addSC("allowed", "Allow default information");


+	routerIGRPC["default-information"].addSC("in", "Accept default routing information");


+		routerIGRPC["default-information"]["in"].addSC("<1-99>", "A standard IP access list number");


+		routerIGRPC["default-information"]["in"].addSC("<1300-1999>", "A standard expanded IP access list number");


+		routerIGRPC["default-information"]["in"].addSC("WORD", "Standard Access-list name");


+	routerIGRPC["default-information"].addSC("out", "Output default routing information");


+		routerIGRPC["default-information"].out.addSC("<1-99>", "A standard IP access list number");


+		routerIGRPC["default-information"].out.addSC("<1300-1999>", "A standard expanded IP access list number");


+		routerIGRPC["default-information"].out.addSC("WORD", "Standard Access-list name");


+routerIGRPC.addSC("default-metric", "Set metric of redistributed routes");


+routerIGRPC.addSC("distance", "Define an administrative distance");


+	routerIGRPC.distance.addSC("<1-255>", "Administrative distance");


+		routerIGRPC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");


+			routerIGRPC.distance["<1-255>"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");


+				routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-99>", "IP Standard access list number");


+				routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1300-1999>", "IP Standard expanded access list number");


+				routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("WORD", "Standard access-list name");


+routerIGRPC.addSC("distribute-list", "Filter networks in routing updates");


+	routerIGRPC["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerIGRPC["distribute-list"]["<1-199>"].addSC("in", "Filter incoming routing updates");


+			routerIGRPC["distribute-list"]["<1-199>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1-199>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"]["<1-199>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1-199>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"]["<1-199>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"]["<1-199>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"]["<1-199>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"]["<1-199>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerIGRPC["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing routing updates");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1-199>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1-199>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"]["<1-199>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"]["<1-199>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"]["<1-199>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerIGRPC["distribute-list"]["<1-199>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("connected", "Connected");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerIGRPC["distribute-list"]["<1-199>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerIGRPC["distribute-list"]["<1-199>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerIGRPC["distribute-list"]["<1-199>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerIGRPC["distribute-list"]["<1-199>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerIGRPC["distribute-list"]["<1-199>"].out.addSC("static", "Static routes");


+	routerIGRPC["distribute-list"].addSC("<1300-2699>", "IP expanded access list number");


+		routerIGRPC["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming routing updates");


+			routerIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1300-2699>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1300-2699>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"]["<1300-2699>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"]["<1300-2699>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"]["<1300-2699>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerIGRPC["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing routing updates");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("connected", "Connected");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerIGRPC["distribute-list"]["<1300-2699>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerIGRPC["distribute-list"]["<1300-2699>"].out.addSC("static", "Static routes");


+	routerIGRPC["distribute-list"].addSC("WORD", "Access-list name");


+		routerIGRPC["distribute-list"].WORD.addSC("in", "Filter incoming routing updates");


+			routerIGRPC["distribute-list"].WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"].WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"].WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"].WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"].WORD["in"].addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"].WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"].WORD["in"].addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"].WORD["in"].Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"].WORD["in"].addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"].WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerIGRPC["distribute-list"].WORD.addSC("out", "Filter outgoing routing updates");


+			routerIGRPC["distribute-list"].WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerIGRPC["distribute-list"].WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerIGRPC["distribute-list"].WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("Loopback", "Loopback interface");


+				routerIGRPC["distribute-list"].WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("Null", "Null interface");


+				routerIGRPC["distribute-list"].WORD.out.Null.addSC("<0-0>", "Null interface number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("Vlan", "Catalyst Vlans");


+				routerIGRPC["distribute-list"].WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerIGRPC["distribute-list"].WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("connected", "Connected");


+			routerIGRPC["distribute-list"].WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerIGRPC["distribute-list"].WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerIGRPC["distribute-list"].WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerIGRPC["distribute-list"].WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerIGRPC["distribute-list"].WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerIGRPC["distribute-list"].WORD.out.ospf.addSC("<1-65535>", "Process ID");


+					routerIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerIGRPC["distribute-list"].WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerIGRPC["distribute-list"].WORD.out.addSC("static", "Static routes");


+	routerIGRPC["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerIGRPC["distribute-list"].gateway.addSC("WORD", "Name of an IP prefix-list");


+			routerIGRPC["distribute-list"].gateway.WORD.addSC("in", "Filter incoming routing updates");


+				routerIGRPC["distribute-list"].gateway.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerIGRPC["distribute-list"].gateway.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerIGRPC["distribute-list"].gateway.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerIGRPC["distribute-list"].gateway.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerIGRPC["distribute-list"].gateway.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerIGRPC["distribute-list"].gateway.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerIGRPC["distribute-list"].gateway.WORD["in"].addSC("Null", "Null interface");


+					routerIGRPC["distribute-list"].gateway.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerIGRPC["distribute-list"].gateway.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerIGRPC["distribute-list"].gateway.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerIGRPC["distribute-list"].gateway.WORD.addSC("out", "Filter outgoing routing updates");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerIGRPC["distribute-list"].gateway.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerIGRPC["distribute-list"].gateway.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("Loopback", "Loopback interface");


+					routerIGRPC["distribute-list"].gateway.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("Null", "Null interface");


+					routerIGRPC["distribute-list"].gateway.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerIGRPC["distribute-list"].gateway.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerIGRPC["distribute-list"].gateway.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("connected", "Connected");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerIGRPC["distribute-list"].gateway.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerIGRPC["distribute-list"].gateway.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerIGRPC["distribute-list"].gateway.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerIGRPC["distribute-list"].gateway.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerIGRPC["distribute-list"].gateway.WORD.out.addSC("static", "Static routes");


+	routerIGRPC["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+		routerIGRPC["distribute-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+			routerIGRPC["distribute-list"].prefix.WORD.addSC("gateway", "Filtering incoming updates based on gateway");


+			routerIGRPC["distribute-list"].prefix.WORD.addSC("in", "Filter incoming routing updates");


+				routerIGRPC["distribute-list"].prefix.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerIGRPC["distribute-list"].prefix.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerIGRPC["distribute-list"].prefix.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerIGRPC["distribute-list"].prefix.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerIGRPC["distribute-list"].prefix.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerIGRPC["distribute-list"].prefix.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerIGRPC["distribute-list"].prefix.WORD["in"].addSC("Null", "Null interface");


+					routerIGRPC["distribute-list"].prefix.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerIGRPC["distribute-list"].prefix.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerIGRPC["distribute-list"].prefix.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerIGRPC["distribute-list"].prefix.WORD.addSC("out", "Filter outgoing routing updates");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerIGRPC["distribute-list"].prefix.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerIGRPC["distribute-list"].prefix.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("Loopback", "Loopback interface");


+					routerIGRPC["distribute-list"].prefix.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("Null", "Null interface");


+					routerIGRPC["distribute-list"].prefix.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerIGRPC["distribute-list"].prefix.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerIGRPC["distribute-list"].prefix.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("connected", "Connected");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerIGRPC["distribute-list"].prefix.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerIGRPC["distribute-list"].prefix.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerIGRPC["distribute-list"].prefix.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerIGRPC["distribute-list"].prefix.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerIGRPC["distribute-list"].prefix.WORD.out.addSC("static", "Static routes");


+routerIGRPC.addSC("exit", "Exit from routing protocol configuration mode");


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


+routerIGRPC.addSC("input-queue", "Specify input queue depth");


+routerIGRPC.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerIGRPC["maximum-paths"].addSC("<1-8>", "Number of paths");


+routerIGRPC.addSC("metric", "Modify IGRP routing metrics and parameters");


+	routerIGRPC.metric.addSC("holddown", "Enable IGRP holddown");


+	routerIGRPC.metric.addSC("maximum-hops", "Advertise IGRP routes greater than <hops> as unreachable");


+		routerIGRPC.metric["maximum-hops"].addSC("<1-255>", "Hop count");


+	routerIGRPC.metric.addSC("weights", "Modify IGRP metric coefficients");


+		routerIGRPC.metric.weights.addSC("<0-8>", "Type Of Service (Only TOS 0 supported)");


+			routerIGRPC.metric.weights["<0-8>"].addSC("<0-4294967295>", "K1");


+				routerIGRPC.metric.weights["<0-8>"]["<0-4294967295>"].addSC("<0-4294967295>", "K2");


+					routerIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K3");


+						routerIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K4");


+							routerIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].addSC("<0-4294967295>", "K5");


+routerIGRPC.addSC("neighbor", "Specify a neighbor router");


+	routerIGRPC.neighbor.addSC("A.B.C.D", "Neighbor address");


+routerIGRPC.addSC("network", "Enable routing on an IP network");


+	routerIGRPC.network.addSC("A.B.C.D", "Network number");


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


+routerIGRPC.addSC("offset-list", "Add or subtract offset from IGRP or RIP metrics");


+routerIGRPC.addSC("passive-interface", "Suppress routing updates on an interface");


+	routerIGRPC["passive-interface"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+		routerIGRPC["passive-interface"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+	routerIGRPC["passive-interface"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		routerIGRPC["passive-interface"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+	routerIGRPC["passive-interface"].addSC("Loopback", "Loopback interface");


+		routerIGRPC["passive-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+	routerIGRPC["passive-interface"].addSC("Null", "Null interface");


+		routerIGRPC["passive-interface"].Null.addSC("<0-0>", "Null interface number");


+	routerIGRPC["passive-interface"].addSC("Vlan", "Catalyst Vlans");


+		routerIGRPC["passive-interface"].Vlan.addSC("<1-1001>", "Vlan interface number");


+	routerIGRPC["passive-interface"].addSC("default", "Suppress routing updates on all interfaces");


+routerIGRPC.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerIGRPC.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerIGRPC.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+	routerIGRPC.redistribute.addSC("connected", "Connected");


+	routerIGRPC.redistribute.addSC("egp", "Exterior Gateway Protocol (EGP)");


+		routerIGRPC.redistribute.egp.addSC("<0-65535>", "Remote autonomous system number");


+	routerIGRPC.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerIGRPC.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+	routerIGRPC.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerIGRPC.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+	routerIGRPC.redistribute.addSC("isis", "ISO IS-IS");


+		routerIGRPC.redistribute.isis.addSC("level-1", "IS-IS level-1 routes only");


+		routerIGRPC.redistribute.isis.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+		routerIGRPC.redistribute.isis.addSC("level-2", "IS-IS level-2 routes only");


+		routerIGRPC.redistribute.isis.addSC("WORD", "ISO routing area tag");


+			routerIGRPC.redistribute.isis.WORD.addSC("level-1", "IS-IS level-1 routes only");


+			routerIGRPC.redistribute.isis.WORD.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+			routerIGRPC.redistribute.isis.WORD.addSC("level-2", "IS-IS level-2 routes only");


+	routerIGRPC.redistribute.addSC("iso-igrp", "IGRP for OSI networks");


+		routerIGRPC.redistribute["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	routerIGRPC.redistribute.addSC("metric", "Metric for redistributed routes");


+		routerIGRPC.redistribute.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+			routerIGRPC.redistribute.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+				routerIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+					routerIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+						routerIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerIGRPC.redistribute.addSC("mobile", "Mobile routes");


+		routerIGRPC.redistribute.mobile.addSC("metric", "Metric for redistributed routes");


+			routerIGRPC.redistribute.mobile.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerIGRPC.redistribute.mobile.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerIGRPC.redistribute.addSC("odr", "On Demand stub Routes");


+		routerIGRPC.redistribute.odr.addSC("metric", "Metric for redistributed routes");


+			routerIGRPC.redistribute.odr.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerIGRPC.redistribute.odr.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerIGRPC.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerIGRPC.redistribute.ospf.addSC("<1-65535>", "Process ID");


+			routerIGRPC.redistribute.ospf["<1-65535>"].addSC("match", "Redistribution of OSPF routes");


+				routerIGRPC.redistribute.ospf["<1-65535>"].match.addSC("external", "Redistribute OSPF external routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerIGRPC.redistribute.ospf["<1-65535>"].match.addSC("internal", "Redistribute OSPF internal routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match.internal.addSC("external", "Redistribute OSPF external routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerIGRPC.redistribute.ospf["<1-65535>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+			routerIGRPC.redistribute.ospf["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerIGRPC.redistribute.ospf["<1-65535>"].metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+					routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+						routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+							routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+								routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+									routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].addSC("match", "Redistribution of OSPF routes");


+			routerIGRPC.redistribute.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				routerIGRPC.redistribute.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+					routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("match", "Redistribution of OSPF routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("external", "Redistribute OSPF external routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("internal", "Redistribute OSPF internal routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+									routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("metric", "Metric for redistributed routes");


+						routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+							routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+								routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+									routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+	routerIGRPC.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+		routerIGRPC.redistribute.rip.addSC("metric", "Metric for redistributed routes");


+			routerIGRPC.redistribute.rip.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerIGRPC.redistribute.rip.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerIGRPC.redistribute.addSC("route-map", "Route map reference");


+		routerIGRPC.redistribute["route-map"].addSC("WORD", "Pointer to route-map entries");


+			routerIGRPC.redistribute["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+				routerIGRPC.redistribute["route-map"].WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+					routerIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+						routerIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+							routerIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+								routerIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+	routerIGRPC.redistribute.addSC("static", "Static routes");


+		routerIGRPC.redistribute.static.addSC("metric", "Metric for redistributed routes");


+			routerIGRPC.redistribute.static.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+				routerIGRPC.redistribute.static.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+					routerIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+						routerIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+							routerIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+		routerIGRPC.redistribute.static.addSC("route-map", "Route map reference");


+			routerIGRPC.redistribute.static["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerIGRPC.redistribute.static["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerIGRPC.redistribute.static["route-map"].WORD.metric.addSC("<1-4294967295>", "Bandwidth metric in Kbits per second");


+						routerIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"].addSC("<0-4294967295>", "IGRP delay metric, in 10 microsecond units");


+							routerIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"].addSC("<0-255>", "IGRP reliability metric where 255 is 100% reliable");


+								routerIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"].addSC("<1-255>", "IGRP Effective bandwidth metric (Loading) where 255 is 100% loaded");


+									routerIGRPC.redistribute.static["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"].addSC("<1-4294967295>", "IGRP MTU of the path");


+routerIGRPC.addSC("timers", "Adjust routing timers");


+	routerIGRPC.timers.addSC("basic", "Basic routing protocol update timers");


+		routerIGRPC.timers.basic.addSC("<0-4294967295>", "Interval between updates");


+			routerIGRPC.timers.basic["<0-4294967295>"].addSC("<1-4294967295>", "Invalid");


+				routerIGRPC.timers.basic["<0-4294967295>"]["<1-4294967295>"].addSC("<0-4294967295>", "Holddown");


+					routerIGRPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"].addSC("<1-4294967295>", "Flush");


+						routerIGRPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"].addSC("<1-4294967295>", "Sleep time, in milliseconds");


+routerIGRPC.addSC("traffic-share", "How to compute traffic share over alternate paths");


+	routerIGRPC["traffic-share"].addSC("balanced", "Share inversely proportional to metric");


+	routerIGRPC["traffic-share"].addSC("min", "All traffic shared among min metric paths");


+		routerIGRPC["traffic-share"].min.addSC("across-interfaces", "Use different interfaces for equal-cost paths");


+routerIGRPC.addSC("validate-update-source", "Perform sanity checks against source address of routing updates");


+routerIGRPC.addSC("variance", "Control load balancing variance");


+	routerIGRPC.variance.addSC("<1-128>", "Metric variance multiplier");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerOSPF.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerOSPF.txt
new file mode 100644
index 0000000..a84b2a6
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerOSPF.txt
@@ -0,0 +1,195 @@
+


+routerOSPF.addSC("area", "OSPF area parameters");


+	routerOSPF.area.addSC("<0-4294967295>", "OSPF area ID as a decimal value");


+		routerOSPF.area["<0-4294967295>"].addSC("authentication", "Enable authentication");


+			routerOSPF.area["<0-4294967295>"].authentication.addSC("message-digest", "Use message-digest authentication");


+		routerOSPF.area["<0-4294967295>"].addSC("default-cost", "Set the summary default-cost of a NSSA/stub area");


+			routerOSPF.area["<0-4294967295>"]["default-cost"].addSC("<0-16777215>", "Stub's advertised external route metric");


+		routerOSPF.area["<0-4294967295>"].addSC("filter-list", "Filter networks between OSPF areas");


+			routerOSPF.area["<0-4294967295>"]["filter-list"].addSC("prefix", "Filter prefixes between OSPF areas");


+				routerOSPF.area["<0-4294967295>"]["filter-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+					routerOSPF.area["<0-4294967295>"]["filter-list"].prefix.WORD.addSC("in", "Filter networks sent to this area");


+					routerOSPF.area["<0-4294967295>"]["filter-list"].prefix.WORD.addSC("out", "Filter networks sent from this area");


+		routerOSPF.area["<0-4294967295>"].addSC("nssa", "Specify a NSSA area");


+			routerOSPF.area["<0-4294967295>"].nssa.addSC("default-information-originate", "Originate Type 7 default into NSSA area");


+				routerOSPF.area["<0-4294967295>"].nssa["default-information-originate"].addSC("metric", "OSPF default metric");


+					routerOSPF.area["<0-4294967295>"].nssa["default-information-originate"].metric.addSC("<0-16777214>", "OSPF metric");


+				routerOSPF.area["<0-4294967295>"].nssa["default-information-originate"].addSC("metric-type", "OSPF metric type for default routes");


+					routerOSPF.area["<0-4294967295>"].nssa["default-information-originate"]["metric-type"].addSC("<1-2>", "OSPF Link State type");


+			routerOSPF.area["<0-4294967295>"].nssa.addSC("no-redistribution", "No redistribution into this NSSA area");


+			routerOSPF.area["<0-4294967295>"].nssa.addSC("no-summary", "Do not send summary LSA into NSSA");


+		routerOSPF.area["<0-4294967295>"].addSC("range", "Summarize routes matching address/mask (border routers only)");


+			routerOSPF.area["<0-4294967295>"].range.addSC("A.B.C.D", "IP address to match");


+				routerOSPF.area["<0-4294967295>"].range["A.B.C.D"].addSC("A.B.C.D", "IP mask for address");


+					routerOSPF.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].addSC("advertise", "Advertise this range (default)");


+					routerOSPF.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].addSC("cost", "User specified metric for this range");


+						routerOSPF.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].cost.addSC("<0-16777215>", "Advertised metric for this range");


+					routerOSPF.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].addSC("not-advertise", "DoNotAdvertise this range");


+		routerOSPF.area["<0-4294967295>"].addSC("stub", "Specify a stub area");


+			routerOSPF.area["<0-4294967295>"].stub.addSC("no-summary", "Do not send summary LSA into stub area");


+		routerOSPF.area["<0-4294967295>"].addSC("virtual-link", "Define a virtual link and its parameters");


+			routerOSPF.area["<0-4294967295>"]["virtual-link"].addSC("A.B.C.D", "ID (IP addr) associated with virtual link neighbor");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("authentication", "Set authentication type");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].authentication.addSC("message-digest", "Message-digest authentication");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].authentication.addSC("null", "No authentication");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("authentication-key", "Set authentication key");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["authentication-key"].addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["authentication-key"].addSC("LINE", "Authentication key (8 chars)");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("dead-interval", "Dead router detection time");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("hello-interval", "Hello packet interval");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("message-digest-key", "Set message digest key");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["message-digest-key"].addSC("<1-255>", "Key ID");


+						routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].addSC("md5", "Use MD5 algorithm");


+							routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+							routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.addSC("LINE", "Authentication key (16 chars)");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("retransmit-interval", "LSA retransmit interval");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].addSC("transmit-delay", "LSA transmission delay");


+					routerOSPF.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"].addSC("<1-8192>", "Seconds");


+	routerOSPF.area.addSC("A.B.C.D", "OSPF area ID in IP address format");


+		routerOSPF.area["A.B.C.D"].addSC("authentication", "Enable authentication");


+			routerOSPF.area["A.B.C.D"].authentication.addSC("message-digest", "Use message-digest authentication");


+		routerOSPF.area["A.B.C.D"].addSC("default-cost", "Set the summary default-cost of a NSSA/stub area");


+			routerOSPF.area["A.B.C.D"]["default-cost"].addSC("<0-16777215>", "Stub's advertised external route metric");


+		routerOSPF.area["A.B.C.D"].addSC("filter-list", "Filter networks between OSPF areas");


+			routerOSPF.area["A.B.C.D"]["filter-list"].addSC("prefix", "Filter prefixes between OSPF areas");


+				routerOSPF.area["A.B.C.D"]["filter-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+					routerOSPF.area["A.B.C.D"]["filter-list"].prefix.WORD.addSC("in", "Filter networks sent to this area");


+					routerOSPF.area["A.B.C.D"]["filter-list"].prefix.WORD.addSC("out", "Filter networks sent from this area");


+		routerOSPF.area["A.B.C.D"].addSC("nssa", "Specify a NSSA area");


+			routerOSPF.area["A.B.C.D"].nssa.addSC("default-information-originate", "Originate Type 7 default into NSSA area");


+				routerOSPF.area["A.B.C.D"].nssa["default-information-originate"].addSC("metric", "OSPF default metric");


+					routerOSPF.area["A.B.C.D"].nssa["default-information-originate"].metric.addSC("<0-16777214>", "OSPF metric");


+				routerOSPF.area["A.B.C.D"].nssa["default-information-originate"].addSC("metric-type", "OSPF metric type for default routes");


+					routerOSPF.area["A.B.C.D"].nssa["default-information-originate"]["metric-type"].addSC("<1-2>", "OSPF Link State type");


+			routerOSPF.area["A.B.C.D"].nssa.addSC("no-redistribution", "No redistribution into this NSSA area");


+			routerOSPF.area["A.B.C.D"].nssa.addSC("no-summary", "Do not send summary LSA into NSSA");


+		routerOSPF.area["A.B.C.D"].addSC("range", "Summarize routes matching address/mask (border routers only)");


+			routerOSPF.area["A.B.C.D"].range.addSC("A.B.C.D", "IP address to match");


+				routerOSPF.area["A.B.C.D"].range["A.B.C.D"].addSC("A.B.C.D", "IP mask for address");


+					routerOSPF.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].addSC("advertise", "Advertise this range (default)");


+					routerOSPF.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].addSC("cost", "User specified metric for this range");


+						routerOSPF.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].cost.addSC("<0-16777215>", "Advertised metric for this range");


+					routerOSPF.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].addSC("not-advertise", "DoNotAdvertise this range");


+		routerOSPF.area["A.B.C.D"].addSC("stub", "Specify a stub area");


+			routerOSPF.area["A.B.C.D"].stub.addSC("no-summary", "Do not send summary LSA into stub area");


+		routerOSPF.area["A.B.C.D"].addSC("virtual-link", "Define a virtual link and its parameters");


+			routerOSPF.area["A.B.C.D"]["virtual-link"].addSC("A.B.C.D", "ID (IP addr) associated with virtual link neighbor");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("authentication", "Set authentication type");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].authentication.addSC("message-digest", "Message-digest authentication");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].authentication.addSC("null", "No authentication");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("authentication-key", "Set authentication key");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["authentication-key"].addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["authentication-key"].addSC("LINE", "Authentication key (8 chars)");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("dead-interval", "Dead router detection time");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("hello-interval", "Hello packet interval");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("message-digest-key", "Set message digest key");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["message-digest-key"].addSC("<1-255>", "Key ID");


+						routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].addSC("md5", "Use MD5 algorithm");


+							routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.addSC("<0-7>", "Encryption type (0 for not yet encrypted, 7 for proprietary)");


+							routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.addSC("LINE", "Authentication key (16 chars)");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("retransmit-interval", "LSA retransmit interval");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"].addSC("<1-8192>", "Seconds");


+				routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].addSC("transmit-delay", "LSA transmission delay");


+					routerOSPF.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"].addSC("<1-8192>", "Seconds");


+routerOSPF.addSC("auto-cost", "Calculate OSPF interface cost according to bandwidth");


+routerOSPF.addSC("capability", "Enable specific OSPF feature");


+routerOSPF.addSC("compatible", "OSPF compatibility list");


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


+routerOSPF.addSC("default-information", "Control distribution of default information");


+	routerOSPF["default-information"].addSC("originate", "Distribute a default route");


+		routerOSPF["default-information"].originate.addSC("always", "Always advertise default route");


+		routerOSPF["default-information"].originate.addSC("metric", "OSPF default metric");


+			routerOSPF["default-information"].originate.metric.addSC("<0-16777214>", "OSPF metric");


+		routerOSPF["default-information"].originate.addSC("metric-type", "OSPF metric type for default routes");


+			routerOSPF["default-information"].originate["metric-type"].addSC("<1-2>", "OSPF Link State type");


+		routerOSPF["default-information"].originate.addSC("route-map", "Route-map reference");


+			routerOSPF["default-information"].originate["route-map"].addSC("WORD", "Route map name");


+routerOSPF.addSC("default-metric", "Set metric of redistributed routes");


+	routerOSPF["default-metric"].addSC("<1-4294967295>", "Default metric");


+routerOSPF.addSC("discard-route", "Enable or disable discard-route installation");


+routerOSPF.addSC("distance", "Define an administrative distance");


+routerOSPF.addSC("distribute-list", "Filter networks in routing updates");


+routerOSPF.addSC("domain-id", "OSPF domain-id");


+	routerOSPF["domain-id"].addSC("A.B.C.D", "OSPF domain ID in IP address format");


+routerOSPF.addSC("domain-tag", "OSPF domain-tag");


+routerOSPF.addSC("exit", "Exit from routing protocol configuration mode");


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


+routerOSPF.addSC("ignore", "Do not complain about specific event");


+routerOSPF.addSC("log-adjacency-changes", "Log changes in adjacency state");


+routerOSPF.addSC("max-metric", "Set maximum metric");


+routerOSPF.addSC("maximum-paths", "Forward packets over multiple paths");


+routerOSPF.addSC("neighbor", "Specify a neighbor router");


+routerOSPF.addSC("network", "Enable routing on an IP network");


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


+routerOSPF.addSC("passive-interface", "Suppress routing updates on an interface");


+	routerOSPF["passive-interface"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+		routerOSPF["passive-interface"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+	routerOSPF["passive-interface"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		routerOSPF["passive-interface"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+	routerOSPF["passive-interface"].addSC("Loopback", "Loopback interface");


+		routerOSPF["passive-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+	routerOSPF["passive-interface"].addSC("Null", "Null interface");


+		routerOSPF["passive-interface"].Null.addSC("<0-0>", "Null interface number");


+	routerOSPF["passive-interface"].addSC("Vlan", "Catalyst Vlans");


+		routerOSPF["passive-interface"].Vlan.addSC("<1-1001>", "Vlan interface number");


+	routerOSPF["passive-interface"].addSC("default", "Suppress routing updates on all interfaces");


+routerOSPF.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerOSPF.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerOSPF.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+	routerOSPF.redistribute.addSC("connected", "Connected");


+	routerOSPF.redistribute.addSC("egp", "Exterior Gateway Protocol (EGP)");


+		routerOSPF.redistribute.egp.addSC("<0-65535>", "Remote autonomous system number");


+	routerOSPF.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerOSPF.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+	routerOSPF.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerOSPF.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+	routerOSPF.redistribute.addSC("isis", "ISO IS-IS");


+		routerOSPF.redistribute.isis.addSC("level-1", "IS-IS level-1 routes only");


+		routerOSPF.redistribute.isis.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+		routerOSPF.redistribute.isis.addSC("level-2", "IS-IS level-2 routes only");


+		routerOSPF.redistribute.isis.addSC("WORD", "ISO routing area tag");


+	routerOSPF.redistribute.addSC("iso-igrp", "IGRP for OSI networks");


+		routerOSPF.redistribute["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	routerOSPF.redistribute.addSC("metric", "Metric for redistributed routes");


+		routerOSPF.redistribute.metric.addSC("<0-16777214>", "OSPF default metric");


+	routerOSPF.redistribute.addSC("metric-type", "OSPF/IS-IS exterior metric type for redistributed routes");


+		routerOSPF.redistribute["metric-type"].addSC("<1-1>", "Set OSPF External Type 1 metrics");


+		routerOSPF.redistribute["metric-type"].addSC("<2-2>", "Set OSPF External Type 2 metrics");


+	routerOSPF.redistribute.addSC("mobile", "Mobile routes");


+	routerOSPF.redistribute.addSC("odr", "On Demand stub Routes");


+	routerOSPF.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerOSPF.redistribute.ospf.addSC("<1-65535>", "Process ID");


+			routerOSPF.redistribute.ospf["<1-65535>"].addSC("match", "Redistribution of OSPF routes");


+				routerOSPF.redistribute.ospf["<1-65535>"].match.addSC("external", "Redistribute OSPF external routes");


+					routerOSPF.redistribute.ospf["<1-65535>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+					routerOSPF.redistribute.ospf["<1-65535>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerOSPF.redistribute.ospf["<1-65535>"].match.addSC("internal", "Redistribute OSPF internal routes");


+				routerOSPF.redistribute.ospf["<1-65535>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+					routerOSPF.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+					routerOSPF.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+			routerOSPF.redistribute.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				routerOSPF.redistribute.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+	routerOSPF.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+	routerOSPF.redistribute.addSC("route-map", "Route map reference");


+		routerOSPF.redistribute["route-map"].addSC("WORD", "Pointer to route-map entries");


+	routerOSPF.redistribute.addSC("static", "Static routes");


+	routerOSPF.redistribute.addSC("subnets", "Consider subnets for redistribution into OSPF");


+	routerOSPF.redistribute.addSC("tag", "Set tag for routes redistributed into OSPF");


+		routerOSPF.redistribute.tag.addSC("<0-4294967295>", "32-bit tag value");


+routerOSPF.addSC("router-id", "router-id for this OSPF process");


+	routerOSPF["router-id"].addSC("A.B.C.D", "OSPF router-id in IP address format");


+routerOSPF.addSC("summary-address", "Configure IP address summaries");


+	routerOSPF["summary-address"].addSC("A.B.C.D", "IP summary address");


+		routerOSPF["summary-address"]["A.B.C.D"].addSC("A.B.C.D", "Summary mask");


+			routerOSPF["summary-address"]["A.B.C.D"]["A.B.C.D"].addSC("not-advertise", "Do not advertise when translating OSPF type-7 LSA");


+			routerOSPF["summary-address"]["A.B.C.D"]["A.B.C.D"].addSC("tag", "Set tag");


+				routerOSPF["summary-address"]["A.B.C.D"]["A.B.C.D"].tag.addSC("<0-4294967295>", "32-bit tag value");


+routerOSPF.addSC("timers", "Adjust routing timers");


+routerOSPF.addSC("traffic-share", "How to compute traffic share over alternate paths");


+	routerOSPF["traffic-share"].addSC("min", "All traffic shared among min metric paths");


+		routerOSPF["traffic-share"].min.addSC("across-interfaces", "Use different interfaces for equal-cost paths");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerRIP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerRIP.txt
new file mode 100644
index 0000000..6d1655f
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_routerRIP.txt
@@ -0,0 +1,405 @@
+


+routerRIPC.addSC("address-family", "Enter Address Family command mode");


+	routerRIPC["address-family"].addSC("ipv4", "Address family");


+		routerRIPC["address-family"].ipv4.addSC("unicast", "Address Family Modifier");


+		routerRIPC["address-family"].ipv4.addSC("vrf", "Specify parameters for a VPN Routing/Forwarding instance");


+			routerRIPC["address-family"].ipv4.vrf.addSC("WORD", "VPN Routing/Forwarding instance name");


+routerRIPC.addSC("auto-summary", "Enable automatic network number summarization");


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


+routerRIPC.addSC("default-information", "Control distribution of default information");


+	routerRIPC["default-information"].addSC("originate", "Distribute a default route");


+		routerRIPC["default-information"].originate.addSC("route-map", "Route-map reference");


+			routerRIPC["default-information"].originate["route-map"].addSC("WORD", "Route map name");


+routerRIPC.addSC("default-metric", "Set metric of redistributed routes");


+routerRIPC.addSC("distance", "Define an administrative distance");


+	routerRIPC.distance.addSC("<1-255>", "Administrative distance");


+		routerRIPC.distance["<1-255>"].addSC("A.B.C.D", "IP Source address");


+			routerRIPC.distance["<1-255>"]["A.B.C.D"].addSC("A.B.C.D", "IP address mask");


+				routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1-99>", "IP Standard access list number");


+				routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("<1300-1999>", "IP Standard expanded access list number");


+				routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].addSC("WORD", "Standard access-list name");


+routerRIPC.addSC("distribute-list", "Filter networks in routing updates");


+	routerRIPC["distribute-list"].addSC("<1-199>", "IP access list number");


+		routerRIPC["distribute-list"]["<1-199>"].addSC("in", "Filter incoming routing updates");


+			routerRIPC["distribute-list"]["<1-199>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1-199>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"]["<1-199>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1-199>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"]["<1-199>"]["in"].addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"]["<1-199>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"]["<1-199>"]["in"].addSC("Null", "Null interface");


+				routerRIPC["distribute-list"]["<1-199>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"]["<1-199>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"]["<1-199>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerRIPC["distribute-list"]["<1-199>"].addSC("out", "Filter outgoing routing updates");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1-199>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1-199>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"]["<1-199>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("Null", "Null interface");


+				routerRIPC["distribute-list"]["<1-199>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"]["<1-199>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerRIPC["distribute-list"]["<1-199>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("connected", "Connected");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerRIPC["distribute-list"]["<1-199>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerRIPC["distribute-list"]["<1-199>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerRIPC["distribute-list"]["<1-199>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerRIPC["distribute-list"]["<1-199>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerRIPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerRIPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerRIPC["distribute-list"]["<1-199>"].out.addSC("static", "Static routes");


+	routerRIPC["distribute-list"].addSC("<1300-2699>", "IP expanded access list number");


+		routerRIPC["distribute-list"]["<1300-2699>"].addSC("in", "Filter incoming routing updates");


+			routerRIPC["distribute-list"]["<1300-2699>"]["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1300-2699>"]["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"]["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1300-2699>"]["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"]["in"].addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"]["<1300-2699>"]["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"]["in"].addSC("Null", "Null interface");


+				routerRIPC["distribute-list"]["<1300-2699>"]["in"].Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"]["in"].addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"]["<1300-2699>"]["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerRIPC["distribute-list"]["<1300-2699>"].addSC("out", "Filter outgoing routing updates");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1300-2699>"].out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("Null", "Null interface");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("connected", "Connected");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerRIPC["distribute-list"]["<1300-2699>"].out.ospf.addSC("<1-65535>", "Process ID");


+					routerRIPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerRIPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerRIPC["distribute-list"]["<1300-2699>"].out.addSC("static", "Static routes");


+	routerRIPC["distribute-list"].addSC("WORD", "Access-list name");


+		routerRIPC["distribute-list"].WORD.addSC("in", "Filter incoming routing updates");


+			routerRIPC["distribute-list"].WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"].WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"].WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"].WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"].WORD["in"].addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"].WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"].WORD["in"].addSC("Null", "Null interface");


+				routerRIPC["distribute-list"].WORD["in"].Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"].WORD["in"].addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"].WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+		routerRIPC["distribute-list"].WORD.addSC("out", "Filter outgoing routing updates");


+			routerRIPC["distribute-list"].WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+				routerRIPC["distribute-list"].WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+			routerRIPC["distribute-list"].WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+				routerRIPC["distribute-list"].WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+			routerRIPC["distribute-list"].WORD.out.addSC("Loopback", "Loopback interface");


+				routerRIPC["distribute-list"].WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+			routerRIPC["distribute-list"].WORD.out.addSC("Null", "Null interface");


+				routerRIPC["distribute-list"].WORD.out.Null.addSC("<0-0>", "Null interface number");


+			routerRIPC["distribute-list"].WORD.out.addSC("Vlan", "Catalyst Vlans");


+				routerRIPC["distribute-list"].WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerRIPC["distribute-list"].WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+				routerRIPC["distribute-list"].WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"].WORD.out.addSC("connected", "Connected");


+			routerRIPC["distribute-list"].WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+				routerRIPC["distribute-list"].WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+			routerRIPC["distribute-list"].WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+				routerRIPC["distribute-list"].WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"].WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+				routerRIPC["distribute-list"].WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+			routerRIPC["distribute-list"].WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+				routerRIPC["distribute-list"].WORD.out.ospf.addSC("<1-65535>", "Process ID");


+					routerRIPC["distribute-list"].WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+						routerRIPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+			routerRIPC["distribute-list"].WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+			routerRIPC["distribute-list"].WORD.out.addSC("static", "Static routes");


+	routerRIPC["distribute-list"].addSC("gateway", "Filtering incoming updates based on gateway");


+		routerRIPC["distribute-list"].gateway.addSC("WORD", "Name of an IP prefix-list");


+			routerRIPC["distribute-list"].gateway.WORD.addSC("in", "Filter incoming routing updates");


+				routerRIPC["distribute-list"].gateway.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerRIPC["distribute-list"].gateway.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerRIPC["distribute-list"].gateway.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerRIPC["distribute-list"].gateway.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerRIPC["distribute-list"].gateway.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerRIPC["distribute-list"].gateway.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerRIPC["distribute-list"].gateway.WORD["in"].addSC("Null", "Null interface");


+					routerRIPC["distribute-list"].gateway.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerRIPC["distribute-list"].gateway.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerRIPC["distribute-list"].gateway.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerRIPC["distribute-list"].gateway.WORD.addSC("out", "Filter outgoing routing updates");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerRIPC["distribute-list"].gateway.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerRIPC["distribute-list"].gateway.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("Loopback", "Loopback interface");


+					routerRIPC["distribute-list"].gateway.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("Null", "Null interface");


+					routerRIPC["distribute-list"].gateway.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerRIPC["distribute-list"].gateway.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerRIPC["distribute-list"].gateway.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("connected", "Connected");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerRIPC["distribute-list"].gateway.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerRIPC["distribute-list"].gateway.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerRIPC["distribute-list"].gateway.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerRIPC["distribute-list"].gateway.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerRIPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerRIPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerRIPC["distribute-list"].gateway.WORD.out.addSC("static", "Static routes");


+	routerRIPC["distribute-list"].addSC("prefix", "Filter prefixes in routing updates");


+		routerRIPC["distribute-list"].prefix.addSC("WORD", "Name of an IP prefix-list");


+			routerRIPC["distribute-list"].prefix.WORD.addSC("gateway", "Filtering incoming updates based on gateway");


+			routerRIPC["distribute-list"].prefix.WORD.addSC("in", "Filter incoming routing updates");


+				routerRIPC["distribute-list"].prefix.WORD["in"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerRIPC["distribute-list"].prefix.WORD["in"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerRIPC["distribute-list"].prefix.WORD["in"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerRIPC["distribute-list"].prefix.WORD["in"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerRIPC["distribute-list"].prefix.WORD["in"].addSC("Loopback", "Loopback interface");


+					routerRIPC["distribute-list"].prefix.WORD["in"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerRIPC["distribute-list"].prefix.WORD["in"].addSC("Null", "Null interface");


+					routerRIPC["distribute-list"].prefix.WORD["in"].Null.addSC("<0-0>", "Null interface number");


+				routerRIPC["distribute-list"].prefix.WORD["in"].addSC("Vlan", "Catalyst Vlans");


+					routerRIPC["distribute-list"].prefix.WORD["in"].Vlan.addSC("<1-1001>", "Vlan interface number");


+			routerRIPC["distribute-list"].prefix.WORD.addSC("out", "Filter outgoing routing updates");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+					routerRIPC["distribute-list"].prefix.WORD.out["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+					routerRIPC["distribute-list"].prefix.WORD.out.GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("Loopback", "Loopback interface");


+					routerRIPC["distribute-list"].prefix.WORD.out.Loopback.addSC("<0-2147483647>", "Loopback interface number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("Null", "Null interface");


+					routerRIPC["distribute-list"].prefix.WORD.out.Null.addSC("<0-0>", "Null interface number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("Vlan", "Catalyst Vlans");


+					routerRIPC["distribute-list"].prefix.WORD.out.Vlan.addSC("<1-1001>", "Vlan interface number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("bgp", "Border Gateway Protocol (BGP)");


+					routerRIPC["distribute-list"].prefix.WORD.out.bgp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("connected", "Connected");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("egp", "Exterior Gateway Protocol (EGP)");


+					routerRIPC["distribute-list"].prefix.WORD.out.egp.addSC("<0-65535>", "Remote autonomous system number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+					routerRIPC["distribute-list"].prefix.WORD.out.eigrp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+					routerRIPC["distribute-list"].prefix.WORD.out.igrp.addSC("<1-65535>", "Autonomous system number");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("ospf", "Open Shortest Path First (OSPF)");


+					routerRIPC["distribute-list"].prefix.WORD.out.ospf.addSC("<1-65535>", "Process ID");


+						routerRIPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+							routerRIPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("rip", "Routing Information Protocol (RIP)");


+				routerRIPC["distribute-list"].prefix.WORD.out.addSC("static", "Static routes");


+routerRIPC.addSC("exit", "Exit from routing protocol configuration mode");


+routerRIPC.addSC("flash-update-threshold", "Specify flash update threshold in second");


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


+routerRIPC.addSC("input-queue", "Specify input queue depth");


+routerRIPC.addSC("maximum-paths", "Forward packets over multiple paths");


+	routerRIPC["maximum-paths"].addSC("<1-8>", "Number of paths");


+routerRIPC.addSC("neighbor", "Specify a neighbor router");


+	routerRIPC.neighbor.addSC("A.B.C.D", "Neighbor address");


+routerRIPC.addSC("network", "Enable routing on an IP network");


+	routerRIPC.network.addSC("A.B.C.D", "Network number");


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


+routerRIPC.addSC("offset-list", "Add or subtract offset from IGRP or RIP metrics");


+routerRIPC.addSC("output-delay", "Interpacket delay for RIP updates");


+routerRIPC.addSC("passive-interface", "Suppress routing updates on an interface");


+	routerRIPC["passive-interface"].addSC("GE-WAN", "GigabitEthernetWAN IEEE 802.3z");


+		routerRIPC["passive-interface"]["GE-WAN"].addSC("<1-6>", "GE-WAN interface number");


+	routerRIPC["passive-interface"].addSC("GigabitEthernet", "GigabitEthernet IEEE 802.3z");


+		routerRIPC["passive-interface"].GigabitEthernet.addSC("<1-6>", "GigabitEthernet interface number");


+	routerRIPC["passive-interface"].addSC("Loopback", "Loopback interface");


+		routerRIPC["passive-interface"].Loopback.addSC("<0-2147483647>", "Loopback interface number");


+	routerRIPC["passive-interface"].addSC("Null", "Null interface");


+		routerRIPC["passive-interface"].Null.addSC("<0-0>", "Null interface number");


+	routerRIPC["passive-interface"].addSC("Vlan", "Catalyst Vlans");


+		routerRIPC["passive-interface"].Vlan.addSC("<1-1001>", "Vlan interface number");


+	routerRIPC["passive-interface"].addSC("default", "Suppress routing updates on all interfaces");


+routerRIPC.addSC("redistribute", "Redistribute information from another routing protocol");


+	routerRIPC.redistribute.addSC("bgp", "Border Gateway Protocol (BGP)");


+		routerRIPC.redistribute.bgp.addSC("<1-65535>", "Autonomous system number");


+	routerRIPC.redistribute.addSC("connected", "Connected");


+	routerRIPC.redistribute.addSC("egp", "Exterior Gateway Protocol (EGP)");


+		routerRIPC.redistribute.egp.addSC("<0-65535>", "Remote autonomous system number");


+	routerRIPC.redistribute.addSC("eigrp", "Enhanced Interior Gateway Routing Protocol (EIGRP)");


+		routerRIPC.redistribute.eigrp.addSC("<1-65535>", "Autonomous system number");


+	routerRIPC.redistribute.addSC("igrp", "Interior Gateway Routing Protocol (IGRP)");


+		routerRIPC.redistribute.igrp.addSC("<1-65535>", "Autonomous system number");


+	routerRIPC.redistribute.addSC("isis", "ISO IS-IS");


+		routerRIPC.redistribute.isis.addSC("level-1", "IS-IS level-1 routes only");


+		routerRIPC.redistribute.isis.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+		routerRIPC.redistribute.isis.addSC("level-2", "IS-IS level-2 routes only");


+		routerRIPC.redistribute.isis.addSC("WORD", "ISO routing area tag");


+			routerRIPC.redistribute.isis.WORD.addSC("level-1", "IS-IS level-1 routes only");


+			routerRIPC.redistribute.isis.WORD.addSC("level-1-2", "IS-IS level-1 and level-2 routes");


+			routerRIPC.redistribute.isis.WORD.addSC("level-2", "IS-IS level-2 routes only");


+	routerRIPC.redistribute.addSC("iso-igrp", "IGRP for OSI networks");


+		routerRIPC.redistribute["iso-igrp"].addSC("WORD", "ISO routing area tag");


+	routerRIPC.redistribute.addSC("metric", "Metric for redistributed routes");


+		routerRIPC.redistribute.metric.addSC("<0-16>", "Default metric");


+		routerRIPC.redistribute.metric.addSC("transparent", "Transparently redistribute metric");


+	routerRIPC.redistribute.addSC("mobile", "Mobile routes");


+		routerRIPC.redistribute.mobile.addSC("metric", "Metric for redistributed routes");


+			routerRIPC.redistribute.mobile.metric.addSC("<0-16>", "Default metric");


+			routerRIPC.redistribute.mobile.metric.addSC("transparent", "Transparently redistribute metric");


+	routerRIPC.redistribute.addSC("odr", "On Demand stub Routes");


+		routerRIPC.redistribute.odr.addSC("metric", "Metric for redistributed routes");


+			routerRIPC.redistribute.odr.metric.addSC("<0-16>", "Default metric");


+			routerRIPC.redistribute.odr.metric.addSC("transparent", "Transparently redistribute metric");


+	routerRIPC.redistribute.addSC("ospf", "Open Shortest Path First (OSPF)");


+		routerRIPC.redistribute.ospf.addSC("<1-65535>", "Process ID");


+			routerRIPC.redistribute.ospf["<1-65535>"].addSC("match", "Redistribution of OSPF routes");


+				routerRIPC.redistribute.ospf["<1-65535>"].match.addSC("external", "Redistribute OSPF external routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerRIPC.redistribute.ospf["<1-65535>"].match.addSC("internal", "Redistribute OSPF internal routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match.internal.addSC("external", "Redistribute OSPF external routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerRIPC.redistribute.ospf["<1-65535>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+			routerRIPC.redistribute.ospf["<1-65535>"].addSC("metric", "Metric for redistributed routes");


+				routerRIPC.redistribute.ospf["<1-65535>"].metric.addSC("<0-16>", "Default metric");


+					routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].addSC("match", "Redistribution of OSPF routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.addSC("external", "Redistribute OSPF external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.addSC("internal", "Redistribute OSPF internal routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+				routerRIPC.redistribute.ospf["<1-65535>"].metric.addSC("transparent", "Transparently redistribute metric");


+					routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.addSC("match", "Redistribution of OSPF routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.addSC("external", "Redistribute OSPF external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.addSC("internal", "Redistribute OSPF internal routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+			routerRIPC.redistribute.ospf["<1-65535>"].addSC("vrf", "VPN Routing/Forwarding Instance");


+				routerRIPC.redistribute.ospf["<1-65535>"].vrf.addSC("WORD", "VPN Routing/Forwarding Instance (VRF) name");


+					routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("match", "Redistribution of OSPF routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("external", "Redistribute OSPF external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("internal", "Redistribute OSPF internal routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<1-1>", "Redistribute external type 1 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.addSC("<2-2>", "Redistribute external type 2 routes");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.addSC("<2-2>", "Redistribute external type 2 routes");


+					routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.addSC("metric", "Metric for redistributed routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.addSC("<0-16>", "Default metric");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].addSC("match", "Redistribution of OSPF routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.addSC("internal", "Redistribute OSPF internal routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+						routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.addSC("transparent", "Transparently redistribute metric");


+							routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.addSC("match", "Redistribution of OSPF routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.external.addSC("<1-1>", "Redistribute external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.external.addSC("<2-2>", "Redistribute external type 2 routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.addSC("internal", "Redistribute OSPF internal routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.internal.addSC("external", "Redistribute OSPF external routes");


+								routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.addSC("nssa-external", "Redistribute OSPF NSSA external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match["nssa-external"].addSC("<1-1>", "Redistribute NSSA external type 1 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match["nssa-external"].addSC("<2-2>", "Redistribute NSSA external type 2 routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match["nssa-external"].addSC("external", "Redistribute OSPF external routes");


+									routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match["nssa-external"].addSC("internal", "Redistribute OSPF internal routes");


+	routerRIPC.redistribute.addSC("rip", "Routing Information Protocol (RIP)");


+		routerRIPC.redistribute.rip.addSC("metric", "Metric for redistributed routes");


+			routerRIPC.redistribute.rip.metric.addSC("<0-16>", "Default metric");


+			routerRIPC.redistribute.rip.metric.addSC("transparent", "Transparently redistribute metric");


+	routerRIPC.redistribute.addSC("route-map", "Route map reference");


+		routerRIPC.redistribute["route-map"].addSC("WORD", "Pointer to route-map entries");


+			routerRIPC.redistribute["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+				routerRIPC.redistribute["route-map"].WORD.metric.addSC("<0-16>", "Default metric");


+				routerRIPC.redistribute["route-map"].WORD.metric.addSC("transparent", "Transparently redistribute metric");


+	routerRIPC.redistribute.addSC("static", "Static routes");


+		routerRIPC.redistribute.static.addSC("metric", "Metric for redistributed routes");


+			routerRIPC.redistribute.static.metric.addSC("<0-16>", "Default metric");


+			routerRIPC.redistribute.static.metric.addSC("transparent", "Transparently redistribute metric");


+		routerRIPC.redistribute.static.addSC("route-map", "Route map reference");


+			routerRIPC.redistribute.static["route-map"].addSC("WORD", "Pointer to route-map entries");


+				routerRIPC.redistribute.static["route-map"].WORD.addSC("metric", "Metric for redistributed routes");


+					routerRIPC.redistribute.static["route-map"].WORD.metric.addSC("<0-16>", "Default metric");


+					routerRIPC.redistribute.static["route-map"].WORD.metric.addSC("transparent", "Transparently redistribute metric");


+routerRIPC.addSC("timers", "Adjust routing timers");


+	routerRIPC.timers.addSC("basic", "Basic routing protocol update timers");


+		routerRIPC.timers.basic.addSC("<0-4294967295>", "Interval between updates");


+			routerRIPC.timers.basic["<0-4294967295>"].addSC("<1-4294967295>", "Invalid");


+				routerRIPC.timers.basic["<0-4294967295>"]["<1-4294967295>"].addSC("<0-4294967295>", "Holddown");


+					routerRIPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"].addSC("<1-4294967295>", "Flush");


+						routerRIPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"].addSC("<1-4294967295>", "Sleep time, in milliseconds");


+routerRIPC.addSC("traffic-share", "How to compute traffic share over alternate paths");


+	routerRIPC["traffic-share"].addSC("min", "All traffic shared among min metric paths");


+		routerRIPC["traffic-share"].min.addSC("across-interfaces", "Use different interfaces for equal-cost paths");


+routerRIPC.addSC("validate-update-source", "Perform sanity checks against source address of routing updates");


+routerRIPC.addSC("version", "Set routing protocol version");


+	routerRIPC.version.addSC("<1-2>", "version");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_timeRange.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_timeRange.txt
new file mode 100644
index 0000000..fa59188
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_timeRange.txt
@@ -0,0 +1,150 @@
+


+timeRangeC.addSC("absolute", "absolute time and date");


+	timeRangeC.absolute.addSC("end", "ending time and date");


+		timeRangeC.absolute.end.addSC("hh:mm", "Ending time - stays valid until beginning of next minute");


+	timeRangeC.absolute.addSC("start", "starting time and date");


+		timeRangeC.absolute.start.addSC("hh:mm", "Starting time");


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


+timeRangeC.addSC("exit", "Exit from time-range configuration mode");


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


+timeRangeC.addSC("periodic", "periodic time and date");


+	timeRangeC.periodic.addSC("Friday", "Friday");


+		timeRangeC.periodic.Friday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Monday", "Monday");


+		timeRangeC.periodic.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Monday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Saturday", "Saturday");


+		timeRangeC.periodic.Saturday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Saturday.addSC("Monday", "Monday");


+			timeRangeC.periodic.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Saturday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Sunday", "Sunday");


+		timeRangeC.periodic.Sunday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Sunday.addSC("Monday", "Monday");


+			timeRangeC.periodic.Sunday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Sunday.addSC("Saturday", "Saturday");


+			timeRangeC.periodic.Sunday.Saturday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Sunday.Saturday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Sunday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Thursday", "Thursday");


+		timeRangeC.periodic.Thursday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Thursday.addSC("Monday", "Monday");


+			timeRangeC.periodic.Thursday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Thursday.addSC("Saturday", "Saturday");


+			timeRangeC.periodic.Thursday.Saturday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Thursday.Saturday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Thursday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Thursday.addSC("Sunday", "Sunday");


+			timeRangeC.periodic.Thursday.Sunday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Thursday.Sunday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Thursday.Sunday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Thursday.Sunday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Thursday.Sunday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Thursday.Sunday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Thursday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Thursday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Tuesday", "Tuesday");


+		timeRangeC.periodic.Tuesday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Tuesday.addSC("Monday", "Monday");


+			timeRangeC.periodic.Tuesday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Tuesday.addSC("Saturday", "Saturday");


+			timeRangeC.periodic.Tuesday.Saturday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Saturday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Tuesday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Tuesday.addSC("Sunday", "Sunday");


+			timeRangeC.periodic.Tuesday.Sunday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Sunday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Tuesday.Sunday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Sunday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Tuesday.Sunday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Tuesday.Sunday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Tuesday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Tuesday.addSC("Thursday", "Thursday");


+			timeRangeC.periodic.Tuesday.Thursday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Thursday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Tuesday.Thursday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Thursday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Tuesday.Thursday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Tuesday.Thursday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Tuesday.Thursday.Saturday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Tuesday.Thursday.addSC("Sunday", "Sunday");


+				timeRangeC.periodic.Tuesday.Thursday.Sunday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Tuesday.Thursday.Sunday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Tuesday.Thursday.Sunday.Monday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Tuesday.Thursday.Sunday.addSC("Saturday", "Saturday");


+					timeRangeC.periodic.Tuesday.Thursday.Sunday.Saturday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Tuesday.Thursday.Sunday.Saturday.addSC("Monday", "Monday");


+						timeRangeC.periodic.Tuesday.Thursday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Tuesday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("Wednesday", "Wednesday");


+		timeRangeC.periodic.Wednesday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("Monday", "Monday");


+			timeRangeC.periodic.Wednesday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("Saturday", "Saturday");


+			timeRangeC.periodic.Wednesday.Saturday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Saturday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Wednesday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("Sunday", "Sunday");


+			timeRangeC.periodic.Wednesday.Sunday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Sunday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Wednesday.Sunday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Sunday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Wednesday.Sunday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Sunday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("Thursday", "Thursday");


+			timeRangeC.periodic.Wednesday.Thursday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Thursday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Wednesday.Thursday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Thursday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Wednesday.Thursday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Thursday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Thursday.Saturday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Thursday.addSC("Sunday", "Sunday");


+				timeRangeC.periodic.Wednesday.Thursday.Sunday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Thursday.Sunday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Thursday.Sunday.Monday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Thursday.Sunday.addSC("Saturday", "Saturday");


+					timeRangeC.periodic.Wednesday.Thursday.Sunday.Saturday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Wednesday.Thursday.Sunday.Saturday.addSC("Monday", "Monday");


+						timeRangeC.periodic.Wednesday.Thursday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("Tuesday", "Tuesday");


+			timeRangeC.periodic.Wednesday.Tuesday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Tuesday.addSC("Monday", "Monday");


+				timeRangeC.periodic.Wednesday.Tuesday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Tuesday.addSC("Saturday", "Saturday");


+				timeRangeC.periodic.Wednesday.Tuesday.Saturday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Saturday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Tuesday.Saturday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Tuesday.addSC("Sunday", "Sunday");


+				timeRangeC.periodic.Wednesday.Tuesday.Sunday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Sunday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Tuesday.Sunday.Monday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Sunday.addSC("Saturday", "Saturday");


+					timeRangeC.periodic.Wednesday.Tuesday.Sunday.Saturday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Wednesday.Tuesday.Sunday.Saturday.addSC("Monday", "Monday");


+						timeRangeC.periodic.Wednesday.Tuesday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+			timeRangeC.periodic.Wednesday.Tuesday.addSC("Thursday", "Thursday");


+				timeRangeC.periodic.Wednesday.Tuesday.Thursday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Thursday.addSC("Monday", "Monday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Monday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Thursday.addSC("Saturday", "Saturday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Saturday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Saturday.addSC("Monday", "Monday");


+						timeRangeC.periodic.Wednesday.Tuesday.Thursday.Saturday.Monday.addSC("Friday", "Friday");


+				timeRangeC.periodic.Wednesday.Tuesday.Thursday.addSC("Sunday", "Sunday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.addSC("Monday", "Monday");


+						timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.Monday.addSC("Friday", "Friday");


+					timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.addSC("Saturday", "Saturday");


+						timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.Saturday.addSC("Friday", "Friday");


+						timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.Saturday.addSC("Monday", "Monday");


+							timeRangeC.periodic.Wednesday.Tuesday.Thursday.Sunday.Saturday.Monday.addSC("Friday", "Friday");


+		timeRangeC.periodic.Wednesday.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("daily", "Every day of the week");


+		timeRangeC.periodic.daily.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("weekdays", "Monday thru Friday");


+		timeRangeC.periodic.weekdays.addSC("hh:mm", "Starting time");


+	timeRangeC.periodic.addSC("weekend", "Saturday and Sunday");


+		timeRangeC.periodic.weekend.addSC("hh:mm", "Starting time");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_user.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_user.txt
new file mode 100644
index 0000000..46dab6a
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_user.txt
@@ -0,0 +1,270 @@
+


+userC.addSC("cd", "Set default flash device");


+userC.addSC("dir", "Show list of files on flash device");


+userC.addSC("enable", "Enable privileged mode");


+userC.addSC("help", "Show this help screen");


+userC.addSC("history", "Show contents of history substitution buffer");


+userC.addSC("l2trace", "Layer2 trace between hosts");


+userC.addSC("ping", "Send echo packets to hosts");


+	userC.ping.addSC("-s", "Ping parameter");


+		userC.ping["-s"].addSC("<host>", "IP address or hostname");


+			userC.ping["-s"]["<host>"].addSC("<packet_size>", "Size of the packet (56..1472 bytes)");


+				userC.ping["-s"]["<host>"]["<packet_size>"].addSC("<packet_count>", "Number of packets");


+	userC.ping.addSC("<host>", "IP address or hostname");


+userC.addSC("pwd", "Show default flash device");


+userC.addSC("quit", "Exit from the Admin session");


+userC.addSC("session", "Tunnel to ATM or Router module");


+userC.addSC("set", "Set commands, use 'set help' for more info");


+userC.addSC("show", "Show commands, use 'show help' for more info");


+	userC.show.addSC("accounting", "Show accounting information");


+	userC.show.addSC("alias", "Show aliases for commands");


+	userC.show.addSC("arp", "Show ARP table");


+	userC.show.addSC("authentication", "Show authentication information");


+	userC.show.addSC("authorization", "Show authorization information");


+	userC.show.addSC("banner", "Show system banner");


+	userC.show.addSC("boot", "Show booting environment variables");


+	userC.show.addSC("cam", "Show CAM table");


+	userC.show.addSC("cdp", "Show Cisco Discovery Protocol Information");


+	userC.show.addSC("cgmp", "Show CGMP info");


+	userC.show.addSC("channel", "Show channel information");


+	userC.show.addSC("counters", "Show port counters");


+	userC.show.addSC("dot1q-all-tagged", "Show dot1q tag status");


+	userC.show.addSC("dot1x", "Show dot1x port capability & version");


+	userC.show.addSC("dvlan", "Show dynamic vlan statistics");


+		userC.show.dvlan.addSC("statistics", "Show Dynamic Vlan statistic info");


+	userC.show.addSC("environment", "Show environment information");


+	userC.show.addSC("errdisable-timeout", "Show err-disable timeout config");


+	userC.show.addSC("errordetection", "Show errordetection settings");


+	userC.show.addSC("flash", "Show file information on flash device");


+	userC.show.addSC("garp", "Show GARP information");


+	userC.show.addSC("gmrp", "Show GMRP information");


+	userC.show.addSC("gvrp", "Show GVRP information");


+	userC.show.addSC("imagemib", "Show image mib information");


+	userC.show.addSC("interface", "Show network interfaces");


+	userC.show.addSC("ip", "Show IP Information");


+		userC.show.ip.addSC("alias", "Show IP address aliases");


+		userC.show.ip.addSC("dns", "Show IP DNS information");


+		userC.show.ip.addSC("http", "Show IP HTTP information");


+		userC.show.ip.addSC("route", "Show IP routing table");


+	userC.show.addSC("kerberos", "Show kerberos configuration information");


+	userC.show.addSC("log", "Show log information");


+	userC.show.addSC("logging", "Show system logging information");


+	userC.show.addSC("mac", "Show MAC information");


+		userC.show.mac.addSC("<mod>", "Module number");


+		userC.show.mac.addSC("<mod/port>", "Module number and Port number(s)");


+	userC.show.addSC("mls", "Show multilayer switching information");


+		userC.show.mls.addSC("entry", "Show MLS entries");


+			userC.show.mls.entry.addSC("destination", "Show IP entry destination");


+				userC.show.mls.entry.destination.addSC("<ip_addr_spec>", "ip_addr or ip_addr/netmask or ip_addr/maskbit");


+			userC.show.mls.entry.addSC("ip", "Show IP entry");


+				userC.show.mls.entry.ip.addSC("destination", "Show IP entry destination");


+				userC.show.mls.entry.ip.addSC("qos", "Show QoS entry");


+				userC.show.mls.entry.ip.addSC("rp", "Show IP entry");


+				userC.show.mls.entry.ip.addSC("source", "Show IP entry source");


+				userC.show.mls.entry.ip.addSC("flow", "Show IP entry flow");


+			userC.show.mls.entry.addSC("ipx", "Show IPX entry");


+			userC.show.mls.entry.addSC("qos", "Show QoS entry");


+			userC.show.mls.entry.addSC("rp", "Show IP entry");


+			userC.show.mls.entry.addSC("source", "Show IP entry source");


+				userC.show.mls.entry.source.addSC("<ip_addr_spec>", "ip_addr or ip_addr/netmask or ip_addr/maskbit");


+			userC.show.mls.entry.addSC("flow", "Show IP entry flow");


+		userC.show.mls.addSC("nde", "Show Netflow Data Export information");


+		userC.show.mls.addSC("include", "Show routers included as MLS-RP");


+			userC.show.mls.include.addSC("ip", "Show IP entry");


+			userC.show.mls.include.addSC("ipx", "Show IPX entry");


+			userC.show.mls.include.addSC("noalias", "Don't show alias name");


+		userC.show.mls.addSC("multicast", "Show MLS feature info for multicast");


+			userC.show.mls.multicast.addSC("entry", "Show multicast shortcut info for a given entry");


+			userC.show.mls.multicast.addSC("include", "Show all the routers that can download shortcuts to this switch");


+			userC.show.mls.multicast.addSC("statistics", "Show MLS-RP statistics");


+		userC.show.mls.addSC("rp", "Show information for MLS-RP");


+			userC.show.mls.rp.addSC("ip", "Show IP entry");


+				userC.show.mls.rp.ip.addSC("<host>", "IP address or hostname");


+			userC.show.mls.rp.addSC("ipx", "Show IPX entry");


+			userC.show.mls.rp.addSC("<host>", "IP address or hostname");


+				userC.show.mls.rp["<host>"].addSC("noalias", "Don't show alias name");


+		userC.show.mls.addSC("statistics", "Show MLS statistics");


+			userC.show.mls.statistics.addSC("entry", "Show MLS entry");


+				userC.show.mls.statistics.entry.addSC("ip", "Show IP entry");


+				userC.show.mls.statistics.entry.addSC("ipx", "Show IPX entry");


+				userC.show.mls.statistics.entry.addSC("destination", "Show IP entry destination");


+				userC.show.mls.statistics.entry.addSC("source", "Show IP entry source");


+				userC.show.mls.statistics.entry.addSC("flow", "Show IP entry flow");


+			userC.show.mls.statistics.addSC("ip", "Show IP entry");


+				userC.show.mls.statistics.ip.addSC("rp", "Show MLS entry");


+			userC.show.mls.statistics.addSC("ipx", "Show IPX entry");


+				userC.show.mls.statistics.ipx.addSC("rp", "Show MLS entry");


+			userC.show.mls.statistics.addSC("protocol", "Show MLS protocol statistic info");


+			userC.show.mls.statistics.addSC("rp", "Show MLS protocol router processor statistic info");


+				userC.show.mls.statistics.rp.addSC("noalias", "Don't show host in DNS name format");


+				userC.show.mls.statistics.rp.addSC("<ip_addr>", "IP address");


+	userC.show.addSC("module", "Show module info");


+		userC.show.module.addSC("<mod>", "Module number");


+	userC.show.addSC("multicast", "Show multicast information");


+	userC.show.addSC("netstat", "Show network statistics");


+	userC.show.addSC("ntp", "Show ntp statistics");


+	userC.show.addSC("nvramenv", "Show environment variables");


+	userC.show.addSC("port", "Show port information");


+		userC.show.port.addSC("auxiliaryvlan", "Show port auxiliary vlan information");


+			userC.show.port.auxiliaryvlan.addSC("none", "Show ports that have no auxiliary vlan");


+			userC.show.port.auxiliaryvlan.addSC("untagged", "Show ports that have untagged auxiliary vlan");


+			userC.show.port.auxiliaryvlan.addSC("<vlan>", "VLAN number");


+		userC.show.port.addSC("cdp", "Show port CDP information");


+			userC.show.port.cdp.addSC("<mod>", "Module number");


+			userC.show.port.cdp.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("capabilities", "Show port capabilities");


+			userC.show.port.capabilities.addSC("<mod>", "Module number");


+			userC.show.port.capabilities.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("channel", "Show port channel information");


+			userC.show.port.channel.addSC("info", "Show port channel information");


+			userC.show.port.channel.addSC("statistics", "Show port channel statistics");


+			userC.show.port.channel.addSC("<mod>", "Module number");


+				userC.show.port.channel["<mod>"].addSC("info", "Show port channel information");


+				userC.show.port.channel["<mod>"].addSC("statistics", "Show port channel statistics");


+			userC.show.port.channel.addSC("<mod/port>", "Module number and Port number");


+				userC.show.port.channel["<mod/port>"].addSC("info", "Show port channel information");


+				userC.show.port.channel["<mod/port>"].addSC("statistics", "Show port channel statistics");


+		userC.show.port.addSC("counters", "Show port counters");


+			userC.show.port.counters.addSC("<mod>", "Module number");


+			userC.show.port.counters.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("dot1x", "Show port dot1x information");


+		userC.show.port.addSC("flowcontrol", "Show port traffic flowcontrol");


+			userC.show.port.flowcontrol.addSC("<mod>", "Module number");


+			userC.show.port.flowcontrol.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("ifindex", "Show port IfIndex information");


+			userC.show.port.ifindex.addSC("<mod>", "Module number");


+			userC.show.port.ifindex.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("inlinepower", "Show inline power for port(s)");


+			userC.show.port.inlinepower.addSC("<mod>", "Module number");


+			userC.show.port.inlinepower.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("mac", "Show port MAC counters");


+			userC.show.port.mac.addSC("<mod>", "Module number");


+			userC.show.port.mac.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("negotiation", "Show port negotiation");


+			userC.show.port.negotiation.addSC("<mod>", "Module number");


+			userC.show.port.negotiation.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("protocol", "Show port protocol membership");


+			userC.show.port.protocol.addSC("<mod>", "Module number");


+			userC.show.port.protocol.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("security", "Show port security information");


+		userC.show.port.addSC("spantree", "Show port spantree information");


+			userC.show.port.spantree.addSC("<mod>", "Module number");


+			userC.show.port.spantree.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("status", "Show port status");


+			userC.show.port.status.addSC("<mod>", "Module number");


+			userC.show.port.status.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("trap", "Show port trap information");


+			userC.show.port.trap.addSC("<mod>", "Module number");


+			userC.show.port.trap.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("trunk", "Show port trunk information");


+			userC.show.port.trunk.addSC("<mod>", "Module number");


+			userC.show.port.trunk.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.port.addSC("<mod>", "Module number");


+		userC.show.port.addSC("<mod/port>", "Module number and Port number(s)");


+	userC.show.addSC("protocolfilter", "Show protocolfilter information");


+	userC.show.addSC("pvlan", "Show Private Vlan Information");


+		userC.show.pvlan.addSC("<vlan>", "Show Private Vlan's Config");


+		userC.show.pvlan.addSC("capability", "Determine if a Port can be made a private port");


+			userC.show.pvlan.capability.addSC("<mod/port>", "Port");


+		userC.show.pvlan.addSC("community", "Show Config for Community Private Vlans");


+		userC.show.pvlan.addSC("isolated", "Show Config for Isolated Private Vlans");


+		userC.show.pvlan.addSC("mapping", "Show Private Vlan Mappings");


+		userC.show.pvlan.addSC("primary", "Show Config for Primary Private Vlans");


+		userC.show.pvlan.addSC("twoway-community", "Show Config for Twoway Community Private Vlans");


+	userC.show.addSC("qos", "Show QOS information");


+	userC.show.addSC("radius", "Show RADIUS information");


+	userC.show.addSC("reset", "Show schedule reset information");


+	userC.show.addSC("rspan", "Show remote switch port analyzer information");


+	userC.show.addSC("snmp", "Show SNMP information");


+	userC.show.addSC("span", "Show switch port analyzer information");


+		userC.show.span.addSC("all", "Show both local and remote span sessions");


+	userC.show.addSC("spantree", "Show spantree information");


+		userC.show.spantree.addSC("active", "Show active ports in spanning tree");


+		userC.show.spantree.addSC("backbonefast", "Show spanning tree backbone fast");


+		userC.show.spantree.addSC("blockedports", "Show ports that are blocked");


+			userC.show.spantree.blockedports.addSC("mistp-instance", "Show blocked ports in an MISTP instance");


+				userC.show.spantree.blockedports["mistp-instance"].addSC("<instance>", "Instance number for MISTP");


+			userC.show.spantree.blockedports.addSC("<vlan>", "VLAN number for PVST+");


+		userC.show.spantree.addSC("bpdu-skewing", "Show spanning tree bpdu skewing statistics");


+			userC.show.spantree["bpdu-skewing"].addSC("mistp-instance", "Show bpdu skewing statistics for MISTP instance");


+				userC.show.spantree["bpdu-skewing"]["mistp-instance"].addSC("<instance>", "Instance number for MISTP");


+			userC.show.spantree["bpdu-skewing"].addSC("<vlan>", "VLAN number for PVST+");


+		userC.show.spantree.addSC("conflicts", "Show spanning tree conflicting info for vlan");


+			userC.show.spantree.conflicts.addSC("<vlan>", "VLAN number");


+		userC.show.spantree.addSC("defaultcostmode", "Show spanning tree port cost mode");


+		userC.show.spantree.addSC("guard", "Show spanning tree guard info");


+			userC.show.spantree.guard.addSC("mistp-instance", "Show rootguard info for MISTP instance");


+				userC.show.spantree.guard["mistp-instance"].addSC("<instance>", "Instance number for MISTP");


+				userC.show.spantree.guard["mistp-instance"].addSC("<mod/port>", "Module number and Port number(s)");


+			userC.show.spantree.guard.addSC("<mod/port>", "Module number and Port number(s)");


+			userC.show.spantree.guard.addSC("<vlan>", "VLAN number for PVST+");


+		userC.show.spantree.addSC("mapping", "Show spanning tree vlan and instance mapping");


+			userC.show.spantree.mapping.addSC("config", "Mapping configurations on local switch");


+		userC.show.spantree.addSC("mistp-instance", "Show spantree info for MISTP instance");


+			userC.show.spantree["mistp-instance"].addSC("active", "Show active ports in instances");


+			userC.show.spantree["mistp-instance"].addSC("tunnel", "Show tunneling instance");


+			userC.show.spantree["mistp-instance"].addSC("<instance>", "Instance number for MISTP");


+				userC.show.spantree["mistp-instance"]["<instance>"].addSC("active", "Show active ports in instance");


+			userC.show.spantree["mistp-instance"].addSC("<mod/port>", "Module number and Port number(s)");


+				userC.show.spantree["mistp-instance"]["<mod/port>"].addSC("active", "Show active ports in instance");


+		userC.show.spantree.addSC("portfast", "Show spanning tree port fast info");


+		userC.show.spantree.addSC("portinstancecost", "Show spanning tree port instance cost");


+			userC.show.spantree.portinstancecost.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.spantree.addSC("portvlancost", "Show spanning tree port vlan cost");


+			userC.show.spantree.portvlancost.addSC("<mod/port>", "Module number and Port number(s)");


+			userC.show.spantree.portvlancost.addSC("extended-range", "Shows portvlancost for extended range");


+		userC.show.spantree.addSC("statistics", "Show spanning tree statistic info");


+			userC.show.spantree.statistics.addSC("<mod/port>", "Module number and Port number(s)");


+				userC.show.spantree.statistics["<mod/port>"].addSC("mistp-instance", "Show statistics for MISTP instance");


+				userC.show.spantree.statistics["<mod/port>"].addSC("<vlan>", "VLAN number for PVST+");


+		userC.show.spantree.addSC("summary", "Show spanning tree summary");


+			userC.show.spantree.summary.addSC("mistp-instance", "MISTP spantree summary");


+				userC.show.spantree.summary["mistp-instance"].addSC("noinstance", "Spantree summary without per instance info");


+			userC.show.spantree.summary.addSC("novlan", "Spantree summary without per vlan info");


+		userC.show.spantree.addSC("uplinkfast", "Show spanning tree uplink fast");


+			userC.show.spantree.uplinkfast.addSC("mistp-instance", "Show uplinkfast for MISTP instances");


+				userC.show.spantree.uplinkfast["mistp-instance"].addSC("<instance>", "MISTP Instance number(s)");


+			userC.show.spantree.uplinkfast.addSC("<vlan>", "VLAN number for PVST+");


+		userC.show.spantree.addSC("<mod/port>", "Module number and Port number(s)");


+		userC.show.spantree.addSC("<vlan>", "VLAN number for PVST+");


+	userC.show.addSC("summertime", "Show state of summertime information");


+	userC.show.addSC("switchacceleration", "Show switch acceleration status");


+	userC.show.addSC("system", "Show system information");


+	userC.show.addSC("tacacs", "Show TACACS information");


+	userC.show.addSC("test", "Show results of diagnostic tests");


+	userC.show.addSC("time", "Show time of day");


+	userC.show.addSC("timezone", "Show the current timezone offset");


+	userC.show.addSC("top", "Show TopN report");


+	userC.show.addSC("trunk", "Show trunk ports");


+		userC.show.trunk.addSC("detail", "Show detailed information");


+		userC.show.trunk.addSC("<mod>", "Module number");


+			userC.show.trunk["<mod>"].addSC("detail", "Show detailed information");


+		userC.show.trunk.addSC("<mod/port>", "Module number and Port number(s)");


+			userC.show.trunk["<mod/port>"].addSC("detail", "Show detailed information");


+	userC.show.addSC("udld", "Show Uni-directional Link Detection information");


+	userC.show.addSC("users", "Show active Admin sessions");


+	userC.show.addSC("version", "Show version information");


+		userC.show.version.addSC("<mod>", "Module number");


+	userC.show.addSC("vlan", "Show Virtual LAN information");


+		userC.show.vlan.addSC("mapping", "Show Vlan 802.1Q mapping");


+		userC.show.vlan.addSC("trunk", "Show Vlan including trunk ports");


+		userC.show.vlan.addSC("<type>", "Vlan type (ethernet, fddi, fddinet, trbrf, trcrf)");


+			userC.show.vlan["<type>"].addSC("notrunk", "Show Vlan excluding trunk ports");


+		userC.show.vlan.addSC("<vlans>", "Vlan Number(s)");


+			userC.show.vlan["<vlans>"].addSC("notrunk", "Show Vlan excluding trunk ports");


+	userC.show.addSC("vmps", "Show VMPS information");


+	userC.show.addSC("vtp", "Show VTP Information");


+		userC.show.vtp.addSC("domain", "Show VTP domain information");


+		userC.show.vtp.addSC("statistics", "Show VTP statistic information");


+userC.addSC("traceroute", "Trace the route to a host");


+	userC.traceroute.addSC("-i", "Specify the initial TTL");


+	userC.traceroute.addSC("-m", "Specify maximum TTL");


+	userC.traceroute.addSC("-n", "No DNS lookup");


+	userC.traceroute.addSC("-p", "Specify base UDP destination port number");


+	userC.traceroute.addSC("-q", "Specify number of queries");


+	userC.traceroute.addSC("-t", "Specify TOS");


+	userC.traceroute.addSC("-w", "Specify wait time");


+	userC.traceroute.addSC("<host>", "IP address or hostname");


+userC.addSC("verify", "Verify checksum of file on flash device");


+userC.addSC("wait", "Wait for x seconds");


+userC.addSC("whichboot", "Which file booted");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_vlanDB.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_vlanDB.txt
new file mode 100644
index 0000000..c69e97c
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/cmd_vlanDB.txt
@@ -0,0 +1,76 @@
+


+vlanDBC.addSC("abort", "Exit mode without applying the changes");


+vlanDBC.addSC("apply", "Apply current changes and bump revision number");


+vlanDBC.addSC("exit", "Apply changes, bump revision number, and exit mode");


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


+	vlanDBC.no.addSC("abort", "Exit mode without applying the changes");


+	vlanDBC.no.addSC("apply", "Apply current changes and bump revision number");


+	vlanDBC.no.addSC("exit", "Apply changes, bump revision number, and exit mode");


+	vlanDBC.no.addSC("reset", "Abandon current changes and reread current database");


+	vlanDBC.no.addSC("show", "Show database information");


+		vlanDBC.no.show.addSC("changes", "Show the changes to the database since modification began (or since 'reset')");


+			vlanDBC.no.show.changes.addSC("<1-1005>", "ID number of the VLAN shown");


+		vlanDBC.no.show.addSC("current", "Show the database installed when modification began (or since 'reset')");


+			vlanDBC.no.show.current.addSC("<1-1005>", "ID number of the VLAN shown");


+		vlanDBC.no.show.addSC("proposed", "Show the database as it would be modified if applied");


+			vlanDBC.no.show.proposed.addSC("<1-1005>", "ID number of the VLAN shown");


+	vlanDBC.no.addSC("vlan", "Add, delete, or modify values associated with a single VLAN");


+		vlanDBC.no.vlan.addSC("<1-1005>", "ISL VLAN index");


+			vlanDBC.no.vlan["<1-1005>"].addSC("are", "Maximum number of All Route Explorer hops for this VLAN (or zero if none specified)");


+			vlanDBC.no.vlan["<1-1005>"].addSC("backupcrf", "Backup CRF mode of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("bridge", "Bridging characteristics of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("media", "Media type of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("mtu", "VLAN Maximum Transmission Unit");


+			vlanDBC.no.vlan["<1-1005>"].addSC("name", "Ascii name of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("parent", "ID number of the Parent VLAN of FDDI or Token Ring type VLANs");


+			vlanDBC.no.vlan["<1-1005>"].addSC("ring", "Ring number of FDDI or Token Ring type VLANs");


+			vlanDBC.no.vlan["<1-1005>"].addSC("said", "IEEE 802.10 SAID");


+			vlanDBC.no.vlan["<1-1005>"].addSC("state", "Operational state of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("ste", "Maximum number of Spanning Tree Explorer hops for this VLAN (or zero if none specified)");


+			vlanDBC.no.vlan["<1-1005>"].addSC("stp", "Spanning tree characteristics of the VLAN");


+			vlanDBC.no.vlan["<1-1005>"].addSC("tb-vlan1", "ID number of the first translational VLAN for this VLAN (or zero if none)");


+			vlanDBC.no.vlan["<1-1005>"].addSC("tb-vlan2", "ID number of the second translational VLAN for this VLAN (or zero if none)");


+	vlanDBC.no.addSC("vtp", "Perform VTP administrative functions.");


+		vlanDBC.no.vtp.addSC("client", "Set the device to client mode.");


+		vlanDBC.no.vtp.addSC("password", "Set the password for the VTP administrative domain.");


+		vlanDBC.no.vtp.addSC("pruning", "Set the administrative domain to permit pruning.");


+			vlanDBC.no.vtp.pruning.addSC("v2-mode", "Set the administrative domain to V2 mode.");


+		vlanDBC.no.vtp.addSC("transparent", "Set the device to transparent mode.");


+		vlanDBC.no.vtp.addSC("v2-mode", "Set the administrative domain to V2 mode.");


+vlanDBC.addSC("reset", "Abandon current changes and reread current database");


+vlanDBC.addSC("show", "Show database information");


+	vlanDBC.show.addSC("changes", "Show the changes to the database since modification began (or since 'reset')");


+		vlanDBC.show.changes.addSC("<1-1005>", "ID number of the VLAN shown");


+	vlanDBC.show.addSC("current", "Show the database installed when modification began (or since 'reset')");


+		vlanDBC.show.current.addSC("<1-1005>", "ID number of the VLAN shown");


+	vlanDBC.show.addSC("proposed", "Show the database as it would be modified if applied");


+		vlanDBC.show.proposed.addSC("<1-1005>", "ID number of the VLAN shown");


+vlanDBC.addSC("vlan", "Add, delete, or modify values associated with a single VLAN");


+	vlanDBC.vlan.addSC("<1-1005>", "ISL VLAN index");


+		vlanDBC.vlan["<1-1005>"].addSC("are", "Maximum number of All Route Explorer hops for this VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("backupcrf", "Backup CRF mode of the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("bridge", "Bridging characteristics of the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("media", "Media type of the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("mtu", "VLAN Maximum Transmission Unit");


+		vlanDBC.vlan["<1-1005>"].addSC("name", "Ascii name of the VLAN");


+			vlanDBC.vlan["<1-1005>"].name.addSC("WORD", "The ascii name for the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("parent", "ID number of the Parent VLAN of FDDI or Token Ring type VLANs");


+		vlanDBC.vlan["<1-1005>"].addSC("ring", "Ring number of FDDI or Token Ring type VLANs");


+		vlanDBC.vlan["<1-1005>"].addSC("said", "IEEE 802.10 SAID");


+		vlanDBC.vlan["<1-1005>"].addSC("state", "Operational state of the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("ste", "Maximum number of Spanning Tree Explorer hops for this VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("stp", "Spanning tree characteristics of the VLAN");


+		vlanDBC.vlan["<1-1005>"].addSC("tb-vlan1", "ID number of the first translational VLAN for this VLAN (or zero if none)");


+		vlanDBC.vlan["<1-1005>"].addSC("tb-vlan2", "ID number of the second translational VLAN for this VLAN (or zero if none)");


+vlanDBC.addSC("vtp", "Perform VTP administrative functions.");


+	vlanDBC.vtp.addSC("client", "Set the device to client mode.");


+	vlanDBC.vtp.addSC("domain", "Set the name of the VTP administrative domain.");


+		vlanDBC.vtp.domain.addSC("WORD", "The ascii name for the VTP administrative domain.");


+	vlanDBC.vtp.addSC("password", "Set the password for the VTP administrative domain.");


+		vlanDBC.vtp.password.addSC("WORD", "The ascii password for the VTP administrative");


+		vlanDBC.vtp.password.addSC("domain.", "");


+	vlanDBC.vtp.addSC("pruning", "Set the administrative domain to permit pruning.");


+		vlanDBC.vtp.pruning.addSC("v2-mode", "Set the administrative domain to V2 mode.");


+	vlanDBC.vtp.addSC("server", "Set the device to server mode.");


+	vlanDBC.vtp.addSC("transparent", "Set the device to transparent mode.");


+	vlanDBC.vtp.addSC("v2-mode", "Set the administrative domain to V2 mode.");


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/dhcp.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/dhcp.swf
new file mode 100644
index 0000000..ada04fd
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/dhcp.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/enable.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/enable.swf
new file mode 100644
index 0000000..f6ed298
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/enable.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/extNacl.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/extNacl.swf
new file mode 100644
index 0000000..46467d9
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/extNacl.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_classMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_classMap.txt
new file mode 100644
index 0000000..8622339
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_classMap.txt
@@ -0,0 +1,52 @@
+classMapC.match["access-group"]["<1-2699>"].enter = true;

+

+classMapC.match["access-group"].name.WORD.enter = true;

+

+classMapC.match.any.enter = true;

+

+classMapC.match["class-map"].WORD.enter = true;

+

+classMapC.match.cos["<0-7>"].enter = true;

+

+classMapC.match["destination-address"].mac["H.H.H"].enter = true;

+

+classMapC.match["input-interface"].ATM["<0-0>"].enter = true;

+

+classMapC.match["input-interface"].Dialer["<0-255>"].enter = true;

+

+classMapC.match["input-interface"].Ethernet["<0-0>"].enter = true;

+

+classMapC.match["input-interface"].Loopback["<0-2147483647>"].enter = true;

+

+classMapC.match["input-interface"].Null["<0-0>"].enter = true;

+

+classMapC.match.ip.precedence["<0-7>"].enter = true;

+

+classMapC.match.ip.rtp["<2000-65535>"]["<0-16383>"].enter = true;

+

+classMapC.match.mpls.experimental["<0-7>"].enter = true;

+

+classMapC.match.protocol.arp.enter = true;

+

+classMapC.match.protocol.bridge.enter = true;

+

+classMapC.match.protocol.cdp.enter = true;

+

+classMapC.match.protocol.compressedtcp.enter = true;

+

+classMapC.match.protocol.ip.enter = true;

+

+classMapC.match.protocol.ipx.enter = true;

+

+classMapC.match.protocol.llc2.enter = true;

+

+classMapC.match.protocol.pppoe.enter = true;

+

+classMapC.match.protocol.snapshot.enter = true;

+

+classMapC.match.protocol.vofr.enter = true;

+

+classMapC.match["qos-group"]["<0-99>"].enter = true;

+

+classMapC.match["source-address"].mac["H.H.H"].enter = true;

+

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_dhcp.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_dhcp.txt
new file mode 100644
index 0000000..71f5c3a
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_dhcp.txt
@@ -0,0 +1,16 @@
+dhcpC["domain-name"].WORD.enter = function()

+{

+}

+

+dhcpC.exit.enter = function()

+{

+}

+

+dhcpC.host["A.B.C.D"].enter = function()

+{

+}

+

+dhcpC.network["A.B.C.D"].enter = function()

+{

+}

+

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_enable.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_enable.txt
new file mode 100644
index 0000000..91fd062
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_enable.txt
@@ -0,0 +1,1428 @@
+enableC.clear["access-list"].counters.enter = true;


+


+enableC.clear["access-list"].counters["<1-199>"].enter = true;


+


+enableC.clear["access-list"].counters["<1300-2699>"].enter = true;


+


+enableC.clear["access-list"].counters.WORD.enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.any.any.enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.any.host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.host["Hostname or A.B.C.D"].any.enter = true;


+


+enableC.clear["access-template"]["<100-199>"].WORD.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.any.any.enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.any.host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.host["Hostname or A.B.C.D"].any.enter = true;


+


+enableC.clear["access-template"]["<2000-2699>"].WORD.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+enableC.clear["arp-cache"].enter = true;


+


+enableC.clear.cdp.counters.enter = true;


+


+enableC.clear.cdp.table.enter = true;


+


+enableC.clear.controllers["ethernet-controller"].enter = true;


+


+enableC.clear.counters.enter = true;


+


+enableC.clear.counters.Line["<0-16>"].enter = true;


+


+enableC.clear.counters.Line["<0-16>"]["<1-16>"].enter = true;


+


+enableC.clear.counters.Line.console["<0-0>"].enter = true;


+


+enableC.clear.counters.Line.vty["<0-15>"].enter = true;


+


+enableC.clear.counters.Line.vty["<0-15>"]["<1-15>"].enter = true;


+


+enableC.clear.counters.Null["<0-0>"].enter = true;


+


+enableC.clear.counters["Port-channel"]["<1-6>"].enter = true;


+


+enableC.clear.counters.Vlan["<1-1001>"].enter = true;


+


+enableC.clear.host.WORD.enter = true;


+


+enableC.clear.interface.Null["<0-0>"].enter = true;


+


+enableC.clear.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.clear.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.clear.ip.accounting.enter = true;


+


+enableC.clear.ip.accounting.checkpoint.enter = true;


+


+enableC.clear.ip.nat.statistics.enter = true;


+


+enableC.clear.ip.nat.translation["*"].enter = true;


+


+enableC.clear.ip.nat.translation.inside["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear.ip.nat.translation.outside["A.B.C.D"]["A.B.C.D"].enter = true;


+


+enableC.clear.ip.redirect.enter = true;


+


+enableC.clear.line["<0-16>"].enter = true;


+


+enableC.clear.line.console["<0-0>"].enter = true;


+


+enableC.clear.line.vty["<0-15>"].enter = true;


+


+enableC.clear.logging.enter = true;


+


+enableC.clear["mac-address-table"].dynamic.enter = true;


+


+enableC.clear["mac-address-table"].dynamic.address["H.H.H"].enter = true;


+


+enableC.clear["mac-address-table"].dynamic.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.clear["mac-address-table"].dynamic.vlan["<0-4096>"].enter = true;


+


+enableC.clear["mac-address-table"].notification.enter = true;


+


+enableC.clear.pagp.counters.enter = true;


+


+enableC.clear.radius.statistics.enter = true;


+


+enableC.clear.tcp.line["<0-16>"].enter = true;


+


+enableC.clear.tcp.line.console["<0-0>"].enter = true;


+


+enableC.clear.tcp.line.vty["<0-15>"].enter = true;


+


+enableC.clear.tcp.local["Hostname or A.B.C.D"]["<1-65535>"].remote["Hostname or A.B.C.D"]["<1-65535>"].enter = true;


+


+enableC.clear.tcp.statistics.enter = true;


+


+enableC.clear.tcp.tcb["<0x0-0xFFFFFFFF>"].enter = true;


+


+enableC.clear.vmps.statistics.enter = true;


+


+enableC.clear.vtp.counters.enter = true;


+


+enableC.configure.enter = true;


+


+enableC.configure.memory.enter = true;


+


+enableC.configure.network.enter = true;


+


+enableC.configure.network["flash:"].enter = true;


+


+enableC.configure.network["ftp:"].enter = true;


+


+enableC.configure.network["null:"].enter = true;


+


+enableC.configure.network["nvram:"].enter = true;


+


+enableC.configure.network["rcp:"].enter = true;


+


+enableC.configure.network["system:"].enter = true;


+


+enableC.configure.network["tftp:"].enter = true;


+


+enableC.configure.network["xmodem:"].enter = true;


+


+enableC.configure.network["ymodem:"].enter = true;


+


+enableC.configure.network["zflash:"].enter = true;


+


+enableC.configure["overwrite-network"].enter = true;


+


+enableC.configure["overwrite-network"]["flash:"].enter = true;


+


+enableC.configure["overwrite-network"]["ftp:"].enter = true;


+


+enableC.configure["overwrite-network"]["null:"].enter = true;


+


+enableC.configure["overwrite-network"]["nvram:"].enter = true;


+


+enableC.configure["overwrite-network"]["rcp:"].enter = true;


+


+enableC.configure["overwrite-network"]["system:"].enter = true;


+


+enableC.configure["overwrite-network"]["tftp:"].enter = true;


+


+enableC.configure["overwrite-network"]["xmodem:"].enter = true;


+


+enableC.configure["overwrite-network"]["ymodem:"].enter = true;


+


+enableC.configure["overwrite-network"]["zflash:"].enter = true;


+


+enableC.configure.terminal.enter = true;


+


+enableC.copy["flash:"]["flash:"].enter = true;


+


+enableC.copy["flash:"]["ftp:"].enter = true;


+


+enableC.copy["flash:"]["null:"].enter = true;


+


+enableC.copy["flash:"]["nvram:"].enter = true;


+


+enableC.copy["flash:"]["rcp:"].enter = true;


+


+enableC.copy["flash:"]["running-config"].enter = true;


+


+enableC.copy["flash:"]["startup-config"].enter = true;


+


+enableC.copy["flash:"]["system:"].enter = true;


+


+enableC.copy["flash:"]["tftp:"].enter = true;


+


+enableC.copy["flash:"]["xmodem:"].enter = true;


+


+enableC.copy["flash:"]["ymodem:"].enter = true;


+


+enableC.copy["flash:"]["zflash:"].enter = true;


+


+enableC.copy["ftp:"]["flash:"].enter = true;


+


+enableC.copy["ftp:"]["ftp:"].enter = true;


+


+enableC.copy["ftp:"]["null:"].enter = true;


+


+enableC.copy["ftp:"]["nvram:"].enter = true;


+


+enableC.copy["ftp:"]["rcp:"].enter = true;


+


+enableC.copy["ftp:"]["running-config"].enter = true;


+


+enableC.copy["ftp:"]["startup-config"].enter = true;


+


+enableC.copy["ftp:"]["system:"].enter = true;


+


+enableC.copy["ftp:"]["tftp:"].enter = true;


+


+enableC.copy["ftp:"]["xmodem:"].enter = true;


+


+enableC.copy["ftp:"]["ymodem:"].enter = true;


+


+enableC.copy["ftp:"]["zflash:"].enter = true;


+


+enableC.copy["null:"]["flash:"].enter = true;


+


+enableC.copy["null:"]["ftp:"].enter = true;


+


+enableC.copy["null:"]["null:"].enter = true;


+


+enableC.copy["null:"]["nvram:"].enter = true;


+


+enableC.copy["null:"]["rcp:"].enter = true;


+


+enableC.copy["null:"]["running-config"].enter = true;


+


+enableC.copy["null:"]["startup-config"].enter = true;


+


+enableC.copy["null:"]["system:"].enter = true;


+


+enableC.copy["null:"]["tftp:"].enter = true;


+


+enableC.copy["null:"]["xmodem:"].enter = true;


+


+enableC.copy["null:"]["ymodem:"].enter = true;


+


+enableC.copy["null:"]["zflash:"].enter = true;


+


+enableC.copy["nvram:"]["flash:"].enter = true;


+


+enableC.copy["nvram:"]["ftp:"].enter = true;


+


+enableC.copy["nvram:"]["null:"].enter = true;


+


+enableC.copy["nvram:"]["nvram:"].enter = true;


+


+enableC.copy["nvram:"]["rcp:"].enter = true;


+


+enableC.copy["nvram:"]["running-config"].enter = true;


+


+enableC.copy["nvram:"]["startup-config"].enter = true;


+


+enableC.copy["nvram:"]["system:"].enter = true;


+


+enableC.copy["nvram:"]["tftp:"].enter = true;


+


+enableC.copy["nvram:"]["xmodem:"].enter = true;


+


+enableC.copy["nvram:"]["ymodem:"].enter = true;


+


+enableC.copy["nvram:"]["zflash:"].enter = true;


+


+enableC.copy["rcp:"]["flash:"].enter = true;


+


+enableC.copy["rcp:"]["ftp:"].enter = true;


+


+enableC.copy["rcp:"]["null:"].enter = true;


+


+enableC.copy["rcp:"]["nvram:"].enter = true;


+


+enableC.copy["rcp:"]["rcp:"].enter = true;


+


+enableC.copy["rcp:"]["running-config"].enter = true;


+


+enableC.copy["rcp:"]["startup-config"].enter = true;


+


+enableC.copy["rcp:"]["system:"].enter = true;


+


+enableC.copy["rcp:"]["tftp:"].enter = true;


+


+enableC.copy["rcp:"]["xmodem:"].enter = true;


+


+enableC.copy["rcp:"]["ymodem:"].enter = true;


+


+enableC.copy["rcp:"]["zflash:"].enter = true;


+


+enableC.copy["running-config"]["flash:"].enter = true;


+


+enableC.copy["running-config"]["ftp:"].enter = true;


+


+enableC.copy["running-config"]["null:"].enter = true;


+


+enableC.copy["running-config"]["nvram:"].enter = true;


+


+enableC.copy["running-config"]["rcp:"].enter = true;


+


+enableC.copy["running-config"]["running-config"].enter = true;


+


+enableC.copy["running-config"]["startup-config"].enter = true;


+


+enableC.copy["running-config"]["system:"].enter = true;


+


+enableC.copy["running-config"]["tftp:"].enter = true;


+


+enableC.copy["running-config"]["xmodem:"].enter = true;


+


+enableC.copy["running-config"]["ymodem:"].enter = true;


+


+enableC.copy["running-config"]["zflash:"].enter = true;


+


+enableC.copy["startup-config"]["flash:"].enter = true;


+


+enableC.copy["startup-config"]["ftp:"].enter = true;


+


+enableC.copy["startup-config"]["null:"].enter = true;


+


+enableC.copy["startup-config"]["nvram:"].enter = true;


+


+enableC.copy["startup-config"]["rcp:"].enter = true;


+


+enableC.copy["startup-config"]["running-config"].enter = true;


+


+enableC.copy["startup-config"]["startup-config"].enter = true;


+


+enableC.copy["startup-config"]["system:"].enter = true;


+


+enableC.copy["startup-config"]["tftp:"].enter = true;


+


+enableC.copy["startup-config"]["xmodem:"].enter = true;


+


+enableC.copy["startup-config"]["ymodem:"].enter = true;


+


+enableC.copy["startup-config"]["zflash:"].enter = true;


+


+enableC.copy["system:"]["flash:"].enter = true;


+


+enableC.copy["system:"]["ftp:"].enter = true;


+


+enableC.copy["system:"]["null:"].enter = true;


+


+enableC.copy["system:"]["nvram:"].enter = true;


+


+enableC.copy["system:"]["rcp:"].enter = true;


+


+enableC.copy["system:"]["running-config"].enter = true;


+


+enableC.copy["system:"]["startup-config"].enter = true;


+


+enableC.copy["system:"]["system:"].enter = true;


+


+enableC.copy["system:"]["tftp:"].enter = true;


+


+enableC.copy["system:"]["xmodem:"].enter = true;


+


+enableC.copy["system:"]["ymodem:"].enter = true;


+


+enableC.copy["system:"]["zflash:"].enter = true;


+


+enableC.copy["tftp:"]["flash:"].enter = true;


+


+enableC.copy["tftp:"]["ftp:"].enter = true;


+


+enableC.copy["tftp:"]["null:"].enter = true;


+


+enableC.copy["tftp:"]["nvram:"].enter = true;


+


+enableC.copy["tftp:"]["rcp:"].enter = true;


+


+enableC.copy["tftp:"]["running-config"].enter = true;


+


+enableC.copy["tftp:"]["startup-config"].enter = true;


+


+enableC.copy["tftp:"]["system:"].enter = true;


+


+enableC.copy["tftp:"]["tftp:"].enter = true;


+


+enableC.copy["tftp:"]["xmodem:"].enter = true;


+


+enableC.copy["tftp:"]["ymodem:"].enter = true;


+


+enableC.copy["tftp:"]["zflash:"].enter = true;


+


+enableC.copy["xmodem:"]["flash:"].enter = true;


+


+enableC.copy["xmodem:"]["ftp:"].enter = true;


+


+enableC.copy["xmodem:"]["null:"].enter = true;


+


+enableC.copy["xmodem:"]["nvram:"].enter = true;


+


+enableC.copy["xmodem:"]["rcp:"].enter = true;


+


+enableC.copy["xmodem:"]["running-config"].enter = true;


+


+enableC.copy["xmodem:"]["startup-config"].enter = true;


+


+enableC.copy["xmodem:"]["system:"].enter = true;


+


+enableC.copy["xmodem:"]["tftp:"].enter = true;


+


+enableC.copy["xmodem:"]["xmodem:"].enter = true;


+


+enableC.copy["xmodem:"]["ymodem:"].enter = true;


+


+enableC.copy["xmodem:"]["zflash:"].enter = true;


+


+enableC.copy["ymodem:"]["flash:"].enter = true;


+


+enableC.copy["ymodem:"]["ftp:"].enter = true;


+


+enableC.copy["ymodem:"]["null:"].enter = true;


+


+enableC.copy["ymodem:"]["nvram:"].enter = true;


+


+enableC.copy["ymodem:"]["rcp:"].enter = true;


+


+enableC.copy["ymodem:"]["running-config"].enter = true;


+


+enableC.copy["ymodem:"]["startup-config"].enter = true;


+


+enableC.copy["ymodem:"]["system:"].enter = true;


+


+enableC.copy["ymodem:"]["tftp:"].enter = true;


+


+enableC.copy["ymodem:"]["xmodem:"].enter = true;


+


+enableC.copy["ymodem:"]["ymodem:"].enter = true;


+


+enableC.copy["ymodem:"]["zflash:"].enter = true;


+


+enableC.copy["zflash:"]["flash:"].enter = true;


+


+enableC.copy["zflash:"]["ftp:"].enter = true;


+


+enableC.copy["zflash:"]["null:"].enter = true;


+


+enableC.copy["zflash:"]["nvram:"].enter = true;


+


+enableC.copy["zflash:"]["rcp:"].enter = true;


+


+enableC.copy["zflash:"]["running-config"].enter = true;


+


+enableC.copy["zflash:"]["startup-config"].enter = true;


+


+enableC.copy["zflash:"]["system:"].enter = true;


+


+enableC.copy["zflash:"]["tftp:"].enter = true;


+


+enableC.copy["zflash:"]["xmodem:"].enter = true;


+


+enableC.copy["zflash:"]["ymodem:"].enter = true;


+


+enableC.copy["zflash:"]["zflash:"].enter = true;


+


+enableC.disable.enter = true;


+


+enableC.show["access-lists"].enter = true;


+


+enableC.show["access-lists"]["<1-2699>"].enter = true;


+


+enableC.show["access-lists"].WORD.enter = true;


+


+enableC.show.accounting.enter = true;


+


+enableC.show.aliases.enter = true;


+


+enableC.show.aliases.calqosclassmap.enter = true;


+


+enableC.show.aliases.calqospolicymap.enter = true;


+


+enableC.show.aliases.calqospolicymapclass.enter = true;


+


+enableC.show.aliases["config-rtr-http"].enter = true;


+


+enableC.show.aliases.configure.enter = true;


+


+enableC.show.aliases.exec.enter = true;


+


+enableC.show.aliases.insenacl.enter = true;


+


+enableC.show.aliases.inssnacl.enter = true;


+


+enableC.show.aliases.interface.enter = true;


+


+enableC.show.aliases.interface.enter = true;


+


+enableC.show.aliases.ipenacl.enter = true;


+


+enableC.show.aliases["ipnat-pool"].enter = true;


+


+enableC.show.aliases.ipsnacl.enter = true;


+


+enableC.show.aliases.line.enter = true;


+


+enableC.show.aliases["mac-enacl"].enter = true;


+


+enableC.show.aliases["map-class"].enter = true;


+


+enableC.show.aliases["map-list"].enter = true;


+


+enableC.show.aliases["null-interface"].enter = true;


+


+enableC.show.aliases.preauth.enter = true;


+


+enableC.show.aliases.qosclassmap.enter = true;


+


+enableC.show.aliases.qospolicymap.enter = true;


+


+enableC.show.aliases.qospolicymapclass.enter = true;


+


+enableC.show.aliases.rtr.enter = true;


+


+enableC.show.aliases["sg-radius"].enter = true;


+


+enableC.show.aliases["sg-tacacs+"].enter = true;


+


+enableC.show.aliases.subinterface.enter = true;


+


+enableC.show.aliases.template.enter = true;


+


+enableC.show.aliases.trange.enter = true;


+


+enableC.show.aliases["vc-class"].enter = true;


+


+enableC.show.arp.enter = true;


+


+enableC.show.boot.enter = true;


+


+enableC.show.buffers.enter = true;


+


+enableC.show.buffers.address["<0-FFFFFFFF>"].enter = true;


+


+enableC.show.buffers.address["<0-FFFFFFFF>"].dump.enter = true;


+


+enableC.show.buffers.address["<0-FFFFFFFF>"].header.enter = true;


+


+enableC.show.buffers.address["<0-FFFFFFFF>"].packet.enter = true;


+


+enableC.show.buffers.all.enter = true;


+


+enableC.show.buffers.all.dump.enter = true;


+


+enableC.show.buffers.all.header.enter = true;


+


+enableC.show.buffers.all.packet.enter = true;


+


+enableC.show.buffers.assigned.enter = true;


+


+enableC.show.buffers.assigned.dump.enter = true;


+


+enableC.show.buffers.assigned.header.enter = true;


+


+enableC.show.buffers.assigned.packet.enter = true;


+


+enableC.show.buffers.failures.enter = true;


+


+enableC.show.buffers.free.enter = true;


+


+enableC.show.buffers.free.dump.enter = true;


+


+enableC.show.buffers.free.header.enter = true;


+


+enableC.show.buffers.free.packet.enter = true;


+


+enableC.show.buffers["input-interface"].Null["<0-0>"].enter = true;


+


+enableC.show.buffers["input-interface"].Null["<0-0>"].dump.enter = true;


+


+enableC.show.buffers["input-interface"].Null["<0-0>"].header.enter = true;


+


+enableC.show.buffers["input-interface"].Null["<0-0>"].packet.enter = true;


+


+enableC.show.buffers["input-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.buffers["input-interface"]["Port-channel"]["<1-6>"].dump.enter = true;


+


+enableC.show.buffers["input-interface"]["Port-channel"]["<1-6>"].header.enter = true;


+


+enableC.show.buffers["input-interface"]["Port-channel"]["<1-6>"].packet.enter = true;


+


+enableC.show.buffers["input-interface"].Vlan["<1-1001>"].enter = true;


+


+enableC.show.buffers["input-interface"].Vlan["<1-1001>"].dump.enter = true;


+


+enableC.show.buffers["input-interface"].Vlan["<1-1001>"].header.enter = true;


+


+enableC.show.buffers["input-interface"].Vlan["<1-1001>"].packet.enter = true;


+


+enableC.show.buffers.old.enter = true;


+


+enableC.show.buffers.old.dump.enter = true;


+


+enableC.show.buffers.old.header.enter = true;


+


+enableC.show.buffers.old.packet.enter = true;


+


+enableC.show.buffers.pool.WORD.enter = true;


+


+enableC.show.buffers.pool.WORD.dump.enter = true;


+


+enableC.show.buffers.pool.WORD.header.enter = true;


+


+enableC.show.buffers.pool.WORD.packet.enter = true;


+


+enableC.show.cdp.enter = true;


+


+enableC.show.cdp.entry["*"].enter = true;


+


+enableC.show.cdp.entry["*"].protocol.enter = true;


+


+enableC.show.cdp.entry["*"].version.enter = true;


+


+enableC.show.cdp.entry.WORD.enter = true;


+


+enableC.show.cdp.entry.WORD.protocol.enter = true;


+


+enableC.show.cdp.entry.WORD.version.enter = true;


+


+enableC.show.cdp.interface.enter = true;


+


+enableC.show.cdp.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.cdp.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show.cdp.neighbors.enter = true;


+


+enableC.show.cdp.neighbors.Vlan["<1-1001>"].enter = true;


+


+enableC.show.cdp.neighbors.detail.enter = true;


+


+enableC.show.cdp.traffic.enter = true;


+


+enableC.show["class-map"].enter = true;


+


+enableC.show["class-map"].WORD.enter = true;


+


+enableC.show.clock.enter = true;


+


+enableC.show.clock.detail.enter = true;


+


+enableC.show.cluster.enter = true;


+


+enableC.show.cluster.candidates.enter = true;


+


+enableC.show.cluster.candidates.detail.enter = true;


+


+enableC.show.cluster.candidates["mac-address"]["H.H.H"].enter = true;


+


+enableC.show.cluster.candidates["mac-address"]["H.H.H"].detail.enter = true;


+


+enableC.show.cluster.members.enter = true;


+


+enableC.show.cluster.members["<0-15>"].enter = true;


+


+enableC.show.cluster.members.detail.enter = true;


+


+enableC.show.configuration.enter = true;


+


+enableC.show.controllers.enter = true;


+


+enableC.show.controllers["ethernet-controller"].enter = true;


+


+enableC.show.debugging.enter = true;


+


+enableC.show.debugging.condition.enter = true;


+


+enableC.show.debugging.condition["<1-1000>"].enter = true;


+


+enableC.show.debugging.condition.all.enter = true;


+


+enableC.show.dhcp.lease.enter = true;


+


+enableC.show.dhcp.server.enter = true;


+


+enableC.show.dot1x.enter = true;


+


+enableC.show.dot1x.statistics.enter = true;


+


+enableC.show.dtp.interface.enter = true;


+


+enableC.show.dtp.interface.Null["<0-0>"].enter = true;


+


+enableC.show.dtp.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.dtp.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show.env.all.enter = true;


+


+enableC.show.env.fan.enter = true;


+


+enableC.show.errdisable.detect.enter = true;


+


+enableC.show.errdisable["flap-values"].enter = true;


+


+enableC.show.errdisable.recovery.enter = true;


+


+enableC.show.etherchannel.brief.enter = true;


+


+enableC.show.etherchannel.detail.enter = true;


+


+enableC.show.etherchannel["load-balance"].enter = true;


+


+enableC.show.etherchannel.port.enter = true;


+


+enableC.show.etherchannel["port-channel"].enter = true;


+


+enableC.show.etherchannel.summary.enter = true;


+


+enableC.show.exception.enter = true;


+


+enableC.show.file.descriptors.enter = true;


+


+enableC.show.file.information["flash:"].enter = true;


+


+enableC.show.file.information["ftp:"].enter = true;


+


+enableC.show.file.information["null:"].enter = true;


+


+enableC.show.file.information["nvram:"].enter = true;


+


+enableC.show.file.information["rcp:"].enter = true;


+


+enableC.show.file.information["system:"].enter = true;


+


+enableC.show.file.information["tftp:"].enter = true;


+


+enableC.show.file.information["xmodem:"].enter = true;


+


+enableC.show.file.information["ymodem:"].enter = true;


+


+enableC.show.file.information["zflash:"].enter = true;


+


+enableC.show.file.systems.enter = true;


+


+enableC.show["flash:"].enter = true;


+


+enableC.show.history.enter = true;


+


+enableC.show.hosts.enter = true;


+


+enableC.show.hosts.WORD.enter = true;


+


+enableC.show.html.module.command.LINE.enter = true;


+


+enableC.show.html.module.count.enter = true;


+


+enableC.show.html.module.names.enter = true;


+


+enableC.show.html.module.options.enter = true;


+


+enableC.show.html.module.ports.enter = true;


+


+enableC.show.html.module.ports.l2.enter = true;


+


+enableC.show.html.port.command.LINE.enter = true;


+


+enableC.show.html.port.count.enter = true;


+


+enableC.show.html.port.names.enter = true;


+


+enableC.show.html.port.options.enter = true;


+


+enableC.show.html.port.shortnames.enter = true;


+


+enableC.show.interfaces.enter = true;


+


+enableC.show.interfaces.Null["<0-0>"].enter = true;


+


+enableC.show.interfaces["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.interfaces.Vlan["<1-1001>"].enter = true;


+


+enableC.show.interfaces.accounting.enter = true;


+


+enableC.show.interfaces.counters.enter = true;


+


+enableC.show.interfaces.counters.broadcast.enter = true;


+


+enableC.show.interfaces.counters.errors.enter = true;


+


+enableC.show.interfaces.counters.module["<1-9>"].enter = true;


+


+enableC.show.interfaces.counters.multicast.enter = true;


+


+enableC.show.interfaces.counters.trunk.enter = true;


+


+enableC.show.interfaces.counters.unicast.enter = true;


+


+enableC.show.interfaces.crb.enter = true;


+


+enableC.show.interfaces.description.enter = true;


+


+enableC.show.interfaces.etherchannel.enter = true;


+


+enableC.show.interfaces.etherchannel.module["<1-9>"].enter = true;


+


+enableC.show.interfaces["fair-queue"].enter = true;


+


+enableC.show.interfaces.irb.enter = true;


+


+enableC.show.interfaces["mac-accounting"].enter = true;


+


+enableC.show.interfaces.precedence.enter = true;


+


+enableC.show.interfaces.pruning.enter = true;


+


+enableC.show.interfaces.pruning.module["<1-9>"].enter = true;


+


+enableC.show.interfaces["random-detect"].enter = true;


+


+enableC.show.interfaces["rate-limit"].enter = true;


+


+enableC.show.interfaces.shape.enter = true;


+


+enableC.show.interfaces.stats.enter = true;


+


+enableC.show.interfaces.status.enter = true;


+


+enableC.show.interfaces.status["err-disabled"].enter = true;


+


+enableC.show.interfaces.status.module["<1-9>"].enter = true;


+


+enableC.show.interfaces.switchport.enter = true;


+


+enableC.show.interfaces.switchport.module["<1-9>"].enter = true;


+


+enableC.show.interfaces.trunk.enter = true;


+


+enableC.show.interfaces.trunk.module["<1-9>"].enter = true;


+


+enableC.show.ip["access-lists"].enter = true;


+


+enableC.show.ip["access-lists"]["<1-199>"].enter = true;


+


+enableC.show.ip["access-lists"]["<1300-2699>"].enter = true;


+


+enableC.show.ip["access-lists"].WORD.enter = true;


+


+enableC.show.ip.accounting.enter = true;


+


+enableC.show.ip.accounting["access-violations"].enter = true;


+


+enableC.show.ip.accounting.checkpoint.enter = true;


+


+enableC.show.ip.accounting["output-packets"].enter = true;


+


+enableC.show.ip.aliases.enter = true;


+


+enableC.show.ip.arp.enter = true;


+


+enableC.show.ip.arp.FastEthernet.enter = true;


+


+enableC.show.ip.arp.GigabitEthernet.enter = true;


+


+enableC.show.ip.arp["H.H.H"].enter = true;


+


+enableC.show.ip.arp["Hostname or A.B.C.D"].enter = true;


+


+enableC.show.ip.arp.Null.enter = true;


+


+enableC.show.ip.arp.Null["<0-0>"].enter = true;


+


+enableC.show.ip.arp["Port-channel"].enter = true;


+


+enableC.show.ip.arp["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.ip.arp.Vlan.enter = true;


+


+enableC.show.ip.arp.Vlan["<1-1001>"].enter = true;


+


+enableC.show.ip.igmp.snooping.enter = true;


+


+enableC.show.ip.igmp.snooping.mrouter.enter = true;


+


+enableC.show.ip.igmp.snooping.mrouter.vlan["<1-1001>"].enter = true;


+


+enableC.show.ip.igmp.snooping.vlan["<1-1001>"].enter = true;


+


+enableC.show.ip.interface.enter = true;


+


+enableC.show.ip.interface.Null["<0-0>"].enter = true;


+


+enableC.show.ip.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.ip.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show.ip.interface.brief.enter = true;


+


+enableC.show.ip.nat.statistics.enter = true;


+


+enableC.show.ip.nat.translations.enter = true;


+


+enableC.show.ip.nat.translations.verbose.enter = true;


+


+enableC.show.ip.redirects.enter = true;


+


+enableC.show.ip.redirects["A.B.C.D"].enter = true;


+


+enableC.show.ip.sockets.enter = true;


+


+enableC.show.ip.traffic.enter = true;


+


+enableC.show.line.enter = true;


+


+enableC.show.line["<0-16>"].enter = true;


+


+enableC.show.line["<0-16>"]["<1-16>"].enter = true;


+


+enableC.show.line.console["<0-0>"].enter = true;


+


+enableC.show.line.summary.enter = true;


+


+enableC.show.line.vty["<0-15>"].enter = true;


+


+enableC.show.line.vty["<0-15>"]["<1-15>"].enter = true;


+


+enableC.show.location.enter = true;


+


+enableC.show.logging.enter = true;


+


+enableC.show.logging.history.enter = true;


+


+enableC.show.mac["access-group"].enter = true;


+


+enableC.show.mac["access-group"].interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show["mac-address-table"].enter = true;


+


+enableC.show["mac-address-table"].address["H.H.H"].enter = true;


+


+enableC.show["mac-address-table"]["aging-time"].enter = true;


+


+enableC.show["mac-address-table"].count.enter = true;


+


+enableC.show["mac-address-table"].dynamic.enter = true;


+


+enableC.show["mac-address-table"].interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show["mac-address-table"].multicast.enter = true;


+


+enableC.show["mac-address-table"].multicast.count.enter = true;


+


+enableC.show["mac-address-table"].multicast["igmp-snooping"].enter = true;


+


+enableC.show["mac-address-table"].multicast.user.enter = true;


+


+enableC.show["mac-address-table"].notification.enter = true;


+


+enableC.show["mac-address-table"].notification.interface.enter = true;


+


+enableC.show["mac-address-table"].notification.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show["mac-address-table"].static.enter = true;


+


+enableC.show["mac-address-table"].vlan["<1-1005>"].enter = true;


+


+enableC.show.memory.enter = true;


+


+enableC.show.memory["<0-4294967294>"].enter = true;


+


+enableC.show.memory["<0-4294967294>"]["<0-4294967294>"].enter = true;


+


+enableC.show.memory["allocating-process"].enter = true;


+


+enableC.show.memory["allocating-process"].totals.enter = true;


+


+enableC.show.memory.dead.enter = true;


+


+enableC.show.memory.dead.totals.enter = true;


+


+enableC.show.memory.failures.alloc.enter = true;


+


+enableC.show.memory.fast.enter = true;


+


+enableC.show.memory.free.enter = true;


+


+enableC.show.memory.io.enter = true;


+


+enableC.show.memory.multibus.enter = true;


+


+enableC.show.memory.pci.enter = true;


+


+enableC.show.memory.processor.enter = true;


+


+enableC.show.memory.summary.enter = true;


+


+enableC.show.mls.masks.enter = true;


+


+enableC.show.mls.masks.qos.enter = true;


+


+enableC.show.mls.masks.security.enter = true;


+


+enableC.show.mls.qos.interface.enter = true;


+


+enableC.show.mls.qos.interface.Null["<0-0>"].enter = true;


+


+enableC.show.mls.qos.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.mls.qos.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show.mls.qos.interface.policers.enter = true;


+


+enableC.show.mls.qos.maps.enter = true;


+


+enableC.show.mls.qos.maps["cos-dscp"].enter = true;


+


+enableC.show.mls.qos.maps["dscp-cos"].enter = true;


+


+enableC.show.monitor.enter = true;


+


+enableC.show.monitor.session["<1-1>"].enter = true;


+


+enableC.show.mvr.enter = true;


+


+enableC.show.mvr.interface.enter = true;


+


+enableC.show.mvr.members.enter = true;


+


+enableC.show.mvr.members["A.B.C.D"].enter = true;


+


+enableC.show.ntp.associations.enter = true;


+


+enableC.show.ntp.associations.detail.enter = true;


+


+enableC.show.ntp.status.enter = true;


+


+enableC.show.pagp.counters.enter = true;


+


+enableC.show.pagp.internal.enter = true;


+


+enableC.show.pagp.neighbor.enter = true;


+


+enableC.show.pm.LINE.enter = true;


+


+enableC.show["policy-map"].enter = true;


+


+enableC.show["policy-map"].WORD.enter = true;


+


+enableC.show["policy-map"].WORD.class.WORD.enter = true;


+


+enableC.show["port-security"].enter = true;


+


+enableC.show["port-security"].address.enter = true;


+


+enableC.show.post.enter = true;


+


+enableC.show.privilege.enter = true;


+


+enableC.show.processes.enter = true;


+


+enableC.show.processes.cpu.enter = true;


+


+enableC.show.processes.memory.enter = true;


+


+enableC.show.processes.memory["<1-4294967295>"].enter = true;


+


+enableC.show.queue.Null["<0-0>"].enter = true;


+


+enableC.show.queue.Null["<0-0>"]["<0-16>"].enter = true;


+


+enableC.show.queue["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.queue["Port-channel"]["<1-6>"]["<0-16>"].enter = true;


+


+enableC.show.queue.Vlan["<1-1001>"].enter = true;


+


+enableC.show.queue.Vlan["<1-1001>"]["<0-16>"].enter = true;


+


+enableC.show.queueing.enter = true;


+


+enableC.show.queueing.interface.Null["<0-0>"].enter = true;


+


+enableC.show.queueing.interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.queueing.interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show.queueing.custom.enter = true;


+


+enableC.show.queueing.fair.enter = true;


+


+enableC.show.queueing.priority.enter = true;


+


+enableC.show.queueing["random-detect"].enter = true;


+


+enableC.show.radius.statistics.enter = true;


+


+enableC.show.registry.enter = true;


+


+enableC.show.registry.WORD.enter = true;


+


+enableC.show.registry.WORD.WORD.enter = true;


+


+enableC.show.registry.brief.enter = true;


+


+enableC.show.registry.statistics.enter = true;


+


+enableC.show.reload.enter = true;


+


+enableC.show.rhosts.enter = true;


+


+enableC.show.rmon.enter = true;


+


+enableC.show.rmon.alarms.enter = true;


+


+enableC.show.rmon.events.enter = true;


+


+enableC.show.rmon.history.enter = true;


+


+enableC.show.rmon.statistics.enter = true;


+


+enableC.show.rps.enter = true;


+


+enableC.show.rtr.application.enter = true;


+


+enableC.show.rtr.authentication.enter = true;


+


+enableC.show.rtr["collection-statistics"].enter = true;


+


+enableC.show.rtr["collection-statistics"]["<1-2147483647>"].enter = true;


+


+enableC.show.rtr.configuration.enter = true;


+


+enableC.show.rtr.configuration["<1-2147483647>"].enter = true;


+


+enableC.show.rtr["distributions-statistics"].enter = true;


+


+enableC.show.rtr["distributions-statistics"]["<1-2147483647>"].enter = true;


+


+enableC.show.rtr["distributions-statistics"].full.enter = true;


+


+enableC.show.rtr["distributions-statistics"].tabular.enter = true;


+


+enableC.show.rtr.history.enter = true;


+


+enableC.show.rtr.history["<1-2147483647>"].enter = true;


+


+enableC.show.rtr.history.full.enter = true;


+


+enableC.show.rtr.history.tabular.enter = true;


+


+enableC.show.rtr["operational-state"].enter = true;


+


+enableC.show.rtr["operational-state"]["<1-2147483647>"].enter = true;


+


+enableC.show.rtr["reaction-trigger"].enter = true;


+


+enableC.show.rtr["reaction-trigger"]["<1-2147483647>"].enter = true;


+


+enableC.show.rtr.responder.enter = true;


+


+enableC.show.rtr["totals-statistics"].enter = true;


+


+enableC.show.rtr["totals-statistics"]["<1-2147483647>"].enter = true;


+


+enableC.show["running-config"].enter = true;


+


+enableC.show["running-config"].interface.Null["<0-0>"].enter = true;


+


+enableC.show["running-config"].interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show["running-config"].interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show["running-config"]["map-class"].enter = true;


+


+enableC.show.sessions.enter = true;


+


+enableC.show.snmp.enter = true;


+


+enableC.show.snmp.engineID.enter = true;


+


+enableC.show.snmp.group.enter = true;


+


+enableC.show.snmp.user.enter = true;


+


+enableC.show["spanning-tree"].enter = true;


+


+enableC.show["spanning-tree"].active.enter = true;


+


+enableC.show["spanning-tree"].backbonefast.enter = true;


+


+enableC.show["spanning-tree"].blockedports.enter = true;


+


+enableC.show["spanning-tree"].bridge.enter = true;


+


+enableC.show["spanning-tree"].bridge.address.enter = true;


+


+enableC.show["spanning-tree"].bridge.brief.enter = true;


+


+enableC.show["spanning-tree"].bridge["forward-time"].enter = true;


+


+enableC.show["spanning-tree"].bridge["hello-time"].enter = true;


+


+enableC.show["spanning-tree"].bridge["max-age"].enter = true;


+


+enableC.show["spanning-tree"].bridge.priority.enter = true;


+


+enableC.show["spanning-tree"].bridge.protocol.enter = true;


+


+enableC.show["spanning-tree"].brief.enter = true;


+


+enableC.show["spanning-tree"].brief.wide.enter = true;


+


+enableC.show["spanning-tree"].inconsistentports.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].active.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].brief.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].brief.wide.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].cost.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].inconsistency.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].portfast.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].priority.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].rootcost.enter = true;


+


+enableC.show["spanning-tree"].interface["Port-channel"]["<1-6>"].state.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].active.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].brief.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].brief.wide.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].cost.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].inconsistency.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].portfast.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].priority.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].rootcost.enter = true;


+


+enableC.show["spanning-tree"].interface.Vlan["<1-1001>"].state.enter = true;


+


+enableC.show["spanning-tree"].pathcost.method.enter = true;


+


+enableC.show["spanning-tree"].root.enter = true;


+


+enableC.show["spanning-tree"].root.address.enter = true;


+


+enableC.show["spanning-tree"].root.brief.enter = true;


+


+enableC.show["spanning-tree"].root.cost.enter = true;


+


+enableC.show["spanning-tree"].root["forward-time"].enter = true;


+


+enableC.show["spanning-tree"].root["hello-time"].enter = true;


+


+enableC.show["spanning-tree"].root["max-age"].enter = true;


+


+enableC.show["spanning-tree"].root.port.enter = true;


+


+enableC.show["spanning-tree"].root.priority.enter = true;


+


+enableC.show["spanning-tree"].summary.enter = true;


+


+enableC.show["spanning-tree"].summary.totals.enter = true;


+


+enableC.show["spanning-tree"].uplinkfast.enter = true;


+


+enableC.show["spanning-tree"].vlan["<1-1005>"].enter = true;


+


+enableC.show.stacks.enter = true;


+


+enableC.show.stacks["<1-8192>"].enter = true;


+


+enableC.show.standby.enter = true;


+


+enableC.show.standby["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.standby["Port-channel"]["<1-6>"]["<0-255>"].enter = true;


+


+enableC.show.standby.Vlan["<1-1001>"].enter = true;


+


+enableC.show.standby.Vlan["<1-1001>"]["<0-255>"].enter = true;


+


+enableC.show.standby.brief.enter = true;


+


+enableC.show["startup-config"].enter = true;


+


+enableC.show["storm-control"].enter = true;


+


+enableC.show["storm-control"].broadcast.enter = true;


+


+enableC.show["storm-control"].history.enter = true;


+


+enableC.show["storm-control"].multicast.enter = true;


+


+enableC.show["storm-control"].unicast.enter = true;


+


+enableC.show.subsys.enter = true;


+


+enableC.show.subsys.class.driver.enter = true;


+


+enableC.show.subsys.class.kernel.enter = true;


+


+enableC.show.subsys.class.library.enter = true;


+


+enableC.show.subsys.class.management.enter = true;


+


+enableC.show.subsys.class.protocol.enter = true;


+


+enableC.show.subsys.class.registry.enter = true;


+


+enableC.show.subsys.name.WORD.enter = true;


+


+enableC.show.system.mtu.enter = true;


+


+enableC.show.tacacs.enter = true;


+


+enableC.show.tcp.enter = true;


+


+enableC.show.tcp["<0-16>"].enter = true;


+


+enableC.show.tcp.brief.enter = true;


+


+enableC.show.tcp.brief.all.enter = true;


+


+enableC.show.tcp.console["<0-0>"].enter = true;


+


+enableC.show.tcp.statistics.enter = true;


+


+enableC.show.tcp.tcb["<0x0-0xFFFFFFFF>"].enter = true;


+


+enableC.show.tcp.vty["<0-15>"].enter = true;


+


+enableC.show["tech-support"].enter = true;


+


+enableC.show["tech-support"].page.enter = true;


+


+enableC.show["tech-support"].password.enter = true;


+


+enableC.show.template.enter = true;


+


+enableC.show.template.WORD.enter = true;


+


+enableC.show.terminal.enter = true;


+


+enableC.show["time-range"].enter = true;


+


+enableC.show["time-range"].WORD.enter = true;


+


+enableC.show.udld.enter = true;


+


+enableC.show.udld.Null["<0-0>"].enter = true;


+


+enableC.show.udld["Port-channel"]["<1-6>"].enter = true;


+


+enableC.show.udld.Vlan["<1-1001>"].enter = true;


+


+enableC.show.users.enter = true;


+


+enableC.show.users.all.enter = true;


+


+enableC.show.users.wide.enter = true;


+


+enableC.show.version.enter = true;


+


+enableC.show.vlan.enter = true;


+


+enableC.show.vlan.brief.enter = true;


+


+enableC.show.vlan.id["<1-1005>"].enter = true;


+


+enableC.show.vlan.name.WORD.enter = true;


+


+enableC.show.vmps.enter = true;


+


+enableC.show.vmps.statistics.enter = true;


+


+enableC.show.vtp.counters.enter = true;


+


+enableC.show.vtp.status.enter = true;


+


+enableC.show["wrr-queue"].bandwidth.enter = true;


+


+enableC.show["wrr-queue"]["cos-map"].enter = true;


+


+enableC.write.enter = true;


+


+enableC.write.erase.enter = true;


+


+enableC.write.memory.enter = true;


+


+enableC.write.network.enter = true;


+


+enableC.write.network["flash:"].enter = true;


+


+enableC.write.network["ftp:"].enter = true;


+


+enableC.write.network["null:"].enter = true;


+


+enableC.write.network["nvram:"].enter = true;


+


+enableC.write.network["rcp:"].enter = true;


+


+enableC.write.network["system:"].enter = true;


+


+enableC.write.network["tftp:"].enter = true;


+


+enableC.write.network["zflash:"].enter = true;


+


+enableC.write.terminal.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_extNacl.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_extNacl.txt
new file mode 100644
index 0000000..d5f58c0
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_extNacl.txt
@@ -0,0 +1,74 @@
+extNaclC.deny["<0-255>"].any.any.enter = true;


+


+extNaclC.deny.ahp.any.any.enter = true;


+


+extNaclC.deny.eigrp.any.any.enter = true;


+


+extNaclC.deny.esp.any.any.enter = true;


+


+extNaclC.deny.gre.any.any.enter = true;


+


+extNaclC.deny.icmp.any.any.enter = true;


+


+extNaclC.deny.igmp.any.any.enter = true;


+


+extNaclC.deny.igrp.any.any.enter = true;


+


+extNaclC.deny.ip.any.any.enter = true;


+


+extNaclC.deny.ipinip.any.any.enter = true;


+


+extNaclC.deny.nos.any.any.enter = true;


+


+extNaclC.deny.ospf.any.any.enter = true;


+


+extNaclC.deny.pcp.any.any.enter = true;


+


+extNaclC.deny.pim.any.any.enter = true;


+


+extNaclC.deny.tcp.any.any.enter = true;


+


+extNaclC.deny.udp.any.any.enter = true;


+


+extNaclC.evaluate.WORD.enter = true;


+


+extNaclC.exit.enter = true;


+


+extNaclC.no.evaluate.WORD.enter = true;


+


+extNaclC.permit["<0-255>"].any.any.enter = true;


+


+extNaclC.permit.ahp.any.any.enter = true;


+


+extNaclC.permit.eigrp.any.any.enter = true;


+


+extNaclC.permit.esp.any.any.enter = true;


+


+extNaclC.permit.gre.any.any.enter = true;


+


+extNaclC.permit.icmp.any.any.enter = true;


+


+extNaclC.permit.igmp.any.any.enter = true;


+


+extNaclC.permit.igrp.any.any.enter = true;


+


+extNaclC.permit.ip.any.any.enter = true;


+


+extNaclC.permit.ipinip.any.any.enter = true;


+


+extNaclC.permit.nos.any.any.enter = true;


+


+extNaclC.permit.ospf.any.any.enter = true;


+


+extNaclC.permit.pcp.any.any.enter = true;


+


+extNaclC.permit.pim.any.any.enter = true;


+


+extNaclC.permit.tcp.any.any.enter = true;


+


+extNaclC.permit.udp.any.any.enter = true;


+


+extNaclC.remark.enter = true;


+


+extNaclC.remark.LINE.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_global.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_global.txt
new file mode 100644
index 0000000..67edd1b
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_global.txt
@@ -0,0 +1,983 @@
+globalC.aaa["new-model"].enter = true;


+


+globalC["access-list"]["<1-99>"].deny["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].deny["Hostname or A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].deny.any.enter = true;


+


+globalC["access-list"]["<1-99>"].deny.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].permit["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].permit["Hostname or A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].permit.any.enter = true;


+


+globalC["access-list"]["<1-99>"].permit.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1-99>"].remark.enter = true;


+


+globalC["access-list"]["<1-99>"].remark.LINE.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.ip.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.tcp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].deny.udp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.ip.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.tcp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.any.any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<100-199>"].permit.udp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<100-199>"].remark.enter = true;


+


+globalC["access-list"]["<100-199>"].remark.LINE.enter = true;


+


+globalC["access-list"]["<1300-1999>"].deny["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].deny["Hostname or A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].deny.any.enter = true;


+


+globalC["access-list"]["<1300-1999>"].deny.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].permit["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].permit["Hostname or A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].permit.any.enter = true;


+


+globalC["access-list"]["<1300-1999>"].permit.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<1300-1999>"].remark.enter = true;


+


+globalC["access-list"]["<1300-1999>"].remark.LINE.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.ip.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.tcp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].deny.udp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.ip.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.tcp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp["A.B.C.D"]["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp["A.B.C.D"]["A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp["A.B.C.D"]["A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.any["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.any.any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.any.host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.host["Hostname or A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.host["Hostname or A.B.C.D"].any.enter = true;


+


+globalC["access-list"]["<2000-2699>"].permit.udp.host["Hostname or A.B.C.D"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["access-list"]["<2000-2699>"].remark.enter = true;


+


+globalC["access-list"]["<2000-2699>"].remark.LINE.enter = true;


+


+globalC.banner.LINE.enter = true;


+


+globalC.boot.boothlpr.WORD.enter = true;


+


+globalC.boot.buffersize["<4096-524288>"].enter = true;


+


+globalC.boot["config-file"].WORD.enter = true;


+


+globalC.boot["enable-break"].enter = true;


+


+globalC.boot["helper-config-file"].WORD.enter = true;


+


+globalC.boot.manual.enter = true;


+


+globalC.boot.system.WORD.enter = true;


+


+globalC.cdp["advertise-v2"].enter = true;


+


+globalC.cdp.holdtime["<10-255>"].enter = true;


+


+globalC.cdp.timer["<5-254>"].enter = true;


+


+globalC.cdp.run.enter = true;


+


+globalC.clock["summer-time"].WORD.recurring.enter = true;


+


+globalC.enable["last-resort"].password.enter = true;


+


+globalC.enable["last-resort"].succeed.enter = true;


+


+globalC.enable.password["<7-7>"].WORD.enter = true;


+


+globalC.enable.password.LINE.enter = true;


+


+globalC.enable.secret["5"].LINE.enter = true;


+


+globalC.enable.secret.LINE.enter = true;


+


+globalC.enable["use-tacacs"].enter = true;


+


+globalC.exit.enter = true;


+


+globalC.help.enter = true;


+


+globalC.interface.GigabitEthernet["0/1"].enter = true;


+globalC.interface.GigabitEthernet["0/2"].enter = true;


+globalC.interface.GigabitEthernet["0/3"].enter = true;


+globalC.interface.GigabitEthernet["0/4"].enter = true;


+globalC.interface.GigabitEthernet["0/5"].enter = true;


+globalC.interface.GigabitEthernet["0/6"].enter = true;


+globalC.interface.GigabitEthernet["0/7"].enter = true;


+globalC.interface.GigabitEthernet["0/8"].enter = true;


+globalC.interface.GigabitEthernet["0/9"].enter = true;


+globalC.interface.GigabitEthernet["0/10"].enter = true;


+globalC.interface.GigabitEthernet["0/11"].enter = true;


+globalC.interface.GigabitEthernet["0/12"].enter = true;


+


+globalC.interface.Dialer["<0-255>"].enter = true;


+


+globalC.interface.Dialer["<0-255>"]["<0-4294967295>"].enter = true;


+


+globalC.interface.GigabitEthernet["<1-6>"]["<1-24>"].enter= true;


+


+globalC.interface.GigabitEthernet["<1-6>"]["<1-24>"]["<0-4294967295>"].enter= true;


+


+globalC.interface.Loopback["<0-2147483647>"].enter = true;


+


+globalC.interface.Null["<0-0>"].enter = true;


+


+globalC.interface["Port-channel"]["<1-6>"].enter = true;


+


+globalC.interface.Vlan["<1-1001>"].enter = true;


+


+globalC.interface.Vlan["<1-1001>"]["<0-4294967295>"].enter = true;


+


+globalC.ip["access-list"].extended["<100-199>"].enter = true;


+


+globalC.ip["access-list"].extended.WORD.enter = true;


+


+globalC.ip["access-list"].standard["<1-99>"].enter = true;


+


+globalC.ip["access-list"].standard.WORD.enter = true;


+


+globalC.ip["accounting-list"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+globalC.ip["accounting-threshold"]["<0-4294967295>"].enter = true;


+


+globalC.ip["accounting-transits"]["<0-32000>"].enter = true;


+


+globalC.ip.alias["A.B.C.D"]["<0-65535>"].enter = true;


+


+globalC.ip["default-gateway"].enter = true;


+


+globalC.ip["default-gateway"]["A.B.C.D"].enter = true;


+


+globalC.ip["dhcp-server"]["Hostname or A.B.C.D"].enter = true;


+


+globalC.ip["domain-list"].WORD.enter = true;


+


+globalC.ip["domain-lookup"].enter = true;


+


+globalC.ip["domain-lookup"].nsap.enter = true;


+


+globalC.ip["domain-name"].WORD.enter = true;


+


+globalC.ip.finger.enter = true;


+


+globalC.ip.finger["rfc-compliant"].enter = true;


+


+globalC.ip.ftp.passive.enter = true;


+


+globalC.ip.ftp.password.LINE.enter = true;


+


+globalC.ip.ftp["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.ftp["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.ftp["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.ftp["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip.ftp.username.WORD.enter = true;


+


+globalC.ip.gdp.igrp.enter = true;


+


+globalC.ip.gdp.irdp.enter = true;


+


+globalC.ip.gdp.irdp.multicast.enter = true;


+


+globalC.ip.gdp.rip.enter = true;


+


+globalC.ip["gratuitous-arps"].enter = true;


+


+globalC.ip.host.WORD["A.B.C.D"].enter = true;


+


+globalC.ip["host-routing"].enter = true;


+


+globalC.ip["hp-host"].WORD["A.B.C.D"].enter = true;


+


+globalC.ip.http["access-class"]["<1-99>"].enter = true;


+


+globalC.ip.http.authentication.enable.enter = true;


+


+globalC.ip.http.authentication.local.enter = true;


+


+globalC.ip.http.authentication.tacacs.enter = true;


+


+globalC.ip.http.path.WORD.enter = true;


+


+globalC.ip.http.port["<0-65535>"].enter = true;


+


+globalC.ip.http.server.enter = true;


+


+globalC.ip.icmp["rate-limit"].unreachable["<1-4294967295>"].enter = true;


+


+globalC.ip.icmp.redirect.host.enter = true;


+


+globalC.ip.icmp.redirect.subnet.enter = true;


+


+globalC.ip.igmp.snooping.enter = true;


+


+globalC.ip.igmp.snooping.vlan["<1-1001>"].enter = true;


+


+globalC.ip.igmp.snooping.vlan["<1-1001>"]["immediate-leave"].enter = true;


+


+globalC.ip.igmp.snooping.vlan["<1-1001>"].mrouter.interface["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.igmp.snooping.vlan["<1-1001>"].mrouter.learn.cgmp.enter = true;


+


+globalC.ip.igmp.snooping.vlan["<1-1001>"].mrouter.learn["pim-dvmrp"].enter = true;


+


+globalC.ip["name-server"]["A.B.C.D"].enter = true;


+


+globalC.ip.radius["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.radius["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.radius["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.radius["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip.rcmd["domain-lookup"].enter = true;


+


+globalC.ip.rcmd["rcp-enable"].enter = true;


+


+globalC.ip.rcmd["remote-host"].WORD["Hostname or A.B.C.D"].WORD.enter = true;


+


+globalC.ip.rcmd["remote-host"].WORD["Hostname or A.B.C.D"].WORD.enable.enter = true;


+


+globalC.ip.rcmd["remote-host"].WORD["Hostname or A.B.C.D"].WORD.enable["<1-15>"].enter = true;


+


+globalC.ip.rcmd["remote-username"].WORD.enter = true;


+


+globalC.ip.rcmd["rsh-enable"].enter = true;


+


+globalC.ip.rcmd["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.rcmd["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.rcmd["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.rcmd["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip["reflexive-list"].timeout["<1-2147483647>"].enter = true;


+


+globalC.ip.security["eso-info"]["<0-255>"]["<1-16>"]["<0-1>"].enter = true;


+


+globalC.ip["source-route"].enter = true;


+


+globalC.ip["subnet-zero"].enter = true;


+


+globalC.ip.tacacs["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.tacacs["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.tacacs["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.tacacs["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip.tcp["async-mobility"].server.enter = true;


+


+globalC.ip.tcp["chunk-size"]["<0-4294967295>"].enter = true;


+


+globalC.ip.tcp.mss["<0-10000>"].enter = true;


+


+globalC.ip.tcp["path-mtu-discovery"].enter = true;


+


+globalC.ip.tcp["path-mtu-discovery"]["age-timer"]["<10-30>"].enter = true;


+


+globalC.ip.tcp["path-mtu-discovery"]["age-timer"].infinite.enter = true;


+


+globalC.ip.tcp.queuemax["<5-50>"].enter = true;


+


+globalC.ip.tcp["selective-ack"].enter = true;


+


+globalC.ip.tcp["synwait-time"]["<5-300>"].enter = true;


+


+globalC.ip.tcp.timestamp.enter = true;


+


+globalC.ip.tcp["window-size"]["<0-65535>"].enter = true;


+


+globalC.ip.telnet.comport.disconnect.delay["<0-360>"].enter = true;


+


+globalC.ip.telnet.comport.enable.enter = true;


+


+globalC.ip.telnet.comport.flow.level["<1-1023>"].enter = true;


+


+globalC.ip.telnet.comport.receive.window["<1-4128>"].enter = true;


+


+globalC.ip.telnet.quiet.enter = true;


+


+globalC.ip.telnet["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.telnet["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.telnet["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.telnet["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip.telnet.tos["<0-FF>"].enter = true;


+


+globalC.ip.tftp["boot-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.tftp["boot-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.tftp["boot-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.tftp["boot-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.ip.tftp["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.ip.tftp["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.ip.tftp["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.ip.tftp["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.line["<0-16>"].enter = true;


+


+globalC.line["<0-16>"]["<1-16>"].enter = true;


+


+globalC.line.console["<0-0>"].enter = true;


+


+globalC.line.vty["<0-15>"].enter = true;


+


+globalC.line.vty["<0-15>"]["<1-15>"].enter = true;


+


+globalC.logging["Hostname or A.B.C.D"].enter = true;


+


+globalC.logging.buffered.enter = true;


+


+globalC.logging.buffered["<0-7>"].enter = true;


+


+globalC.logging.buffered["<4096-2147483647>"].enter = true;


+


+globalC.logging.buffered.alerts.enter = true;


+


+globalC.logging.buffered.critical.enter = true;


+


+globalC.logging.buffered.debugging.enter = true;


+


+globalC.logging.buffered.emergencies.enter = true;


+


+globalC.logging.buffered.errors.enter = true;


+


+globalC.logging.buffered.informational.enter = true;


+


+globalC.logging.buffered.notifications.enter = true;


+


+globalC.logging.buffered.warnings.enter = true;


+


+globalC.logging.console.enter = true;


+


+globalC.logging.console["<0-7>"].enter = true;


+


+globalC.logging.console.alerts.enter = true;


+


+globalC.logging.console.critical.enter = true;


+


+globalC.logging.console.debugging.enter = true;


+


+globalC.logging.console.emergencies.enter = true;


+


+globalC.logging.console.errors.enter = true;


+


+globalC.logging.console.guaranteed.enter = true;


+


+globalC.logging.console.informational.enter = true;


+


+globalC.logging.console.notifications.enter = true;


+


+globalC.logging.console.warnings.enter = true;


+


+globalC.logging.facility.auth.enter = true;


+


+globalC.logging.facility.cron.enter = true;


+


+globalC.logging.facility.daemon.enter = true;


+


+globalC.logging.facility.kern.enter = true;


+


+globalC.logging.facility.local0.enter = true;


+


+globalC.logging.facility.local1.enter = true;


+


+globalC.logging.facility.local2.enter = true;


+


+globalC.logging.facility.local3.enter = true;


+


+globalC.logging.facility.local4.enter = true;


+


+globalC.logging.facility.local5.enter = true;


+


+globalC.logging.facility.local6.enter = true;


+


+globalC.logging.facility.local7.enter = true;


+


+globalC.logging.facility.lpr.enter = true;


+


+globalC.logging.facility.mail.enter = true;


+


+globalC.logging.facility.news.enter = true;


+


+globalC.logging.facility.sys10.enter = true;


+


+globalC.logging.facility.sys11.enter = true;


+


+globalC.logging.facility.sys12.enter = true;


+


+globalC.logging.facility.sys13.enter = true;


+


+globalC.logging.facility.sys14.enter = true;


+


+globalC.logging.facility.sys9.enter = true;


+


+globalC.logging.facility.syslog.enter = true;


+


+globalC.logging.facility.user.enter = true;


+


+globalC.logging.facility.uucp.enter = true;


+


+globalC.logging.history["<0-7>"].enter = true;


+


+globalC.logging.history.alerts.enter = true;


+


+globalC.logging.history.critical.enter = true;


+


+globalC.logging.history.debugging.enter = true;


+


+globalC.logging.history.emergencies.enter = true;


+


+globalC.logging.history.errors.enter = true;


+


+globalC.logging.history.informational.enter = true;


+


+globalC.logging.history.notifications.enter = true;


+


+globalC.logging.history.size["<0-500>"].enter = true;


+


+globalC.logging.history.warnings.enter = true;


+


+globalC.logging.monitor.enter = true;


+


+globalC.logging.monitor["<0-7>"].enter = true;


+


+globalC.logging.monitor.alerts.enter = true;


+


+globalC.logging.monitor.critical.enter = true;


+


+globalC.logging.monitor.debugging.enter = true;


+


+globalC.logging.monitor.emergencies.enter = true;


+


+globalC.logging.monitor.errors.enter = true;


+


+globalC.logging.monitor.informational.enter = true;


+


+globalC.logging.monitor.notifications.enter = true;


+


+globalC.logging.monitor.warnings.enter = true;


+


+globalC.logging["on"].enter = true;


+


+globalC.logging["source-interface"].Loopback["<0-2147483647>"].enter = true;


+


+globalC.logging["source-interface"].Null["<0-0>"].enter = true;


+


+globalC.logging["source-interface"]["Port-channel"]["<1-6>"].enter = true;


+


+globalC.logging["source-interface"].Vlan["<1-1001>"].enter = true;


+


+globalC.logging.trap.enter = true;


+


+globalC.logging.trap["<0-7>"].enter = true;


+


+globalC.logging.trap.alerts.enter = true;


+


+globalC.logging.trap.critical.enter = true;


+


+globalC.logging.trap.debugging.enter = true;


+


+globalC.logging.trap.emergencies.enter = true;


+


+globalC.logging.trap.errors.enter = true;


+


+globalC.logging.trap.informational.enter = true;


+


+globalC.logging.trap.notifications.enter = true;


+


+globalC.logging.trap.warnings.enter = true;


+


+globalC["map-class"].atm.WORD.enter = true;


+


+globalC["map-class"].dialer.WORD.enter = true;


+


+globalC["map-class"]["frame-relay"].WORD.enter = true;


+


+globalC["queue-list"]["<1-16>"]["default"]["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].interface.Null["<0-0>"]["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].interface["Port-channel"]["<1-6>"]["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].interface.Vlan["<1-1001>"]["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"]["lowest-custom"]["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.arp["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.arp["<0-16>"]["gt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.arp["<0-16>"]["lt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.cdp["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.cdp["<0-16>"]["gt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.cdp["<0-16>"]["lt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.compressedtcp["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.compressedtcp["<0-16>"]["gt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.compressedtcp["<0-16>"]["lt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].fragments.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"]["gt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].list["<1-199>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].list["<1300-2699>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"]["lt"]["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.bgp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.chargen.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.cmd.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.daytime.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.discard.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.domain.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.echo.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.exec.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.finger.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.ftp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp["ftp-data"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.gopher.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.hostname.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.ident.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.irc.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.klogin.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.kshell.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.login.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.lpd.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.nntp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp["pim-auto-rp"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.pop2.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.pop3.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.smtp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.sunrpc.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.syslog.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.tacacs.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.talk.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.telnet.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.time.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.uucp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.whois.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].tcp.www.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["<0-65535>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.biff.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.bootpc.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.bootps.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.discard.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.dnsix.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.domain.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.echo.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.isakmp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["mobile-ip"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.nameserver.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["netbios-dgm"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["netbios-ns"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["netbios-ss"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.ntp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp["pim-auto-rp"].enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.rip.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.snmp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.snmptrap.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.sunrpc.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.syslog.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.tacacs.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.talk.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.tftp.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.time.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.who.enter = true;


+


+globalC["queue-list"]["<1-16>"].protocol.ip["<0-16>"].udp.xdmcp.enter = true;


+


+globalC["queue-list"]["<1-16>"].queue["<0-16>"]["byte-count"]["<1-16777215>"].enter = true;


+


+globalC["queue-list"]["<1-16>"].queue["<0-16>"].limit["<0-32767>"].enter = true;


+


+globalC["spanning-tree"].backbonefast.enter = true;


+


+globalC["spanning-tree"].portfast.bpduguard.enter = true;


+


+globalC["spanning-tree"].uplinkfast.enter = true;


+


+globalC["spanning-tree"].uplinkfast["max-update-rate"]["<0-65535>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"]["forward-time"]["<4-30>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"]["hello-time"]["<1-10>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"]["max-age"]["<6-40>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].priority["<0-65535>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.primary.enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.primary.diameter["<2-7>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.primary.diameter["<2-7>"]["hello-time"]["<1-10>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.secondary.enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.secondary.diameter["<2-7>"].enter = true;


+


+globalC["spanning-tree"].vlan["<1-1005>"].root.secondary.diameter["<2-7>"]["hello-time"]["<1-10>"].enter = true;


+


+globalC["tacacs-server"].administration.enter = true;


+


+globalC["tacacs-server"].attempts["<1-1000>"].enter = true;


+


+globalC["tacacs-server"]["directed-request"].enter = true;


+


+globalC["tacacs-server"]["dns-alias-lookup"].enter = true;


+


+globalC["tacacs-server"].extended.enter = true;


+


+globalC["tacacs-server"].host.enter = true;


+


+globalC["tacacs-server"].host["Hostname or A.B.C.D"].enter = true;


+


+globalC["tacacs-server"].key.LINE.enter = true;


+


+globalC["tacacs-server"]["last-resort"].password.enter = true;


+


+globalC["tacacs-server"]["last-resort"].succeed.enter = true;


+


+globalC["tacacs-server"]["optional-passwords"].enter = true;


+


+globalC["tacacs-server"].packet.maxsize["<10240-65536>"].enter = true;


+


+globalC["tacacs-server"].retransmit["<0-100>"].enter = true;


+


+globalC["tacacs-server"].timeout["<1-1000>"].enter = true;


+


+globalC["time-range"].WORD.enter = true;


+


+globalC.username.WORD.enter = true;


+


+globalC.username.WORD["access-class"]["<1-199>"].enter = true;


+


+globalC.username.WORD["access-class"]["<1300-2699>"].enter = true;


+


+globalC.username.WORD.autocommand.LINE.enter = true;


+


+globalC.username.WORD["callback-dialstring"].WORD.enter = true;


+


+globalC.username.WORD["callback-line"]["<0-16>"].enter = true;


+


+globalC.username.WORD["callback-line"].console["<0-0>"].enter = true;


+


+globalC.username.WORD["callback-line"].vty["<0-15>"].enter = true;


+


+globalC.username.WORD["callback-rotary"]["<0-100>"].enter = true;


+


+globalC.username.WORD.dnis.enter = true;


+


+globalC.username.WORD["nocallback-verify"].enter = true;


+


+globalC.username.WORD.noescape.enter = true;


+


+globalC.username.WORD.nohangup.enter = true;


+


+globalC.username.WORD.nopassword.enter = true;


+


+globalC.username.WORD.password["<7-7>"].WORD.enter = true;


+


+globalC.username.WORD.password.LINE.enter = true;


+


+globalC.username.WORD.privilege["<0-15>"].enter = true;


+


+globalC.username.WORD["user-maxlinks"]["<1-255>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intE.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intE.txt
new file mode 100644
index 0000000..2f77855
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intE.txt
@@ -0,0 +1,77 @@
+intEC.description.LINE.enter = true;


+


+intEC.exit.enter = true;


+


+intEC.ip.address["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intEC.no.description.enter = true;


+


+intEC.no.ip.address.enter = true;


+


+intEC.no.shutdown.enter = true;


+


+intEC.no["spanning-tree"].cost.enter = true;


+


+intEC.no["spanning-tree"].guard.enter = true;


+


+intEC.no["spanning-tree"]["port-priority"].enter = true;


+


+intEC.no["spanning-tree"].portfast.enter = true;


+


+intEC.no.speed.enter = true;


+


+intEC.no.switchport.enter = true;


+


+intEC.no.switchport.access.vlan.enter = true;


+


+intEC.no.switchport.host.enter = true;


+


+intEC.no.switchport.mode.enter = true;


+


+intEC.no.switchport.nonegotiate.enter = true;


+


+intEC.no.switchport["private-vlan"]["host-association"].enter = true;


+


+intEC.no.switchport["private-vlan"].mapping.enter = true;


+


+intEC.no.switchport.trunk.encapsulation.enter = true;


+


+intEC.shutdown.enter = true;


+


+intEC["spanning-tree"].cost["<1-200000000>"].enter = true;


+


+intEC["spanning-tree"].guard.none.enter = true;


+


+intEC["spanning-tree"].guard.root.enter = true;


+


+intEC["spanning-tree"]["port-priority"]["<0-240>"].enter = true;


+


+intEC["spanning-tree"].portfast.enter = true;


+


+intEC.speed.nonegotiate.enter = true;


+


+intEC.switchport.enter = true;


+


+intEC.switchport.access.vlan["<1-1005>"].enter = true;


+


+intEC.switchport.host.enter = true;


+


+intEC.switchport.mode.access.enter = true;


+


+intEC.switchport.mode.dynamic.auto.enter = true;


+


+intEC.switchport.mode.dynamic.desirable.enter = true;


+


+intEC.switchport.mode["private-vlan"].host.enter = true;


+


+intEC.switchport.mode["private-vlan"].promiscuous.enter = true;


+


+intEC.switchport.mode.trunk.enter = true;


+


+intEC.switchport.nonegotiate.enter = true;


+


+intEC.switchport.trunk.encapsulation.dot1q.enter = true;


+


+intEC.switchport.trunk.encapsulation.isl.enter = true;


+


+intEC.switchport.trunk.encapsulation.negotiate.enter = true;


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intG.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intG.txt
new file mode 100644
index 0000000..574bd53
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intG.txt
@@ -0,0 +1,140 @@
+intGC.arp.arpa.enter = true;


+


+intGC.arp["frame-relay"].enter = true;


+


+intGC.arp.probe.enter = true;


+


+intGC.arp.snap.enter = true;


+


+intGC.backup.delay["<0-4294967294>"].never.enter = true;


+


+intGC.backup.delay.never["<0-4294967294>"].enter = true;


+


+intGC.backup.delay.never.never.enter = true;


+


+intGC.backup.interface.Null["<0-0>"].enter = true;


+


+intGC.backup.interface.Vlan["<1-1001>"].enter = true;


+


+intGC.backup.load["<0-100>"].never.enter = true;


+


+intGC.backup.load.never["<0-100>"].enter = true;


+


+intGC.backup.load.never.never.enter = true;


+


+intGC.bandwidth["<1-10000000>"].enter = true;


+


+intGC["bgp-policy"].accounting.enter = true;


+


+intGC["carrier-delay"]["<0-60>"].enter = true;


+


+intGC.cdp.enable.enter = true;


+


+intGC["custom-queue-list"]["<1-16>"].enter = true;


+


+intGC["default"].bandwidth.enter = true;


+


+intGC["default"]["carrier-delay"].enter = true;


+


+intGC["default"]["channel-group"].enter = true;


+


+intGC["default"]["custom-queue-list"].enter = true;


+


+intGC.delay["<1-16777215>"].enter = true;


+


+intGC.description.LINE.enter = true;


+


+intGC.exit.enter = true;


+


+intGC["fair-queue"].enter = true;


+


+intGC["fair-queue"]["<1-4096>"].enter = true;


+


+intGC["fair-queue"]["<1-4096>"]["<16-4096>"].enter = true;


+


+intGC["fair-queue"]["<1-4096>"]["<16-4096>"]["<0-1000>"].enter = true;


+


+intGC.help.enter = true;


+


+intGC.ip.address["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intGC.ip.address["A.B.C.D"]["A.B.C.D"].secondary.enter = true;


+


+intGC.keepalive.enter = true;


+


+intGC.keepalive["<0-32767>"].enter = true;


+


+intGC["load-interval"]["<30-600>"].enter = true;


+


+intGC.loopback.enter = true;


+


+intGC["max-reserved-bandwidth"].enter = true;


+


+intGC["max-reserved-bandwidth"]["<1-100>"].enter = true;


+


+intGC.no.bandwidth.enter = true;


+


+intGC.no["carrier-delay"].enter = true;


+


+intGC.no["channel-group"].enter = true;


+


+intGC.no["custom-queue-list"].enter = true;


+


+intGC.no.delay.enter = true;


+


+intGC.no.description.enter = true;


+


+intGC.no["fair-queue"].enter = true;


+


+intGC.no.keepalive.enter = true;


+


+intGC.no["load-interval"].enter = true;


+


+intGC.no.loopback.enter = true;


+


+intGC.no["max-reserved-bandwidth"].enter = true;


+


+intGC.ntp.broadcast.enter = true;


+


+intGC.ntp.disable.enter = true;


+


+intGC.ntp.multicast.enter = true;


+


+intGC["priority-group"]["<1-16>"].enter = true;


+


+intGC.qos.enter = true;


+


+intGC.qos["vlan-based"].enter = true;


+


+intGC["random-detect"].enter = true;


+


+intGC.rmon.native.enter = true;


+


+intGC.rmon.promiscuous.enter = true;


+


+intGC["service-policy"].history.enter = true;


+


+intGC.shutdown.enter = true;


+


+intGC["spanning-tree"].portfast.enter = true;


+


+intGC.speed.nonegotiate.enter = true;


+


+intGC.switchport.enter = true;


+


+intGC.switchport.host.enter = true;


+


+intGC.switchport.nonegotiate.enter = true;


+


+intGC["tx-queue"]["<1-4>"].enter = true;


+


+intGC["tx-ring-limit"].enter = true;


+


+intGC["tx-ring-limit"]["<1-32767>"].enter = true;


+


+intGC.udld.aggressive.enter = true;


+


+intGC.udld.disable.enter = true;


+


+intGC.udld.enable.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intLoopBack.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intLoopBack.txt
new file mode 100644
index 0000000..dd5c674
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intLoopBack.txt
@@ -0,0 +1,268 @@
+intLoopBackC.arp.arpa.enter = true;


+


+intLoopBackC.arp["frame-relay"].enter = true;


+


+intLoopBackC.arp.probe.enter = true;


+


+intLoopBackC.arp.snap.enter = true;


+


+intLoopBackC.backup.delay["<0-4294967294>"].never.enter = true;


+


+intLoopBackC.backup.delay.never["<0-4294967294>"].enter = true;


+


+intLoopBackC.backup.delay.never.never.enter = true;


+


+intLoopBackC.backup.interface.Null["<0-0>"].enter = true;


+


+intLoopBackC.backup.interface.Vlan["<1-1001>"].enter = true;


+


+intLoopBackC.backup.load["<0-100>"].never.enter = true;


+


+intLoopBackC.backup.load.never["<0-100>"].enter = true;


+


+intLoopBackC.backup.load.never.never.enter = true;


+


+intLoopBackC.bandwidth["<1-10000000>"].enter = true;


+


+intLoopBackC["bgp-policy"].accounting.enter = true;


+


+intLoopBackC["carrier-delay"]["<0-60>"].enter = true;


+


+intLoopBackC.cdp.enable.enter = true;


+


+intLoopBackC["default"].bandwidth.enter = true;


+


+intLoopBackC["default"]["carrier-delay"].enter = true;


+


+intLoopBackC.delay["<1-16777215>"].enter = true;


+


+intLoopBackC.description.LINE.enter = true;


+


+intLoopBackC.exit.enter = true;


+


+intLoopBackC.help.enter = true;


+


+intLoopBackC.ip["access-group"]["<1-199>"]["in"].enter = true;


+


+intLoopBackC.ip["access-group"]["<1-199>"].out.enter = true;


+


+intLoopBackC.ip["access-group"]["<1300-2699>"]["in"].enter = true;


+


+intLoopBackC.ip["access-group"]["<1300-2699>"].out.enter = true;


+


+intLoopBackC.ip["access-group"].WORD["in"].enter = true;


+


+intLoopBackC.ip["access-group"].WORD.out.enter = true;


+


+intLoopBackC.ip.address["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip.address["A.B.C.D"]["A.B.C.D"].secondary.enter = true;


+


+intLoopBackC.ip.authentication["key-chain"].eigrp["<1-65535>"].LINE.enter = true;


+


+intLoopBackC.ip.authentication.mode.eigrp["<1-65535>"].md5.enter = true;


+


+intLoopBackC.ip["bandwidth-percent"].eigrp["<1-65535>"]["<1-999999>"].enter = true;


+


+intLoopBackC.ip.bgp["fast-external-fallover"].deny.enter = true;


+


+intLoopBackC.ip.bgp["fast-external-fallover"].permit.enter = true;


+


+intLoopBackC.ip["broadcast-address"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip.cef.accounting["non-recursive"].enter = true;


+


+intLoopBackC.ip.cef.accounting["non-recursive"].external.enter = true;


+


+intLoopBackC.ip.cef.accounting["non-recursive"].internal.enter = true;


+


+intLoopBackC.ip.cgmp.enter = true;


+


+intLoopBackC.ip.cgmp.proxy.enter = true;


+


+intLoopBackC.ip.cgmp["router-only"].enter = true;


+


+intLoopBackC.ip["directed-broadcast"].enter = true;


+


+intLoopBackC.ip["directed-broadcast"]["<1-199>"].enter = true;


+


+intLoopBackC.ip["directed-broadcast"]["<1300-2699>"].enter = true;


+


+intLoopBackC.ip["hello-interval"].eigrp["<1-65535>"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip["helper-address"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip["hold-time"].eigrp["<1-65535>"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip["load-sharing"]["per-destination"].enter = true;


+


+intLoopBackC.ip["load-sharing"]["per-packet"].enter = true;


+


+intLoopBackC.ip["local-proxy-arp"].enter = true;


+


+intLoopBackC.ip["mask-reply"].enter = true;


+


+intLoopBackC.ip.mrm["test-receiver"].enter = true;


+


+intLoopBackC.ip.mrm["test-sender"].enter = true;


+


+intLoopBackC.ip.mrm["test-sender-receiver"].enter = true;


+


+intLoopBackC.ip["mroute-cache"].enter = true;


+


+intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"]["<100-199>"].enter = true;


+


+intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"]["<2000-2699>"].enter = true;


+


+intLoopBackC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].WORD.enter = true;


+


+intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"]["<100-199>"].enter = true;


+


+intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"]["<2000-2699>"].enter = true;


+


+intLoopBackC.ip.multicast["helper-map"].broadcast["A.B.C.D"].WORD.enter = true;


+


+intLoopBackC.ip.ospf.authentication.enter = true;


+


+intLoopBackC.ip.ospf.authentication["message-digest"].enter = true;


+


+intLoopBackC.ip.ospf.authentication.null.enter = true;


+


+intLoopBackC.ip.ospf["authentication-key"].LINE.enter = true;


+


+intLoopBackC.ip.ospf.cost["<1-65535>"].enter = true;


+


+intLoopBackC.ip.ospf["database-filter"].all.out.enter = true;


+


+intLoopBackC.ip.ospf["dead-interval"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip.ospf["demand-circuit"].enter = true;


+


+intLoopBackC.ip.ospf["hello-interval"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip.ospf["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+intLoopBackC.ip.ospf["mtu-ignore"].enter = true;


+


+intLoopBackC.ip.ospf.network.broadcast.enter = true;


+


+intLoopBackC.ip.ospf.network["non-broadcast"].enter = true;


+


+intLoopBackC.ip.ospf.network["point-to-multipoint"].enter = true;


+


+intLoopBackC.ip.ospf.network["point-to-multipoint"]["non-broadcast"].enter = true;


+


+intLoopBackC.ip.ospf.network["point-to-point"].enter = true;


+


+intLoopBackC.ip.ospf.priority["<0-255>"].enter = true;


+


+intLoopBackC.ip.ospf["retransmit-interval"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip.ospf["transmit-delay"]["<1-65535>"].enter = true;


+


+intLoopBackC.ip.pim.enter = true;


+


+intLoopBackC.ip.probe.proxy.enter = true;


+


+intLoopBackC.ip["proxy-arp"].enter = true;


+


+intLoopBackC.ip["rarp-server"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip.redirects.enter = true;


+


+intLoopBackC.ip.rgmp.enter = true;


+


+intLoopBackC.ip.rip.authentication["key-chain"].LINE.enter = true;


+


+intLoopBackC.ip.rip.authentication.mode.md5.enter = true;


+


+intLoopBackC.ip.rip.authentication.mode.text.enter = true;


+


+intLoopBackC.ip.rip.receive.version.enter = true;


+


+intLoopBackC.ip.rip.send.version.enter = true;


+intLoopBackC.ip.rip["v2-broadcast"].enter = true;


+


+intLoopBackC.ip["route-cache"].enter = true;


+


+intLoopBackC.ip["route-cache"].cef.enter = true;


+


+intLoopBackC.ip["route-cache"].flow.enter = true;


+


+intLoopBackC.ip["route-cache"]["same-interface"].enter = true;


+


+intLoopBackC.ip.sap.listen.enter = true;


+


+intLoopBackC.ip.sdr.listen.enter = true;


+intLoopBackC.ip.security.first.enter = true;


+


+intLoopBackC.ip.security.strip.enter = true;


+


+intLoopBackC.ip["split-horizon"].enter = true;


+


+intLoopBackC.ip["split-horizon"].eigrp["<1-65535>"].enter = true;


+


+intLoopBackC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"]["<1-255>"].enter = true;


+


+intLoopBackC.ip["summary-address"].rip["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intLoopBackC.ip.tcp["compression-connections"]["<3-256>"].enter = true;


+


+intLoopBackC.ip.tcp["header-compression"].enter = true;


+


+intLoopBackC.ip.tcp["header-compression"].passive.enter = true;


+


+intLoopBackC.ip.unnumbered.Null["<0-0>"].enter = true;


+


+intLoopBackC.ip.unnumbered.Vlan["<1-1001>"].enter = true;


+


+intLoopBackC.ip.unreachables.enter = true;


+


+intLoopBackC.keepalive.enter = true;


+


+intLoopBackC.keepalive["<0-32767>"].enter = true;


+


+intLoopBackC["load-interval"]["<30-600>"].enter = true;


+


+intLoopBackC["max-reserved-bandwidth"].enter = true;


+


+intLoopBackC["max-reserved-bandwidth"]["<1-100>"].enter = true;


+


+intLoopBackC.no.bandwidth.enter = true;


+


+intLoopBackC.no["carrier-delay"].enter = true;


+


+intLoopBackC.no.delay.enter = true;


+


+intLoopBackC.no.description.enter = true;


+


+intLoopBackC.no.keepalive.enter = true;


+


+intLoopBackC.no["load-interval"].enter = true;


+


+intLoopBackC.no["max-reserved-bandwidth"].enter = true;


+


+intLoopBackC.ntp.broadcast.enter = true;


+


+intLoopBackC.ntp.disable.enter = true;


+


+intLoopBackC.ntp.multicast.enter = true;


+


+intLoopBackC.rmon.native.enter = true;


+


+intLoopBackC.rmon.promiscuous.enter = true;


+


+intLoopBackC["service-policy"].history.enter = true;


+


+


+


+intLoopBackC.shutdown.enter = true;


+


+intLoopBackC["spanning-tree"].portfast.enter = true;


+


+intLoopBackC["tx-ring-limit"].enter = true;


+


+intLoopBackC["tx-ring-limit"]["<1-32767>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intVlan.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intVlan.txt
new file mode 100644
index 0000000..0c3b4f7
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_intVlan.txt
@@ -0,0 +1,918 @@
+intVlanC.arp.arpa.enter = true;


+


+intVlanC.arp["frame-relay"].enter = true;


+


+intVlanC.arp.probe.enter = true;


+


+intVlanC.arp.snap.enter = true;


+


+intVlanC.backup.delay["<0-4294967294>"].never.enter = true;


+


+intVlanC.backup.delay.never["<0-4294967294>"].enter = true;


+


+intVlanC.backup.delay.never.never.enter = true;


+


+intVlanC.backup.interface.Null["<0-0>"].enter = true;


+


+intVlanC.backup.interface.Vlan["<1-1001>"].enter = true;


+


+intVlanC.backup.load["<0-100>"].never.enter = true;


+


+intVlanC.backup.load.never["<0-100>"].enter = true;


+


+intVlanC.backup.load.never.never.enter = true;


+


+intVlanC.bandwidth["<1-10000000>"].enter = true;


+


+intVlanC["bgp-policy"].accounting.enter = true;


+


+intVlanC["carrier-delay"]["<0-60>"].enter = true;


+


+intVlanC.cdp.enable.enter = true;


+


+intVlanC["custom-queue-list"]["<1-16>"].enter = true;


+


+intVlanC["default"].bandwidth.enter = true;


+


+intVlanC["default"]["carrier-delay"].enter = true;


+


+intVlanC["default"]["custom-queue-list"].enter = true;


+


+intVlanC.delay["<1-16777215>"].enter = true;


+


+intVlanC.description.LINE.enter = true;


+


+intVlanC.exit.enter = true;


+


+intVlanC["fair-queue"].enter = true;


+


+intVlanC["fair-queue"]["<1-4096>"].enter = true;


+


+intVlanC["fair-queue"]["<1-4096>"]["<16-4096>"].enter = true;


+


+intVlanC["fair-queue"]["<1-4096>"]["<16-4096>"]["<0-1000>"].enter = true;


+


+intVlanC.help.enter = true;


+


+intVlanC.ip["access-group"]["<1-199>"]["in"].enter = true;


+


+intVlanC.ip["access-group"]["<1-199>"].out.enter = true;


+


+intVlanC.ip["access-group"]["<1300-2699>"]["in"].enter = true;


+


+intVlanC.ip["access-group"]["<1300-2699>"].out.enter = true;


+


+intVlanC.ip["access-group"].WORD["in"].enter = true;


+


+intVlanC.ip["access-group"].WORD.out.enter = true;


+


+intVlanC.ip.address["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.address["A.B.C.D"]["A.B.C.D"].secondary.enter = true;


+


+intVlanC.ip.authentication["key-chain"].eigrp["<1-65535>"].LINE.enter = true;


+


+intVlanC.ip.authentication.mode.eigrp["<1-65535>"].md5.enter = true;


+


+intVlanC.ip["bandwidth-percent"].eigrp["<1-65535>"]["<1-999999>"].enter = true;


+


+intVlanC.ip.bgp["fast-external-fallover"].deny.enter = true;


+


+intVlanC.ip.bgp["fast-external-fallover"].permit.enter = true;


+


+intVlanC.ip["broadcast-address"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.cef.accounting["non-recursive"].enter = true;


+


+intVlanC.ip.cef.accounting["non-recursive"].external.enter = true;


+


+intVlanC.ip.cef.accounting["non-recursive"].internal.enter = true;


+


+intVlanC.ip.cgmp.enter = true;


+


+intVlanC.ip.cgmp.proxy.enter = true;


+


+intVlanC.ip.cgmp["router-only"].enter = true;


+


+intVlanC.ip["directed-broadcast"].enter = true;


+


+intVlanC.ip["directed-broadcast"]["<1-199>"].enter = true;


+


+intVlanC.ip["directed-broadcast"]["<1300-2699>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1-99>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1-99>"]["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1300-1999>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1300-1999>"]["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1300-1999>"]["neighbor-list"]["<1-99>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"]["<1300-1999>"]["neighbor-list"]["<1-99>"]["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD.enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD["neighbor-list"]["<1-99>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD["neighbor-list"]["<1-99>"]["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD["neighbor-list"]["<1300-1999>"].enter = true;


+


+intVlanC.ip.dvmrp["accept-filter"].WORD["neighbor-list"]["<1300-1999>"]["<0-255>"].enter = true;


+


+intVlanC.ip.dvmrp["auto-summary"].enter = true;


+


+intVlanC.ip.dvmrp["default-information"].only.enter = true;


+


+intVlanC.ip.dvmrp["default-information"].originate.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].bgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].bgp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].connected.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].dvmrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].egp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].egp["<0-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].eigrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].igrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].igrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].isis.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].isis.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].bgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].bgp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].connected.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].dvmrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].egp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].egp["<0-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].eigrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].igrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].igrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].isis.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1-99>"].isis.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].bgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].bgp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].connected.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].dvmrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].egp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].egp["<0-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].eigrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].igrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].igrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].isis.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list["<1300-1999>"].isis.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.bgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.bgp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.connected.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.dvmrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.egp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.egp["<0-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.eigrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.igrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.igrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.isis.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].list.WORD.isis.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].mbgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].mobile.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].odr.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].ospf.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].ospf["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].ospf["<1-65535>"].vrf.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].ospf["<1-65535>"].vrf.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].rip.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.bgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.bgp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.connected.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.egp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.egp["<0-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.eigrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.igrp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.igrp["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.isis.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.isis.WORD.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.mbgp.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.mobile.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.odr.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.ospf.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.ospf["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.ospf["<1-65535>"].vrf.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"]["route-map"].WORD.rip.enter = true;


+


+intVlanC.ip.dvmrp.metric["<0-32>"].static.enter = true;


+


+intVlanC.ip.dvmrp["metric-offset"]["<1-31>"].enter = true;


+


+intVlanC.ip.dvmrp["metric-offset"]["in"]["<1-31>"].enter = true;


+


+intVlanC.ip.dvmrp["metric-offset"].out["<1-31>"].enter = true;


+


+intVlanC.ip.dvmrp["output-report-delay"]["<0-1000>"].enter = true;


+


+intVlanC.ip.dvmrp["output-report-delay"]["<0-1000>"]["<1-65535>"].enter = true;


+


+intVlanC.ip.dvmrp["reject-non-pruners"].enter = true;


+


+intVlanC.ip.dvmrp["summary-address"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.dvmrp["summary-address"]["A.B.C.D"]["A.B.C.D"].metric["<1-32>"].enter = true;


+


+intVlanC.ip.dvmrp["unicast-routing"].enter = true;


+


+intVlanC.ip["hello-interval"].eigrp["<1-65535>"]["<1-65535>"].enter = true;


+


+intVlanC.ip["helper-address"]["A.B.C.D"].enter = true;


+


+intVlanC.ip["hold-time"].eigrp["<1-65535>"]["<1-65535>"].enter = true;


+


+intVlanC.ip.igmp["access-group"]["<1-99>"].enter = true;


+


+intVlanC.ip.igmp["access-group"].WORD.enter = true;


+


+intVlanC.ip.igmp["helper-address"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.igmp["helper-address"].udl.Null["<0-0>"].enter = true;


+


+intVlanC.ip.igmp["helper-address"].udl.Vlan["<1-1001>"].enter = true;


+


+intVlanC.ip.igmp["join-group"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.igmp["last-member-query-interval"]["<100-65535>"].enter = true;


+


+intVlanC.ip.igmp["querier-timeout"]["<60-300>"].enter = true;


+


+intVlanC.ip.igmp["query-interval"]["<1-65535>"].enter = true;


+


+intVlanC.ip.igmp["query-max-response-time"]["<1-25>"].enter = true;


+


+intVlanC.ip.igmp["static-group"]["*"].enter = true;


+


+intVlanC.ip.igmp["static-group"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.igmp["static-group"]["A.B.C.D"].source["A.B.C.D"].enter = true;


+


+intVlanC.ip.igmp["unidirectional-link"].enter = true;


+


+intVlanC.ip.igmp.v3lite.enter = true;


+


+intVlanC.ip.igmp.version["<1-3>"].enter = true;


+


+intVlanC.ip.irdp.enter = true;


+


+intVlanC.ip.irdp.holdtime["<0-9000>"].enter = true;


+


+


+intVlanC.ip.irdp.maxadvertinterval["<4-1800>"].enter = true;


+


+intVlanC.ip.irdp.minadvertinterval["<3-1800>"].enter = true;


+


+intVlanC.ip.irdp.multicast.enter = true;


+


+intVlanC.ip["load-sharing"]["per-destination"].enter = true;


+


+intVlanC.ip["load-sharing"]["per-packet"].enter = true;


+


+intVlanC.ip["local-proxy-arp"].enter = true;


+


+intVlanC.ip["mask-reply"].enter = true;


+


+intVlanC.ip.mrm["test-receiver"].enter = true;


+


+intVlanC.ip.mrm["test-sender"].enter = true;


+


+intVlanC.ip.mrm["test-sender-receiver"].enter = true;


+


+intVlanC.ip["mroute-cache"].enter = true;


+


+intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"]["<100-199>"].enter = true;


+


+intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"]["<2000-2699>"].enter = true;


+


+intVlanC.ip.multicast["helper-map"]["A.B.C.D"]["A.B.C.D"].WORD.enter = true;


+


+intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"]["<100-199>"].enter = true;


+


+intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"]["<2000-2699>"].enter = true;


+


+intVlanC.ip.multicast["helper-map"].broadcast["A.B.C.D"].WORD.enter = true;


+


+intVlanC.ip.nhrp.authentication.WORD.enter = true;


+


+intVlanC.ip.nhrp.holdtime["<1-65535>"].enter = true;


+


+intVlanC.ip.nhrp.interest["<1-199>"].enter = true;


+


+intVlanC.ip.nhrp.map["A.B.C.D"]["H.H.H"].enter = true;


+


+intVlanC.ip.nhrp.map.multicast["H.H.H"].enter = true;


+


+intVlanC.ip.nhrp["max-send"]["<1-65535>"].every["<10-65535>"].enter = true;


+


+intVlanC.ip.nhrp["network-id"]["<1-4294967295>"].enter = true;


+


+intVlanC.ip.nhrp.nhs["A.B.C.D"].enter = true;


+


+intVlanC.ip.nhrp.nhs["A.B.C.D"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.nhrp.record.enter = true;


+


+intVlanC.ip.nhrp.responder.Null["<0-0>"].enter = true;


+


+intVlanC.ip.nhrp.responder.Vlan["<1-1001>"].enter = true;


+


+intVlanC.ip.nhrp["server-only"].enter = true;


+


+intVlanC.ip.nhrp["server-only"]["non-caching"].enter = true;


+


+intVlanC.ip.nhrp["trigger-svc"]["<1-4294967295>"]["<0-4294967295>"].enter = true;


+


+intVlanC.ip.nhrp.use["<1-65535>"].enter = true;


+


+intVlanC.ip.ospf.authentication.enter = true;


+


+intVlanC.ip.ospf.authentication["message-digest"].enter = true;


+


+intVlanC.ip.ospf.authentication.null.enter = true;


+


+intVlanC.ip.ospf["authentication-key"].LINE.enter = true;


+


+intVlanC.ip.ospf.cost["<1-65535>"].enter = true;


+


+intVlanC.ip.ospf["database-filter"].all.out.enter = true;


+


+intVlanC.ip.ospf["dead-interval"]["<1-65535>"].enter = true;


+


+intVlanC.ip.ospf["demand-circuit"].enter = true;


+


+intVlanC.ip.ospf["hello-interval"]["<1-65535>"].enter = true;


+


+intVlanC.ip.ospf["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+intVlanC.ip.ospf["mtu-ignore"].enter = true;


+


+intVlanC.ip.ospf.network.broadcast.enter = true;


+


+intVlanC.ip.ospf.network["non-broadcast"].enter = true;


+


+intVlanC.ip.ospf.network["point-to-multipoint"].enter = true;


+


+intVlanC.ip.ospf.network["point-to-multipoint"]["non-broadcast"].enter = true;


+


+intVlanC.ip.ospf.network["point-to-point"].enter = true;


+


+intVlanC.ip.ospf.priority["<0-255>"].enter = true;


+


+intVlanC.ip.ospf["retransmit-interval"]["<1-65535>"].enter = true;


+


+intVlanC.ip.ospf["transmit-delay"]["<1-65535>"].enter = true;


+


+intVlanC.ip.pim.enter = true;


+


+intVlanC.ip.pim["bsr-border"].enter = true;


+


+intVlanC.ip.pim["dense-mode"].enter = true;


+


+intVlanC.ip.pim["dense-mode"]["proxy-register"].list["<100-199>"].enter = true;


+


+intVlanC.ip.pim["dense-mode"]["proxy-register"].list["<2000-2699>"].enter = true;


+


+intVlanC.ip.pim["dense-mode"]["proxy-register"].list.WORD.enter = true;


+


+intVlanC.ip.pim["dense-mode"]["proxy-register"]["route-map"].WORD.enter = true;


+


+intVlanC.ip.pim["nbma-mode"].enter = true;


+


+intVlanC.ip.pim["neighbor-filter"]["<1-99>"].enter = true;


+


+intVlanC.ip.pim["neighbor-filter"].WORD.enter = true;


+


+intVlanC.ip.pim["query-interval"]["<0-65535>"].enter = true;


+


+intVlanC.ip.pim["sparse-dense-mode"].enter = true;


+


+intVlanC.ip.pim["sparse-mode"].enter = true;


+


+intVlanC.ip.pim.version["<1-2>"].enter = true;


+


+intVlanC.ip.probe.proxy.enter = true;


+


+intVlanC.ip["proxy-arp"].enter = true;


+


+intVlanC.ip["rarp-server"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.redirects.enter = true;


+


+intVlanC.ip.rgmp.enter = true;


+


+intVlanC.ip.rip.authentication["key-chain"].LINE.enter = true;


+


+intVlanC.ip.rip.authentication.mode.md5.enter = true;


+


+intVlanC.ip.rip.authentication.mode.text.enter = true;


+


+intVlanC.ip.rip.receive.version.enter = true;


+


+intVlanC.ip.rip.send.version.enter = true;


+


+intVlanC.ip.rip["v2-broadcast"].enter = true;


+


+intVlanC.ip["route-cache"].enter = true;


+


+intVlanC.ip["route-cache"].cef.enter = true;


+


+intVlanC.ip["route-cache"].flow.enter = true;


+


+intVlanC.ip["route-cache"]["same-interface"].enter = true;


+


+intVlanC.ip.sap.listen.enter = true;


+


+intVlanC.ip.sdr.listen.enter = true;


+


+intVlanC.ip.security["add"].enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified.sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Unclassified["siop-esi"].sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential.sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Confidential["siop-esi"].sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret.sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.Secret["siop-esi"].sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret.sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].nsa.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].nsa.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.genser.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.nsa.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.nsa.doe.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.nsa.genser.enter = true;


+


+intVlanC.ip.security.dedicated.TopSecret["siop-esi"].sci.nsa.genser.doe.enter = true;


+


+intVlanC.ip.security["extended-allowed"].enter = true;


+


+intVlanC.ip.security["extended-ignored"].enter = true;


+


+intVlanC.ip.security.first.enter = true;


+


+


+intVlanC.ip.security.strip.enter = true;


+


+intVlanC.ip["split-horizon"].enter = true;


+


+intVlanC.ip["split-horizon"].eigrp["<1-65535>"].enter = true;


+


+intVlanC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intVlanC.ip["summary-address"].eigrp["<1-65535>"]["A.B.C.D"]["A.B.C.D"]["<1-255>"].enter = true;


+


+intVlanC.ip["summary-address"].rip["A.B.C.D"]["A.B.C.D"].enter = true;


+


+intVlanC.ip.tcp["compression-connections"]["<3-256>"].enter = true;


+


+intVlanC.ip.tcp["header-compression"].enter = true;


+


+intVlanC.ip.tcp["header-compression"].passive.enter = true;


+


+intVlanC.ip.unnumbered.Null["<0-0>"].enter = true;


+


+intVlanC.ip.unnumbered.Vlan["<1-1001>"].enter = true;


+


+intVlanC.ip.unreachables.enter = true;


+


+intVlanC["load-interval"]["<30-600>"].enter = true;


+


+intVlanC.loopback.enter = true;


+


+intVlanC["max-reserved-bandwidth"].enter = true;


+


+intVlanC["max-reserved-bandwidth"]["<1-100>"].enter = true;


+


+intVlanC.no.bandwidth.enter = true;


+


+intVlanC.no["carrier-delay"].enter = true;


+


+intVlanC.no["custom-queue-list"].enter = true;


+


+intVlanC.no.delay.enter = true;


+


+intVlanC.no.description.enter = true;


+


+intVlanC.no["fair-queue"].enter = true;


+


+intVlanC.no["load-interval"].enter = true;


+


+intVlanC.no.loopback.enter = true;


+


+intVlanC.no["max-reserved-bandwidth"].enter = true;


+


+intVlanC.ntp.broadcast.enter = true;


+


+intVlanC.ntp.disable.enter = true;


+


+intVlanC.ntp.multicast.enter = true;


+


+intVlanC["priority-group"]["<1-16>"].enter = true;


+


+intVlanC.qos.enter = true;


+


+intVlanC["random-detect"].enter = true;


+


+intVlanC.rmon.native.enter = true;


+


+intVlanC.rmon.promiscuous.enter = true;


+


+intVlanC["service-policy"].history.enter = true;


+


+intVlanC.shutdown.enter = true;


+


+intVlanC["spanning-tree"].portfast.enter = true;


+


+intVlanC.standby.authentication.WORD.enter = true;


+


+intVlanC.standby.ip.enter = true;


+


+intVlanC.standby.ip["A.B.C.D"].enter = true;


+


+intVlanC.standby.ip["A.B.C.D"].secondary.enter = true;


+


+intVlanC.standby["mac-address"]["H.H.H"].enter = true;


+


+intVlanC.standby["mac-refresh"]["<0-255>"].enter = true;


+


+intVlanC.standby.name.WORD.enter = true;


+


+intVlanC.standby.preempt.enter = true;


+


+intVlanC.standby.preempt.delay["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.minimum["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.minimum["<0-3600>"]["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.sync["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.sync["<0-3600>"]["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.sync["<0-3600>"].minimum["<0-3600>"].enter = true;


+


+intVlanC.standby.preempt.delay.sync["<0-3600>"].minimum["<0-3600>"]["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay.minimum["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay.minimum["<0-3600>"]["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"]["<0-3600>"].enter = true;


+


+intVlanC.standby.priority["<0-255>"].preempt.delay.sync["<0-3600>"].minimum["<0-3600>"].enter = true;


+


+intVlanC.standby.timers["<1-255>"]["<1-255>"].enter = true;


+


+intVlanC.standby.timers["<1-255>"]["<1-255>"].advertise["<1-255>"].enter = true;


+


+intVlanC.standby.timers["<1-255>"].msec["<20-1000>"].enter = true;


+


+intVlanC.standby.timers["<1-255>"].msec["<20-1000>"].advertise["<1-255>"].enter = true;


+


+intVlanC.standby.timers.msec["<20-1000>"]["<1-255>"].enter = true;


+


+intVlanC.standby.timers.msec["<20-1000>"]["<1-255>"].advertise["<1-255>"].enter = true;


+


+intVlanC.standby.timers.msec["<20-1000>"].msec["<20-1000>"].enter = true;


+


+intVlanC.standby.timers.msec["<20-1000>"].msec["<20-1000>"].advertise["<1-255>"].enter = true;


+


+intVlanC.standby.track.Vlan["<1-1001>"].enter = true;


+


+intVlanC.standby.track.Vlan["<1-1001>"]["<1-255>"].enter = true;


+


+intVlanC.standby["use-bia"].enter = true;


+


+intVlanC.standby["use-bia"].scope.interface.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_lineaux.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_lineaux.txt
new file mode 100644
index 0000000..a67e4ce
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_lineaux.txt
@@ -0,0 +1,52 @@
+// Functions


+


+// exit


+lineauxC.exit.enter = function ()


+{


+	


+}


+// end


+lineauxC.addSC("end");


+lineauxC.end.enter = globalC.exit.enter;


+


+


+// login


+lineauxC.login.enter = true;


+{


+	


+}


+


+// no login


+lineauxC.no.login.enter = true;


+{


+	


+}


+


+


+// password


+lineauxC.password.mustEnter = function(subCNum)


+{


+	


+}


+


+lineauxC.password.mustHelp = function(subCNum)


+{


+	


+}


+


+// no password


+commands_deleteSubCommand("lineauxC.no.password", null, true);


+lineauxC.no.password.enter = function ()


+{


+	


+}


+


+


+// interface


+commands_copyCommand("globalC", "lineauxC", "interface");


+lineauxC.interface.descript = null;


+


+// line


+commands_copyCommand("globalC", "lineauxC", "line");


+lineauxC.line.descript = null;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linecon.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linecon.txt
new file mode 100644
index 0000000..b64d7a9
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linecon.txt
@@ -0,0 +1,309 @@
+lineconC["access-class"]["<1-199>"]["in"].enter = true;


+


+lineconC["access-class"]["<1-199>"].out.enter = true;


+


+lineconC["access-class"]["<1300-2699>"]["in"].enter = true;


+


+lineconC["access-class"]["<1300-2699>"].out.enter = true;


+


+lineconC.autocommand.LINE.enter = true;


+


+lineconC.autocommand["no-suppress-linenumber"].LINE.enter = true;


+


+lineconC["autocommand-options"].enter = true;


+


+lineconC["autocommand-options"].delay["<0-120>"].enter = true;


+


+lineconC["autocommand-options"].nohangup.enter = true;


+


+lineconC["autocommand-options"].nohangup.delay["<0-120>"].enter = true;


+


+lineconC["data-character-bits"]["<7-8>"].enter = true;


+


+lineconC["default"]["access-class"]["in"].enter = true;


+


+lineconC["default"]["access-class"].out.enter = true;


+


+lineconC["default"].autocommand.enter = true;


+


+lineconC["default"]["autocommand-options"].enter = true;


+


+lineconC["default"]["autocommand-options"].delay["<0-120>"].enter = true;


+


+lineconC["default"]["autocommand-options"].nohangup.enter = true;


+


+lineconC["default"]["data-character-bits"].enter = true;


+


+lineconC["default"].databits.enter = true;


+


+lineconC["domain-lookup"].enter = true;


+


+lineconC.editing.enter = true;


+


+lineconC["escape-character"].BREAK.enter = true;


+


+lineconC["escape-character"]["default"].enter = true;


+


+lineconC["escape-character"].NONE.enter = true;


+


+lineconC["escape-character"].soft.BREAK.enter = true;


+


+lineconC["escape-character"].soft["default"].enter = true;


+


+lineconC["escape-character"].soft.NONE.enter = true;


+


+lineconC.exec.enter = true;


+


+lineconC["exec-banner"].enter = true;


+


+lineconC["exec-character-bits"]["<7-8>"].enter = true;


+


+lineconC["exec-timeout"]["<0-35791>"].enter = true;


+


+lineconC["exec-timeout"]["<0-35791>"]["<0-2147483>"].enter = true;


+


+lineconC.exit.enter = true;


+


+lineconC.flowcontrol.NONE.enter = true;


+


+lineconC.flowcontrol.NONE["in"].enter = true;


+


+lineconC.flowcontrol.NONE.lock.enter = true;


+


+lineconC.flowcontrol.NONE.out.enter = true;


+


+lineconC.flowcontrol.NONE.out.lock.enter = true;


+


+lineconC.flowcontrol.hardware.enter = true;


+


+lineconC.flowcontrol.hardware["in"].enter = true;


+


+lineconC.flowcontrol.hardware.out.enter = true;


+


+lineconC.flowcontrol.software.enter = true;


+


+lineconC.flowcontrol.software["in"].enter = true;


+


+lineconC.flowcontrol.software.lock.enter = true;


+


+lineconC.flowcontrol.software.out.enter = true;


+


+lineconC.flowcontrol.software.out.lock.enter = true;


+


+lineconC["full-help"].enter = true;


+


+lineconC.help.enter = true;


+


+lineconC.history.enter = true;


+


+lineconC.history.size["<0-256>"].enter = true;


+


+lineconC.international.enter = true;


+


+lineconC.ip["netmask-format"]["bit-count"].enter = true;


+


+lineconC.ip["netmask-format"].decimal.enter = true;


+


+lineconC.ip["netmask-format"].hexadecimal.enter = true;


+


+lineconC.ip.tcp["input-coalesce-threshold"]["<5-255>"].enter = true;


+


+


+lineconC.location.LINE.enter = true;


+


+lineconC.logging.synchronous.enter = true;


+


+lineconC.logging.synchronous.level["<0-7>"].enter = true;


+


+lineconC.logging.synchronous.level.all.enter = true;


+


+lineconC.logging.synchronous.limit["<0-2147483647>"].enter = true;


+


+lineconC.login.enter = true;


+


+lineconC.login.local.enter = true;


+


+lineconC.login.tacacs.enter = true;


+


+lineconC.modem["CTS-Alarm"].enter = true;


+


+lineconC.modem["DTR-active"].enter = true;


+


+lineconC.modem.Dialin.enter = true;


+


+lineconC.modem.Host.enter = true;


+


+lineconC.modem.InOut.enter = true;


+


+lineconC.modem.Printer.enter = true;


+


+lineconC.modem["answer-timeout"]["<0-65535>"].enter = true;


+


+lineconC.modem["dtr-delay"]["<0-65535>"].enter = true;


+


+lineconC.monitor.enter = true;


+


+lineconC["motd-banner"].enter = true;


+


+lineconC.no["access-class"]["in"].enter = true;


+


+lineconC.no["access-class"].out.enter = true;


+


+lineconC.no.autocommand.enter = true;


+


+lineconC.no["autocommand-options"].enter = true;


+


+lineconC.no["autocommand-options"].delay["<0-120>"].enter = true;


+


+lineconC.no["autocommand-options"].nohangup.enter = true;


+


+lineconC.no["data-character-bits"].enter = true;


+


+lineconC.no.databits.enter = true;


+


+lineconC.no["domain-lookup"].enter = true;


+


+lineconC.no.editing.enter = true;


+


+lineconC.no["escape-character"].enter = true;


+


+lineconC.no["escape-character"].soft.enter = true;


+


+lineconC.no.exec.enter = true;


+


+lineconC.no["exec-banner"].enter = true;


+


+lineconC.no["exec-character-bits"].enter = true;


+


+lineconC.no["exec-timeout"].enter = true;


+


+lineconC.no.flowcontrol.enter = true;


+


+lineconC.no.flowcontrol.NONE.enter = true;


+


+lineconC.no.flowcontrol.NONE["in"].enter = true;


+


+lineconC.no.flowcontrol.NONE.out.enter = true;


+


+lineconC.no.flowcontrol.hardware.enter = true;


+


+lineconC.no.flowcontrol.hardware["in"].enter = true;


+


+lineconC.no.flowcontrol.hardware.out.enter = true;


+


+lineconC.no.flowcontrol.lock.enter = true;


+


+lineconC.no.flowcontrol.software.enter = true;


+


+lineconC.no.flowcontrol.software["in"].enter = true;


+


+lineconC.no.flowcontrol.software.lock.enter = true;


+


+lineconC.no.flowcontrol.software.out.enter = true;


+


+lineconC.no["full-help"].enter = true;


+


+lineconC.no.history.enter = true;


+


+lineconC.no.history.size.enter = true;


+


+lineconC.no.international.enter = true;


+


+lineconC.no.ip["netmask-format"]["bit-count"].enter = true;


+


+lineconC.no.ip["netmask-format"].decimal.enter = true;


+


+lineconC.no.ip["netmask-format"].hexadecimal.enter = true;


+


+lineconC.no.ip.tcp["input-coalesce-threshold"].enter = true;


+


+lineconC.no.location.enter = true;


+


+lineconC.no.logging.synchronous.enter = true;


+


+lineconC.no.login.enter = true;


+


+lineconC.no.login.local.enter = true;


+


+lineconC.no.login.tacacs.enter = true;


+


+lineconC.no.modem["CTS-Alarm"].enter = true;


+


+lineconC.no.modem["DTR-active"].enter = true;


+


+lineconC.no.modem.Dialin.enter = true;


+


+lineconC.no.modem.Host.enter = true;


+


+lineconC.no.modem.InOut.enter = true;


+


+lineconC.no.modem.Printer.enter = true;


+


+lineconC.no.modem["dtr-delay"].enter = true;


+


+lineconC.no.monitor.enter = true;


+


+lineconC.no["motd-banner"].enter = true;


+


+lineconC.notify.enter = true;


+


+lineconC.parity.even.enter = true;


+


+lineconC.parity.mark.enter = true;


+


+lineconC.parity.none.enter = true;


+


+lineconC.parity.odd.enter = true;


+


+lineconC.parity.space.enter = true;


+


+lineconC.password["<7-7>"].WORD.enter = true;


+


+lineconC.password.LINE.enter = true;


+


+lineconC.privilege.level["<0-15>"].enter = true;


+


+lineconC["refuse-message"].LINE.enter = true;


+


+lineconC.rotary["<0-100>"].enter = true;


+


+lineconC.rxspeed["<0-4294967295>"].enter = true;


+


+lineconC["session-timeout"]["<0-35791>"].enter = true;


+


+lineconC["session-timeout"]["<0-35791>"].output.enter = true;


+


+lineconC["special-character-bits"]["<7-8>"].enter = true;


+


+lineconC.speed["<0-4294967295>"].enter = true;


+


+lineconC.stopbits["<1-1>"].enter = true;


+


+lineconC.stopbits["1.5"].enter = true;


+


+lineconC.stopbits["<2-2>"].enter = true;


+


+lineconC["terminal-type"].WORD.enter = true;


+


+lineconC.timeout.login.response["<0-300>"].enter = true;


+


+lineconC.transport.output.all.enter = true;


+


+lineconC.transport.output.none.enter = true;


+


+lineconC.transport.output.telnet.enter = true;


+


+lineconC.transport.preferred.all.enter = true;


+


+lineconC.transport.preferred.none.enter = true;


+


+lineconC.transport.preferred.telnet.enter = true;


+


+lineconC.txspeed["<0-4294967295>"].enter = true;


+


+lineconC["vacant-message"].enter = true;


+


+lineconC["vacant-message"].LINE.enter = true;


+


+lineconC.width["<0-512>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linevty.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linevty.txt
new file mode 100644
index 0000000..33a5c95
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_linevty.txt
@@ -0,0 +1,302 @@
+linevtyC["access-class"]["<1-199>"]["in"].enter = true;


+


+linevtyC["access-class"]["<1-199>"].out.enter = true;


+


+linevtyC["access-class"]["<1300-2699>"]["in"].enter = true;


+


+linevtyC["access-class"]["<1300-2699>"].out.enter = true;


+


+linevtyC.autocommand.LINE.enter = true;


+


+linevtyC.autocommand["no-suppress-linenumber"].LINE.enter = true;


+


+linevtyC["autocommand-options"].enter = true;


+


+linevtyC["autocommand-options"].delay["<0-120>"].enter = true;


+


+linevtyC["autocommand-options"].nohangup.enter = true;


+


+linevtyC["autocommand-options"].nohangup.delay["<0-120>"].enter = true;


+


+linevtyC["data-character-bits"]["<7-8>"].enter = true;


+


+linevtyC["default"]["access-class"]["in"].enter = true;


+


+linevtyC["default"]["access-class"].out.enter = true;


+


+linevtyC["default"].autocommand.enter = true;


+


+linevtyC["default"]["autocommand-options"].enter = true;


+


+linevtyC["default"]["autocommand-options"].delay["<0-120>"].enter = true;


+


+linevtyC["default"]["autocommand-options"].nohangup.enter = true;


+


+linevtyC["default"]["data-character-bits"].enter = true;


+


+linevtyC["default"].databits.enter = true;


+


+linevtyC["domain-lookup"].enter = true;


+


+linevtyC.editing.enter = true;


+


+linevtyC["escape-character"].BREAK.enter = true;


+


+linevtyC["escape-character"]["default"].enter = true;


+


+linevtyC["escape-character"].NONE.enter = true;


+


+linevtyC["escape-character"].soft.BREAK.enter = true;


+


+linevtyC["escape-character"].soft["default"].enter = true;


+


+linevtyC["escape-character"].soft.NONE.enter = true;


+


+linevtyC.exec.enter = true;


+


+linevtyC["exec-banner"].enter = true;


+


+linevtyC["exec-character-bits"]["<7-8>"].enter = true;


+


+linevtyC["exec-timeout"]["<0-35791>"].enter = true;


+


+linevtyC["exec-timeout"]["<0-35791>"]["<0-2147483>"].enter = true;


+


+linevtyC.exit.enter = true;


+


+linevtyC.flowcontrol.NONE.enter = true;


+


+linevtyC.flowcontrol.NONE["in"].enter = true;


+


+linevtyC.flowcontrol.NONE.lock.enter = true;


+


+linevtyC.flowcontrol.NONE.out.enter = true;


+


+linevtyC.flowcontrol.NONE.out.lock.enter = true;


+


+linevtyC.flowcontrol.software.enter = true;


+


+linevtyC.flowcontrol.software["in"].enter = true;


+


+linevtyC.flowcontrol.software.lock.enter = true;


+


+linevtyC.flowcontrol.software.out.enter = true;


+


+linevtyC.flowcontrol.software.out.lock.enter = true;


+


+linevtyC["full-help"].enter = true;


+


+linevtyC.help.enter = true;


+


+linevtyC.history.enter = true;


+


+linevtyC.history.size["<0-256>"].enter = true;


+


+linevtyC.international.enter = true;


+


+linevtyC.ip["netmask-format"]["bit-count"].enter = true;


+


+linevtyC.ip["netmask-format"].decimal.enter = true;


+


+linevtyC.ip["netmask-format"].hexadecimal.enter = true;


+


+linevtyC.ip.tcp["input-coalesce-threshold"]["<5-255>"].enter = true;


+


+linevtyC.location.LINE.enter = true;


+


+linevtyC.logging.synchronous.enter = true;


+


+linevtyC.logging.synchronous.level["<0-7>"].enter = true;


+


+linevtyC.logging.synchronous.level.all.enter = true;


+


+linevtyC.logging.synchronous.limit["<0-2147483647>"].enter = true;


+


+linevtyC.login.enter = true;


+


+linevtyC.login.local.enter = true;


+


+linevtyC.login.tacacs.enter = true;


+


+linevtyC.modem["CTS-Alarm"].enter = true;


+


+linevtyC.modem["DTR-active"].enter = true;


+


+linevtyC.modem.Dialin.enter = true;


+


+linevtyC.modem.Host.enter = true;


+


+linevtyC.modem.InOut.enter = true;


+


+linevtyC.modem.Printer.enter = true;


+


+linevtyC.modem["answer-timeout"]["<0-65535>"].enter = true;


+


+linevtyC.modem["dtr-delay"]["<0-65535>"].enter = true;


+


+linevtyC.monitor.enter = true;


+


+linevtyC["motd-banner"].enter = true;


+


+linevtyC.no["access-class"]["in"].enter = true;


+


+linevtyC.no["access-class"].out.enter = true;


+


+linevtyC.no.autocommand.enter = true;


+


+linevtyC.no["autocommand-options"].enter = true;


+


+linevtyC.no["autocommand-options"].delay["<0-120>"].enter = true;


+


+linevtyC.no["autocommand-options"].nohangup.enter = true;


+


+linevtyC.no["data-character-bits"].enter = true;


+


+linevtyC.no.databits.enter = true;


+


+linevtyC.no["domain-lookup"].enter = true;


+


+linevtyC.no.editing.enter = true;


+


+linevtyC.no["escape-character"].enter = true;


+


+linevtyC.no["escape-character"].soft.enter = true;


+


+linevtyC.no.exec.enter = true;


+


+linevtyC.no["exec-banner"].enter = true;


+


+linevtyC.no["exec-character-bits"].enter = true;


+


+linevtyC.no["exec-timeout"].enter = true;


+


+linevtyC.no.flowcontrol.enter = true;


+


+linevtyC.no.flowcontrol.NONE.enter = true;


+


+linevtyC.no.flowcontrol.NONE["in"].enter = true;


+


+linevtyC.no.flowcontrol.NONE.out.enter = true;


+


+linevtyC.no.flowcontrol.lock.enter = true;


+


+linevtyC.no.flowcontrol.software.enter = true;


+


+linevtyC.no.flowcontrol.software["in"].enter = true;


+


+linevtyC.no.flowcontrol.software.lock.enter = true;


+


+linevtyC.no.flowcontrol.software.out.enter = true;


+


+linevtyC.no["full-help"].enter = true;


+


+linevtyC.no.history.enter = true;


+


+linevtyC.no.history.size.enter = true;


+


+linevtyC.no.international.enter = true;


+


+linevtyC.no.ip["netmask-format"]["bit-count"].enter = true;


+


+linevtyC.no.ip["netmask-format"].decimal.enter = true;


+


+linevtyC.no.ip["netmask-format"].hexadecimal.enter = true;


+


+linevtyC.no.ip.tcp["input-coalesce-threshold"].enter = true;


+


+linevtyC.no.location.enter = true;


+


+linevtyC.no.logging.synchronous.enter = true;


+


+linevtyC.no.login.enter = true;


+


+linevtyC.no.login.local.enter = true;


+


+linevtyC.no.login.tacacs.enter = true;


+


+linevtyC.no.modem["CTS-Alarm"].enter = true;


+


+linevtyC.no.modem["DTR-active"].enter = true;


+


+linevtyC.no.modem.Dialin.enter = true;


+


+linevtyC.no.modem.Host.enter = true;


+


+linevtyC.no.modem.InOut.enter = true;


+


+linevtyC.no.modem.Printer.enter = true;


+


+linevtyC.no.modem["dtr-delay"].enter = true;


+


+linevtyC.no.monitor.enter = true;


+


+linevtyC.no["motd-banner"].enter = true;


+


+linevtyC.notify.enter = true;


+


+linevtyC.parity.even.enter = true;


+


+linevtyC.parity.mark.enter = true;


+


+linevtyC.parity.none.enter = true;


+


+linevtyC.parity.odd.enter = true;


+


+linevtyC.parity.space.enter = true;


+


+linevtyC.password["<7-7>"].WORD.enter = true;


+


+linevtyC.password.LINE.enter = true;


+


+linevtyC.privilege.level["<0-15>"].enter = true;


+


+linevtyC["refuse-message"].LINE.enter = true;


+


+linevtyC.rotary["<0-100>"].enter = true;


+


+linevtyC.rxspeed["<0-4294967295>"].enter = true;


+


+linevtyC["session-timeout"]["<0-35791>"].enter = true;


+


+linevtyC["session-timeout"]["<0-35791>"].output.enter = true;


+


+linevtyC["special-character-bits"]["<7-8>"].enter = true;


+


+linevtyC.speed["<0-4294967295>"].enter = true;


+


+linevtyC.stopbits["<1-1>"].enter = true;


+


+linevtyC.stopbits["1.5"].enter = true;


+


+linevtyC.stopbits["<2-2>"].enter = true;


+


+linevtyC["terminal-type"].WORD.enter = true;


+


+linevtyC.timeout.login.response["<0-300>"].enter = true;


+


+linevtyC.transport.input.all.enter = true;


+


+linevtyC.transport.input.none.enter = true;


+


+linevtyC.transport.input.telnet.enter = true;


+


+linevtyC.transport.output.all.enter = true;


+


+linevtyC.transport.output.none.enter = true;


+


+linevtyC.transport.output.telnet.enter = true;


+


+linevtyC.transport.preferred.all.enter = true;


+


+linevtyC.transport.preferred.none.enter = true;


+


+linevtyC.transport.preferred.telnet.enter = true;


+


+linevtyC.txspeed["<0-4294967295>"].enter = true;


+


+linevtyC["vacant-message"].enter = true;


+


+linevtyC["vacant-message"].LINE.enter = true;


+


+linevtyC.width["<0-512>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_mapClass.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_mapClass.txt
new file mode 100644
index 0000000..b6960ba
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_mapClass.txt
@@ -0,0 +1,224 @@
+mapClassC["exit-class"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["adaptive-shaping"].becn.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["adaptive-shaping"].foresight.enter = function()

+{

+}

+

+mapClassC["frame-relay"].bc.enter = function()

+{

+}

+

+mapClassC["frame-relay"].bc["<300-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].bc["in"]["<0-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].bc.out["<300-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].be.enter = function()

+{

+}

+

+mapClassC["frame-relay"].be["<0-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].be["in"]["<0-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].be.out["<0-16000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].cir["<1-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].cir["in"]["<0-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].cir.out["<1-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].congestion.threshold.de["<0-100>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].congestion.threshold.ecn["<0-100>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["custom-queue-list"]["<1-16>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].recv["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["error-threshold"].send["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].recv["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["event-window"].send["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.mode.bidirectional.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.mode["passive-reply"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.mode.reply.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.mode.request.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].recv["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive["success-events"].send["<1-32>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.timer.recv["<1-10000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["end-to-end"].keepalive.timer.send["<1-10000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fair-queue"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fair-queue"]["<1-4096>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fair-queue"]["<1-4096>"]["<16-4096>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fair-queue"]["<1-4096>"]["<16-4096>"]["<0-100>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fair-queue"]["<1-4096>"]["<16-4096>"]["<0-100>"]["<0-4096>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["fecn-adapt"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].fragment.enter = function()

+{

+}

+

+mapClassC["frame-relay"].fragment["<16-1600>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].holdq["<1-1024>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["idle-timer"]["<0-2000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["idle-timer"]["in"]["<0-2000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["idle-timer"].out["<0-2000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["interface-queue"].priority.high.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["interface-queue"].priority.medium.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["interface-queue"].priority.normal.enter = function()

+{

+}

+

+mapClassC["frame-relay"]["interface-queue"].priority.low.enter = function()

+{

+}

+

+mapClassC["frame-relay"].mincir["<1000-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].mincir["in"]["<1000-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].mincir.out["<1000-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["priority-group"]["<1-16>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].tc["<10-10000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["traffic-rate"]["<600-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"]["traffic-rate"]["<600-45000000>"]["<0-45000000>"].enter = function()

+{

+}

+

+mapClassC["frame-relay"].voice.bandwidth["<8000-45000000>"].enter = function()

+{

+}

+

+mapClassC.help.enter = function()

+{

+}

+

+mapClassC["service-policy"].input.WORD.enter = function()

+{

+}

+

+mapClassC["service-policy"].output.WORD.enter = function()

+{

+}

+

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMap.txt
new file mode 100644
index 0000000..f11e8fe
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMap.txt
@@ -0,0 +1,200 @@
+policyMapC.enter = function()

+{

+}

+

+policyMapC.class.WORD.enter = function()

+{

+}

+

+policyMapC.class.WORD["access-group"]["<1-2699>"].enter = function()

+{

+}

+

+policyMapC.class.WORD["access-group"].name.WORD.enter = function()

+{

+}

+

+policyMapC.class.WORD.any.enter = function()

+{

+}

+

+policyMapC.class.WORD["destination-address"].mac["H.H.H"].enter = function()

+{

+}

+

+policyMapC.class.WORD.dscp.enter = function()

+{

+}

+

+policyMapC.class.WORD.dscp["<0-63>"].enter = function()

+{

+}

+

+policyMapC.class.WORD["input-interface"].Dialer["<0-799>"].enter = function()

+{

+}

+

+policyMapC.class.WORD["input-interface"].Loopback["<0-2147483647>"].enter = function()

+{

+}

+

+policyMapC.class.WORD["input-interface"].Null["<0-0>"].enter = function()

+{

+}

+

+policyMapC.class.WORD.precedence.enter = function()

+{

+}

+

+policyMapC.class.WORD.precedence["<0-7>"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.aarp.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.apollo.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.appletalk.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.arp.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.bridge.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.bstun.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.cdp.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.clns.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol["clns_es"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol["clns_is"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.cmns.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.compressedtcp.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.decnet.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol["decnet_node"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol["decnet_router-l1"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol["decnet_router-l2"].enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.dlsw.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.ip.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.ipx.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.llc2.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.pad.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.pppoe.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.qllc.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.rsrb.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.snapshot.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.stun.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.vines.enter = function()

+{

+}

+

+policyMapC.class.WORD.protocol.xns.enter = function()

+{

+}

+

+policyMapC.class.WORD["qos-group"]["<0-99>"].enter = function()

+{

+}

+

+policyMapC.class.WORD["source-address"].mac["H.H.H"].enter = function()

+{

+}

+

+policyMapC.description.LINE.enter = function()

+{

+}

+

+policyMapC.exit.enter = function()

+{

+}

+

+policyMapC.no.enter = function()

+{

+}

+

+policyMapC.no.class.WORD.enter = function()

+{

+}

+

+policyMapC.no.description.enter = function()

+{

+}

+

+policyMapC.no.exit.enter = function()

+{

+}

+

+policyMapC.rename.WORD.enter = function()

+{

+}

+

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMapClass.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMapClass.txt
new file mode 100644
index 0000000..f4cd32f
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_policyMapClass.txt
@@ -0,0 +1,260 @@
+policyMapClassC.enter = function()

+{

+}

+

+policyMapClassC.bandwidth["<8-2000000>"].enter = function()

+{

+}

+

+policyMapClassC.bandwidth.percent["<1-100>"].enter = function()

+{

+}

+

+policyMapClassC.exit.enter = function()

+{

+}

+

+policyMapClassC.no.enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["<1000-51200000>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["<1000-51200000>"]["<1000-51200000>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].drop.enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].drop["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"]["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-clp-transmit"]["exceed-action"].drop.enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-dscp-transmit"]["<0-63>"]["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-mpls-exp-transmit"]["<0-7>"]["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-prec-transmit"]["<0-7>"]["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"]["set-qos-transmit"]["<0-99>"]["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit.enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"].drop.enter = function()

+{

+}

+

+policyMapClassC.police["<8000-200000000>"]["conform-action"].transmit["exceed-action"]["set-clp-transmit"].enter = function()

+{

+}

+

+policyMapClassC.priority["<8-2000000>"].enter = function()

+{

+}

+

+policyMapClassC.priority["<8-2000000>"]["<32-2000000>"].enter = function()

+{

+}

+

+policyMapClassC["queue-limit"]["<1-512>"].enter = function()

+{

+}

+

+policyMapClassC["random-detect"].enter = function()

+{

+}

+

+policyMapClassC.set["atm-clp"].enter = function()

+{

+}

+

+policyMapClassC.set.cos["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp["<0-63>"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af11.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af12.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af13.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af21.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af22.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af23.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af31.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af32.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af33.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af41.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af42.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.af43.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs1.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs2.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs3.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs4.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs5.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs6.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.cs7.enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp["default"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.dscp.ef.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.critical.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.flash.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence["flash-override"].enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.immediate.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.internet.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.network.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.priority.enter = function()

+{

+}

+

+policyMapClassC.set.ip.precedence.routine.enter = function()

+{

+}

+

+policyMapClassC.set.mpls.experimental["<0-7>"].enter = function()

+{

+}

+

+policyMapClassC.set["qos-group"]["<0-99>"].enter = function()

+{

+}

+

diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routeMap.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routeMap.txt
new file mode 100644
index 0000000..d710dbc
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routeMap.txt
@@ -0,0 +1,1226 @@
+routeMapC.description.enter = true;


+


+routeMapC.description.LINE.enter = true;


+


+routeMapC.exit.enter = true;


+


+routeMapC.help.enter = true;


+


+routeMapC.match["as-path"].enter = true;


+


+routeMapC.match["as-path"]["<1-199>"].enter = true;


+


+routeMapC.match.extcommunity.enter = true;


+


+routeMapC.match.extcommunity["<1-99>"].enter = true;


+


+routeMapC.match.interface.enter = true;


+


+routeMapC.match.interface.Null["<0-0>"].enter = true;


+


+routeMapC.match.interface.Vlan["<1-1001>"].enter = true;


+


+routeMapC.match.ip.address.enter = true;


+


+routeMapC.match.ip.address["<1-199>"].enter = true;


+


+routeMapC.match.ip.address["<1300-2699>"].enter = true;


+


+routeMapC.match.ip.address.WORD.enter = true;


+


+routeMapC.match.ip.address["prefix-list"].enter = true;


+


+routeMapC.match.ip["next-hop"].enter = true;


+


+routeMapC.match.ip["next-hop"]["<1-99>"].enter = true;


+


+routeMapC.match.ip["next-hop"]["<1300-1999>"].enter = true;


+


+routeMapC.match.ip["next-hop"].WORD.enter = true;


+


+routeMapC.match.ip["next-hop"]["prefix-list"].enter = true;


+


+routeMapC.match.ip["route-source"].enter = true;


+


+routeMapC.match.ip["route-source"]["<1-99>"].enter = true;


+


+routeMapC.match.ip["route-source"]["<1300-1999>"].enter = true;


+


+routeMapC.match.ip["route-source"].WORD.enter = true;


+


+routeMapC.match.ip["route-source"]["prefix-list"].enter = true;


+


+routeMapC.match.metric.enter = true;


+


+routeMapC.match.metric["<0-4294967295>"].enter = true;


+


+routeMapC.match["route-type"].enter = true;


+


+routeMapC.match["route-type"].external.enter = true;


+


+routeMapC.match["route-type"].external["type-1"].enter = true;


+


+routeMapC.match["route-type"].external["type-2"].enter = true;


+


+routeMapC.match["route-type"].internal.enter = true;


+


+routeMapC.match["route-type"].internal.external.enter = true;


+


+routeMapC.match["route-type"]["level-1"].enter = true;


+


+routeMapC.match["route-type"]["level-1"].external.enter = true;


+


+routeMapC.match["route-type"]["level-1"].internal.enter = true;


+


+routeMapC.match["route-type"]["level-2"].enter = true;


+


+routeMapC.match["route-type"]["level-2"].external.enter = true;


+


+routeMapC.match["route-type"]["level-2"].internal.enter = true;


+


+routeMapC.match["route-type"]["level-2"]["level-1"].enter = true;


+


+routeMapC.match["route-type"].local.enter = true;


+


+routeMapC.match["route-type"].local.external.enter = true;


+


+routeMapC.match["route-type"].local.internal.enter = true;


+


+routeMapC.match["route-type"].local["level-1"].enter = true;


+


+routeMapC.match["route-type"].local["level-2"].enter = true;


+


+routeMapC.match["route-type"]["nssa-external"].enter = true;


+


+routeMapC.match["route-type"]["nssa-external"].external.enter = true;


+


+routeMapC.match["route-type"]["nssa-external"].internal.enter = true;


+


+routeMapC.match["route-type"]["nssa-external"]["level-1"].enter = true;


+


+routeMapC.match["route-type"]["nssa-external"]["level-2"].enter = true;


+


+routeMapC.match["route-type"]["nssa-external"].local.enter = true;


+


+routeMapC.match["route-type"]["nssa-external"]["type-1"].enter = true;


+


+routeMapC.match["route-type"]["nssa-external"]["type-2"].enter = true;


+


+routeMapC.match.tag.enter = true;


+


+routeMapC.match.tag["<0-4294967295>"].enter = true;


+


+routeMapC.no.description.enter = true;


+


+routeMapC.no.match["as-path"].enter = true;


+


+routeMapC.no.match["as-path"]["<1-199>"].enter = true;


+


+routeMapC.no.match.extcommunity.enter = true;


+


+routeMapC.no.match.extcommunity["<1-99>"].enter = true;


+


+routeMapC.no.match.interface.enter = true;


+


+routeMapC.no.match.ip.address.enter = true;


+


+routeMapC.no.match.ip["next-hop"].enter = true;


+


+routeMapC.no.match.ip["route-source"].enter = true;


+


+routeMapC.no.match.metric.enter = true;


+


+routeMapC.no.match.metric["<0-4294967295>"].enter = true;


+


+routeMapC.no.match["route-type"].enter = true;


+


+routeMapC.no.match["route-type"].external.enter = true;


+


+routeMapC.no.match["route-type"].internal.enter = true;


+


+routeMapC.no.match["route-type"]["level-1"].enter = true;


+


+routeMapC.no.match["route-type"]["level-2"].enter = true;


+


+routeMapC.no.match["route-type"].local.enter = true;


+


+routeMapC.no.match["route-type"]["nssa-external"].enter = true;


+


+routeMapC.no.match.tag.enter = true;


+


+routeMapC.no.match.tag["<0-4294967295>"].enter = true;


+


+routeMapC.set["as-path"].prepend.enter = true;


+


+routeMapC.set["as-path"].prepend["<1-65535>"].enter = true;


+


+routeMapC.set["as-path"].tag.enter = true;


+


+routeMapC.set["automatic-tag"].enter = true;


+


+routeMapC.set["comm-list"]["<1-99>"]["delete"].enter = true;


+


+routeMapC.set["comm-list"]["<100-199>"]["delete"].enter = true;


+


+routeMapC.set["comm-list"].WORD["delete"].enter = true;


+


+routeMapC.set.community.enter = true;


+


+routeMapC.set.community["<1-4294967295>"].enter = true;


+


+routeMapC.set.community.additive.enter = true;


+


+routeMapC.set.community["local-AS"].enter = true;


+


+routeMapC.set.community["local-AS"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["local-AS"].additive.enter = true;


+


+routeMapC.set.community["no-advertise"].enter = true;


+


+routeMapC.set.community["no-advertise"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-advertise"].additive.enter = true;


+


+routeMapC.set.community["no-advertise"]["local-AS"].enter = true;


+


+routeMapC.set.community["no-advertise"]["local-AS"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-advertise"]["local-AS"].additive.enter = true;


+


+routeMapC.set.community["no-export"].enter = true;


+


+routeMapC.set.community["no-export"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-export"].additive.enter = true;


+


+routeMapC.set.community["no-export"]["local-AS"].enter = true;


+


+routeMapC.set.community["no-export"]["local-AS"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-export"]["local-AS"].additive.enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"].enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"].additive.enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"]["local-AS"].enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"]["local-AS"]["<1-4294967295>"].enter = true;


+


+routeMapC.set.community["no-export"]["no-advertise"]["local-AS"].additive.enter = true;


+


+routeMapC.set.community.none.enter = true;


+


+routeMapC.set.dampening["<1-45>"]["<1-20000>"]["<1-20000>"]["<1-255>"].enter = true;


+


+routeMapC.set.extcommunity.rt.enter = true;


+


+routeMapC.set.extcommunity.soo.enter = true;


+


+routeMapC.set.interface.enter = true;


+


+routeMapC.set.interface.Null["<0-0>"].enter = true;


+


+routeMapC.set.interface.Vlan["<1-1001>"].enter = true;


+


+routeMapC.set.interface.Vlan["<1-1001>"].Null["<0-0>"].enter = true;


+


+routeMapC.set.ip.df.enter = true;


+


+routeMapC.set.ip.df["<0-1>"].enter = true;


+


+routeMapC.set.ip["next-hop"].enter = true;


+


+routeMapC.set.ip["next-hop"]["A.B.C.D"].enter = true;


+


+routeMapC.set.ip["next-hop"]["peer-address"].enter = true;


+


+routeMapC.set.ip["next-hop"]["verify-availability"].enter = true;


+


+routeMapC.set.ip.precedence.enter = true;


+


+routeMapC.set.ip.precedence["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.critical.enter = true;


+


+routeMapC.set.ip.precedence.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.flash.enter = true;


+


+routeMapC.set.ip.precedence.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate.enter = true;


+


+routeMapC.set.ip.precedence.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.immediate["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.enter = true;


+


+routeMapC.set.ip.precedence.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.internet.immediate["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.enter = true;


+


+routeMapC.set.ip.precedence.network["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.flash.enter = true;


+


+routeMapC.set.ip.precedence.network.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.immediate["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.enter = true;


+


+routeMapC.set.ip.precedence.network.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.network.internet.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.enter = true;


+


+routeMapC.set.ip.precedence.priority["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.immediate["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.internet.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.enter = true;


+


+routeMapC.set.ip.precedence.priority.network["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.priority.network.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.enter = true;


+


+routeMapC.set.ip.precedence.routine["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.immediate["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.internet.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.enter = true;


+


+routeMapC.set.ip.precedence.routine.network["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.network.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority["flash-override"].flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.immediate["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.internet.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.flash.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network["flash-override"].flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.immediate["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.critical["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.flash["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.flash.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet["flash-override"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet["flash-override"]["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet["flash-override"].critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet["flash-override"].flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.immediate.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.immediate["<0-7>"].enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.immediate.critical.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.immediate.flash.enter = true;


+


+routeMapC.set.ip.precedence.routine.priority.network.internet.immediate["flash-override"].enter = true;


+


+routeMapC.set.ip["qos-group"].enter = true;


+


+routeMapC.set.ip["qos-group"]["<0-99>"].enter = true;


+


+routeMapC.set.level.enter = true;


+


+routeMapC.set.level.backbone.enter = true;


+


+routeMapC.set.level["level-1"].enter = true;


+


+routeMapC.set.level["level-1-2"].enter = true;


+


+routeMapC.set.level["level-2"].enter = true;


+


+routeMapC.set.level["stub-area"].enter = true;


+


+routeMapC.set["local-preference"].enter = true;


+


+routeMapC.set["local-preference"]["<0-4294967295>"].enter = true;


+


+routeMapC.set.metric.enter = true;


+


+routeMapC.set.metric["<0-4294967295>"].enter = true;


+


+routeMapC.set.metric["<0-4294967295>"]["<1-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routeMapC.set["metric-type"].enter = true;


+


+routeMapC.set["metric-type"].external.enter = true;


+


+routeMapC.set["metric-type"].internal.enter = true;


+


+routeMapC.set["metric-type"]["type-1"].enter = true;


+


+routeMapC.set["metric-type"]["type-2"].enter = true;


+


+routeMapC.set.origin.egp["<0-65535>"].enter = true;


+


+routeMapC.set.origin.igp.enter = true;


+


+routeMapC.set.origin.incomplete.enter = true;


+


+routeMapC.set.tag.enter = true;


+


+routeMapC.set.tag["<0-4294967295>"].enter = true;


+


+routeMapC.set["traffic-index"]["<1-8>"].enter = true;


+


+routeMapC.set.weight.enter = true;


+


+routeMapC.set.weight["<0-4294967295>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerAF.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerAF.txt
new file mode 100644
index 0000000..a15b09c
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerAF.txt
@@ -0,0 +1,320 @@
+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD.enter = true;


+


+routerAFC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD["as-set"].enter = true;


+


+routerAFC["auto-summary"].enter = true;


+


+routerAFC.bgp["always-compare-med"].enter = true;


+


+routerAFC.bgp.dampening.enter = true;


+


+routerAFC.bgp["deterministic-med"].enter = true;


+


+routerAFC.bgp["fast-external-fallover"].enter = true;


+


+routerAFC.bgp["log-neighbor-changes"].enter = true;


+


+routerAFC.bgp["redistribute-internal"].enter = true;


+


+routerAFC["default"]["auto-summary"].enter = true;


+


+routerAFC["default-information"].originate.enter = true;


+


+routerAFC["default-metric"]["<1-4294967295>"].enter = true;


+


+routerAFC["exit-address-family"].enter = true;


+


+routerAFC.help.enter = true;


+


+routerAFC["maximum-paths"]["<1-8>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"].activate.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["advertise-map"].WORD["non-exist-map"].WORD.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["advertisement-interval"]["<0-600>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["allowas-in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["allowas-in"]["<1-10>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["default-originate"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["default-originate"]["route-map"].WORD.enter = true;


+


+routerAFC.neighbor["A.B.C.D"].description.LINE.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"].WORD["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["distribute-list"].WORD.out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["ebgp-multihop"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["ebgp-multihop"]["<1-255>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"]["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["local-as"]["<1-65535>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"]["<1-100>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"]["warning-only"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["next-hop-propagate"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["next-hop-self"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"].password.LINE.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["peer-group"].WORD.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["prefix-list"].WORD["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["prefix-list"].WORD.out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["remote-as"]["<1-65535>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["remove-private-AS"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["route-map"].WORD["in"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["route-map"].WORD.out.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["route-reflector-client"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["send-community"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["send-community"].both.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["send-community"].extended.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["send-community"].standard.enter = true;


+


+routerAFC.neighbor["A.B.C.D"].shutdown.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["soft-reconfiguration"].inbound.enter = true;


+


+routerAFC.neighbor["A.B.C.D"].timers["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["unsuppress-map"].WORD.enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["update-source"].Null["<0-0>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"]["update-source"].Vlan["<1-1001>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"].version["<4-4>"].enter = true;


+


+routerAFC.neighbor["A.B.C.D"].weight["<0-65535>"].enter = true;


+


+routerAFC.neighbor.WORD.activate.enter = true;


+


+routerAFC.neighbor.WORD["advertise-map"].WORD["non-exist-map"].WORD.enter = true;


+


+routerAFC.neighbor.WORD["advertisement-interval"]["<0-600>"].enter = true;


+


+routerAFC.neighbor.WORD["allowas-in"].enter = true;


+


+routerAFC.neighbor.WORD["allowas-in"]["<1-10>"].enter = true;


+


+routerAFC.neighbor.WORD["default-originate"].enter = true;


+


+routerAFC.neighbor.WORD["default-originate"]["route-map"].WORD.enter = true;


+


+routerAFC.neighbor.WORD.description.LINE.enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"]["<1-199>"].out.enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"].WORD["in"].enter = true;


+


+routerAFC.neighbor.WORD["distribute-list"].WORD.out.enter = true;


+


+routerAFC.neighbor.WORD["ebgp-multihop"].enter = true;


+


+routerAFC.neighbor.WORD["ebgp-multihop"]["<1-255>"].enter = true;


+


+routerAFC.neighbor.WORD["filter-list"]["<1-199>"]["in"].enter = true;


+


+routerAFC.neighbor.WORD["filter-list"]["<1-199>"].out.enter = true;


+


+routerAFC.neighbor.WORD["local-as"]["<1-65535>"].enter = true;


+


+routerAFC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].enter = true;


+


+routerAFC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"]["<1-100>"].enter = true;


+


+routerAFC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"]["warning-only"].enter = true;


+


+routerAFC.neighbor.WORD["next-hop-propagate"].enter = true;


+


+routerAFC.neighbor.WORD["next-hop-self"].enter = true;


+


+routerAFC.neighbor.WORD.password.LINE.enter = true;


+


+routerAFC.neighbor.WORD["peer-group"].enter = true;


+


+routerAFC.neighbor.WORD["prefix-list"].WORD["in"].enter = true;


+


+routerAFC.neighbor.WORD["prefix-list"].WORD.out.enter = true;


+


+routerAFC.neighbor.WORD["remote-as"]["<1-65535>"].enter = true;


+


+routerAFC.neighbor.WORD["remove-private-AS"].enter = true;


+


+routerAFC.neighbor.WORD["route-map"].WORD["in"].enter = true;


+


+routerAFC.neighbor.WORD["route-map"].WORD.out.enter = true;


+


+routerAFC.neighbor.WORD["route-reflector-client"].enter = true;


+


+routerAFC.neighbor.WORD["send-community"].enter = true;


+


+routerAFC.neighbor.WORD["send-community"].both.enter = true;


+


+routerAFC.neighbor.WORD["send-community"].extended.enter = true;


+


+routerAFC.neighbor.WORD["send-community"].standard.enter = true;


+


+routerAFC.neighbor.WORD.shutdown.enter = true;


+


+routerAFC.neighbor.WORD["soft-reconfiguration"].inbound.enter = true;


+


+routerAFC.neighbor.WORD.timers["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerAFC.neighbor.WORD["unsuppress-map"].WORD.enter = true;


+


+routerAFC.neighbor.WORD["update-source"].Null["<0-0>"].enter = true;


+


+routerAFC.neighbor.WORD["update-source"].Vlan["<1-1001>"].enter = true;


+


+routerAFC.neighbor.WORD.version["<4-4>"].enter = true;


+


+routerAFC.neighbor.WORD.weight["<0-65535>"].enter = true;


+


+routerAFC.network["A.B.C.D"].enter = true;


+


+routerAFC.network["A.B.C.D"].backdoor.enter = true;


+


+routerAFC.network["A.B.C.D"].mask["A.B.C.D"].enter = true;


+


+routerAFC.network["A.B.C.D"].mask["A.B.C.D"].backdoor.enter = true;


+


+routerAFC.network["A.B.C.D"]["route-map"].WORD.enter = true;


+


+routerAFC.network["A.B.C.D"]["route-map"].WORD.backdoor.enter = true;


+


+routerAFC.no["auto-summary"].enter = true;


+


+routerAFC.no["default-metric"].enter = true;


+


+routerAFC.no.help.enter = true;


+


+routerAFC.no["maximum-paths"].enter = true;


+


+routerAFC.redistribute.connected.enter = true;


+


+routerAFC.redistribute.dvmrp.enter = true;


+


+routerAFC.redistribute.isis.enter = true;


+


+routerAFC.redistribute["iso-igrp"].enter = true;


+


+routerAFC.redistribute.mobile.enter = true;


+


+routerAFC.redistribute.odr.enter = true;


+


+routerAFC.redistribute.rip.enter = true;


+


+routerAFC.redistribute.static.enter = true;


+


+routerAFC.synchronization.enter = true;


+


+routerAFC["table-map"].WORD.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerBGP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerBGP.txt
new file mode 100644
index 0000000..c7f323e
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerBGP.txt
@@ -0,0 +1,734 @@
+routerBGPC["address-family"].ipv4.enter = true;


+


+routerBGPC["address-family"].ipv4.multicast.enter = true;


+


+routerBGPC["address-family"].ipv4.unicast.enter = true;


+


+routerBGPC["address-family"].ipv4.vrf.WORD.enter = true;


+


+routerBGPC["address-family"].vpnv4.enter = true;


+


+routerBGPC["address-family"].vpnv4.unicast.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["attribute-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["route-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["attribute-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["summary-only"]["route-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["attribute-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["route-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["as-set"]["advertise-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["attribute-map"].WORD["as-set"].enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD.enter = true;


+


+routerBGPC["aggregate-address"]["A.B.C.D"]["A.B.C.D"]["suppress-map"].WORD["summary-only"]["route-map"].WORD["as-set"].enter = true;


+


+routerBGPC["auto-summary"].enter = true;


+


+routerBGPC.bgp["always-compare-med"].enter = true;


+


+routerBGPC.bgp.bestpath["compare-routerid"].enter = true;


+


+routerBGPC.bgp.bestpath.med.confed.enter = true;


+


+routerBGPC.bgp.bestpath.med["missing-as-worst"].enter = true;


+


+routerBGPC.bgp["client-to-client"].reflection.enter = true;


+


+routerBGPC.bgp["cluster-id"]["<1-4294967295>"].enter = true;


+


+routerBGPC.bgp["cluster-id"]["A.B.C.D"].enter = true;


+


+routerBGPC.bgp.confederation.identifier["<1-65535>"].enter = true;


+


+routerBGPC.bgp.confederation.peers.enter = true;


+


+routerBGPC.bgp.confederation.peers["<1-65535>"].enter = true;


+


+routerBGPC.bgp.dampening.enter = true;


+


+routerBGPC.bgp.dampening["<1-45>"].enter = true;


+


+routerBGPC.bgp.dampening["<1-45>"]["<1-20000>"]["<1-20000>"]["<1-255>"].enter = true;


+


+routerBGPC.bgp.dampening["route-map"].WORD.enter = true;


+


+routerBGPC.bgp["default"]["ipv4-unicast"].enter = true;


+


+routerBGPC.bgp["default"]["local-preference"]["<0-4294967295>"].enter = true;


+


+routerBGPC.bgp["deterministic-med"].enter = true;


+


+routerBGPC.bgp["fast-external-fallover"].enter = true;


+


+routerBGPC.bgp["log-neighbor-changes"].enter = true;


+


+routerBGPC.bgp["redistribute-internal"].enter = true;


+


+routerBGPC.bgp["router-id"]["A.B.C.D"].enter = true;


+


+routerBGPC.bgp["scan-time"]["<5-60>"].enter = true;


+


+routerBGPC["default-information"].originate.enter = true;


+


+routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1-99>"].enter = true;


+


+routerBGPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1300-1999>"].enter = true;


+


+routerBGPC.distance.bgp["<1-255>"]["<1-255>"]["<1-255>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"]["in"].Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.bgp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.connected.enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.egp["<0-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.eigrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.igrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.rip.enter = true;


+


+routerBGPC["distribute-list"]["<1-199>"].out.static.enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"]["in"].Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.bgp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.connected.enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.egp["<0-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.eigrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.igrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.rip.enter = true;


+


+routerBGPC["distribute-list"]["<1300-2699>"].out.static.enter = true;


+


+routerBGPC["distribute-list"].WORD["in"].enter = true;


+


+routerBGPC["distribute-list"].WORD["in"].Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.enter = true;


+


+routerBGPC["distribute-list"].WORD.out.Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.bgp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.connected.enter = true;


+


+routerBGPC["distribute-list"].WORD.out.egp["<0-65535>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.igrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.ospf["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC["distribute-list"].WORD.out.rip.enter = true;


+


+routerBGPC["distribute-list"].WORD.out.static.enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD["in"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD["in"].Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.connected.enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.egp["<0-65535>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.rip.enter = true;


+


+routerBGPC["distribute-list"].gateway.WORD.out.static.enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD["in"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD["in"].Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.Null["<0-0>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.connected.enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.egp["<0-65535>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.rip.enter = true;


+


+routerBGPC["distribute-list"].prefix.WORD.out.static.enter = true;


+


+routerBGPC.exit.enter = true;


+


+routerBGPC.help.enter = true;


+


+routerBGPC["maximum-paths"]["<1-8>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].activate.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["advertise-map"].WORD["non-exist-map"].WORD.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["advertisement-interval"]["<0-600>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["allowas-in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["allowas-in"]["<1-10>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["default-originate"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["default-originate"]["route-map"].WORD.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].description.LINE.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1-199>"].out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"].WORD["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["distribute-list"].WORD.out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["ebgp-multihop"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["ebgp-multihop"]["<1-255>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"]["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["filter-list"]["<1-199>"].out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["local-as"]["<1-65535>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"]["<1-100>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["maximum-prefix"]["<1-4294967295>"]["warning-only"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["next-hop-propagate"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["next-hop-self"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].password.LINE.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["peer-group"].WORD.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["prefix-list"].WORD["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["prefix-list"].WORD.out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["remote-as"]["<1-65535>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["remove-private-AS"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["route-map"].WORD["in"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["route-map"].WORD.out.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["route-reflector-client"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["send-community"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["send-community"].both.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["send-community"].extended.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["send-community"].standard.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].shutdown.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["soft-reconfiguration"].inbound.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].timers["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["unsuppress-map"].WORD.enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["update-source"].Null["<0-0>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"]["update-source"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].version["<4-4>"].enter = true;


+


+routerBGPC.neighbor["A.B.C.D"].weight["<0-65535>"].enter = true;


+


+routerBGPC.neighbor.WORD.activate.enter = true;


+


+routerBGPC.neighbor.WORD["advertise-map"].WORD["non-exist-map"].WORD.enter = true;


+


+routerBGPC.neighbor.WORD["advertisement-interval"]["<0-600>"].enter = true;


+


+routerBGPC.neighbor.WORD["allowas-in"].enter = true;


+


+routerBGPC.neighbor.WORD["allowas-in"]["<1-10>"].enter = true;


+


+routerBGPC.neighbor.WORD["default-originate"].enter = true;


+


+routerBGPC.neighbor.WORD["default-originate"]["route-map"].WORD.enter = true;


+


+routerBGPC.neighbor.WORD.description.LINE.enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"]["<1-199>"].out.enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"].WORD["in"].enter = true;


+


+routerBGPC.neighbor.WORD["distribute-list"].WORD.out.enter = true;


+


+routerBGPC.neighbor.WORD["ebgp-multihop"].enter = true;


+


+routerBGPC.neighbor.WORD["ebgp-multihop"]["<1-255>"].enter = true;


+


+routerBGPC.neighbor.WORD["filter-list"]["<1-199>"]["in"].enter = true;


+


+routerBGPC.neighbor.WORD["filter-list"]["<1-199>"].out.enter = true;


+


+routerBGPC.neighbor.WORD["local-as"]["<1-65535>"].enter = true;


+


+routerBGPC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"].enter = true;


+


+routerBGPC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"]["<1-100>"].enter = true;


+


+routerBGPC.neighbor.WORD["maximum-prefix"]["<1-4294967295>"]["warning-only"].enter = true;


+


+routerBGPC.neighbor.WORD["next-hop-propagate"].enter = true;


+


+routerBGPC.neighbor.WORD["next-hop-self"].enter = true;


+


+routerBGPC.neighbor.WORD.password.LINE.enter = true;


+


+routerBGPC.neighbor.WORD["peer-group"].enter = true;


+


+routerBGPC.neighbor.WORD["prefix-list"].WORD["in"].enter = true;


+


+routerBGPC.neighbor.WORD["prefix-list"].WORD.out.enter = true;


+


+routerBGPC.neighbor.WORD["remote-as"]["<1-65535>"].enter = true;


+


+routerBGPC.neighbor.WORD["remove-private-AS"].enter = true;


+


+routerBGPC.neighbor.WORD["route-map"].WORD["in"].enter = true;


+


+routerBGPC.neighbor.WORD["route-map"].WORD.out.enter = true;


+


+routerBGPC.neighbor.WORD["route-reflector-client"].enter = true;


+


+routerBGPC.neighbor.WORD["send-community"].enter = true;


+


+routerBGPC.neighbor.WORD["send-community"].both.enter = true;


+


+routerBGPC.neighbor.WORD["send-community"].extended.enter = true;


+


+routerBGPC.neighbor.WORD["send-community"].standard.enter = true;


+


+routerBGPC.neighbor.WORD.shutdown.enter = true;


+


+routerBGPC.neighbor.WORD["soft-reconfiguration"].inbound.enter = true;


+


+routerBGPC.neighbor.WORD.timers["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerBGPC.neighbor.WORD["unsuppress-map"].WORD.enter = true;


+


+routerBGPC.neighbor.WORD["update-source"].Null["<0-0>"].enter = true;


+


+routerBGPC.neighbor.WORD["update-source"].Vlan["<1-1001>"].enter = true;


+


+routerBGPC.neighbor.WORD.version["<4-4>"].enter = true;


+


+routerBGPC.neighbor.WORD.weight["<0-65535>"].enter = true;


+


+routerBGPC.network["A.B.C.D"].enter = true;


+


+routerBGPC.network["A.B.C.D"].backdoor.enter = true;


+


+routerBGPC.network["A.B.C.D"].mask["A.B.C.D"].enter = true;


+


+routerBGPC.network["A.B.C.D"].mask["A.B.C.D"].backdoor.enter = true;


+


+routerBGPC.network["A.B.C.D"]["route-map"].WORD.enter = true;


+


+routerBGPC.network["A.B.C.D"]["route-map"].WORD.backdoor.enter = true;


+


+routerBGPC.redistribute.bgp["<1-65535>"].enter = true;


+


+routerBGPC.redistribute.bgp["<1-65535>"].metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.bgp["<1-65535>"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.bgp["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.connected.enter = true;


+


+routerBGPC.redistribute.connected.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.connected["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.connected["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.dvmrp.enter = true;


+


+routerBGPC.redistribute.dvmrp["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.dvmrp["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.egp["<0-65535>"].enter = true;


+


+routerBGPC.redistribute.egp["<0-65535>"].metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.egp["<0-65535>"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.egp["<0-65535>"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.eigrp["<1-65535>"].enter = true;


+


+routerBGPC.redistribute.eigrp["<1-65535>"].metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.eigrp["<1-65535>"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.eigrp["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.igrp["<1-65535>"].enter = true;


+


+routerBGPC.redistribute.igrp["<1-65535>"].metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.igrp["<1-65535>"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.igrp["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.isis.enter = true;


+


+routerBGPC.redistribute.isis["level-1"].enter = true;


+


+routerBGPC.redistribute.isis["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis["level-2"].enter = true;


+


+routerBGPC.redistribute.isis.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.isis.metric["<0-4294967295>"]["level-1"].enter = true;


+


+routerBGPC.redistribute.isis.metric["<0-4294967295>"]["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis.metric["<0-4294967295>"]["level-2"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD["level-1"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD["level-2"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD.metric["<0-4294967295>"]["level-1"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD.metric["<0-4294967295>"]["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis["route-map"].WORD.metric["<0-4294967295>"]["level-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD.enter = true;


+


+routerBGPC.redistribute.isis.WORD["level-1"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["level-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.isis.WORD.metric["<0-4294967295>"]["level-1"].enter = true;


+


+routerBGPC.redistribute.isis.WORD.metric["<0-4294967295>"]["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD.metric["<0-4294967295>"]["level-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD["level-1"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD["level-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD.metric["<0-4294967295>"]["level-1"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD.metric["<0-4294967295>"]["level-1-2"].enter = true;


+


+routerBGPC.redistribute.isis.WORD["route-map"].WORD.metric["<0-4294967295>"]["level-2"].enter = true;


+


+routerBGPC.redistribute["iso-igrp"].enter = true;


+


+routerBGPC.redistribute["iso-igrp"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute["iso-igrp"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute["iso-igrp"].WORD.enter = true;


+


+routerBGPC.redistribute["iso-igrp"].WORD["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute["iso-igrp"].WORD["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.mobile.enter = true;


+


+routerBGPC.redistribute.mobile.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.mobile["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.mobile["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.odr.enter = true;


+


+routerBGPC.redistribute.odr.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.odr["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.odr["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match.internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match.internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match["nssa-external"].external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match["nssa-external"].internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].metric["<0-4294967295>"].match["nssa-external"].internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match.internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match["nssa-external"].external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match["nssa-external"].internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.match["nssa-external"].internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"]["route-map"].WORD.metric["<0-4294967295>"].match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-4294967295>"].match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-4294967295>"].match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-4294967295>"].match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD["route-map"].WORD.match.external.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD["route-map"].WORD.match.internal.enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD["route-map"].WORD.match["nssa-external"].enter = true;


+


+routerBGPC.redistribute.ospf["<1-65535>"].vrf.WORD["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.rip.enter = true;


+


+routerBGPC.redistribute.rip.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.rip["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.rip["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.static.enter = true;


+


+routerBGPC.redistribute.static.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.redistribute.static["route-map"].WORD.enter = true;


+


+routerBGPC.redistribute.static["route-map"].WORD.metric["<0-4294967295>"].enter = true;


+


+routerBGPC.timers.bgp["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerEIGRP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerEIGRP.txt
new file mode 100644
index 0000000..f2466cd
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerEIGRP.txt
@@ -0,0 +1,330 @@
+routerEIGRPC["auto-summary"].enter = true;


+


+routerEIGRPC["default-information"]["in"].enter = true;


+


+routerEIGRPC["default-information"]["in"]["<1-99>"].enter = true;


+


+routerEIGRPC["default-information"]["in"]["<1300-1999>"].enter = true;


+


+routerEIGRPC["default-information"]["in"].WORD.enter = true;


+


+routerEIGRPC["default-information"].out.enter = true;


+


+routerEIGRPC["default-information"].out["<1-99>"].enter = true;


+


+routerEIGRPC["default-information"].out["<1300-1999>"].enter = true;


+


+routerEIGRPC["default-information"].out.WORD.enter = true;


+


+routerEIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1-99>"].enter = true;


+


+routerEIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1300-1999>"].enter = true;


+


+routerEIGRPC.distance.eigrp["<1-255>"]["<1-255>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"]["in"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.connected.enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.egp["<0-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.rip.enter = true;


+


+routerEIGRPC["distribute-list"]["<1-199>"].out.static.enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.connected.enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.egp["<0-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.rip.enter = true;


+


+routerEIGRPC["distribute-list"]["<1300-2699>"].out.static.enter = true;


+


+routerEIGRPC["distribute-list"].WORD["in"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD["in"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.connected.enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.egp["<0-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.rip.enter = true;


+


+routerEIGRPC["distribute-list"].WORD.out.static.enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD["in"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD["in"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.connected.enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.egp["<0-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.rip.enter = true;


+


+routerEIGRPC["distribute-list"].gateway.WORD.out.static.enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD["in"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD["in"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.Null["<0-0>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.connected.enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.egp["<0-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.rip.enter = true;


+


+routerEIGRPC["distribute-list"].prefix.WORD.out.static.enter = true;


+


+routerEIGRPC.eigrp["log-neighbor-changes"].enter = true;


+


+routerEIGRPC.eigrp["log-neighbor-warnings"].enter = true;


+


+routerEIGRPC.eigrp["log-neighbor-warnings"]["<1-65535>"].enter = true;


+


+routerEIGRPC.eigrp["router-id"]["A.B.C.D"].enter = true;


+


+routerEIGRPC.eigrp.stub.enter = true;


+


+routerEIGRPC.eigrp.stub.connected.enter = true;


+


+routerEIGRPC.eigrp.stub["receive-only"].enter = true;


+


+routerEIGRPC.eigrp.stub.static.enter = true;


+


+routerEIGRPC.eigrp.stub.static.connected.enter = true;


+


+routerEIGRPC.eigrp.stub.summary.enter = true;


+


+routerEIGRPC.eigrp.stub.summary.connected.enter = true;


+


+routerEIGRPC.eigrp.stub.summary.static.enter = true;


+


+routerEIGRPC.eigrp.stub.summary.static.connected.enter = true;


+


+routerEIGRPC.exit.enter = true;


+


+routerEIGRPC.help.enter = true;


+


+routerEIGRPC["maximum-paths"]["<1-8>"].enter = true;


+


+routerEIGRPC.metric.holddown.enter = true;


+


+routerEIGRPC.metric["maximum-hops"]["<1-255>"].enter = true;


+


+routerEIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].enter = true;


+


+routerEIGRPC.neighbor["A.B.C.D"].Null["<0-0>"].enter = true;


+


+routerEIGRPC.neighbor["A.B.C.D"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC.network["A.B.C.D"].enter = true;


+


+routerEIGRPC.network["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerEIGRPC["passive-interface"].enter = true;


+


+routerEIGRPC["passive-interface"].Null["<0-0>"].enter = true;


+


+routerEIGRPC["passive-interface"].Vlan["<1-1001>"].enter = true;


+


+routerEIGRPC["passive-interface"]["default"].enter = true;


+


+routerEIGRPC.redistribute.enter = true;


+


+routerEIGRPC.redistribute.bgp["<1-65535>"].enter = true;


+


+routerEIGRPC.redistribute.connected.enter = true;


+


+routerEIGRPC.redistribute.egp["<0-65535>"].enter = true;


+


+routerEIGRPC.redistribute.eigrp["<1-65535>"].enter = true;


+


+routerEIGRPC.redistribute.igrp["<1-65535>"].enter = true;


+


+routerEIGRPC.redistribute.isis.enter = true;


+


+routerEIGRPC.redistribute.isis["level-1"].enter = true;


+


+routerEIGRPC.redistribute.isis["level-1-2"].enter = true;


+


+routerEIGRPC.redistribute.isis["level-2"].enter = true;


+


+routerEIGRPC.redistribute.isis.WORD.enter = true;


+


+routerEIGRPC.redistribute.isis.WORD["level-1"].enter = true;


+


+routerEIGRPC.redistribute.isis.WORD["level-1-2"].enter = true;


+


+routerEIGRPC.redistribute.isis.WORD["level-2"].enter = true;


+


+routerEIGRPC.redistribute["iso-igrp"].enter = true;


+


+routerEIGRPC.redistribute["iso-igrp"].WORD.enter = true;


+


+routerEIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.mobile.enter = true;


+


+routerEIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.odr.enter = true;


+


+routerEIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match.external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match.internal.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.enter = true;


+


+routerEIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.enter = true;


+


+routerEIGRPC.redistribute.rip.enter = true;


+


+routerEIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute["route-map"].WORD.enter = true;


+


+routerEIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.static.enter = true;


+


+routerEIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.redistribute.static["route-map"].WORD.enter = true;


+


+routerEIGRPC.timers["active-time"].enter = true;


+


+routerEIGRPC.timers["active-time"]["<1-4294967295>"].enter = true;


+


+routerEIGRPC.timers["active-time"].disabled.enter = true;


+


+routerEIGRPC["traffic-share"].balanced.enter = true;


+


+routerEIGRPC["traffic-share"].min["across-interfaces"].enter = true;


+


+routerEIGRPC.variance["<1-128>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerIGRP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerIGRP.txt
new file mode 100644
index 0000000..07cd91f
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerIGRP.txt
@@ -0,0 +1,300 @@
+routerIGRPC["default-information"]["in"].enter = true;


+


+routerIGRPC["default-information"]["in"]["<1-99>"].enter = true;


+


+routerIGRPC["default-information"]["in"]["<1300-1999>"].enter = true;


+


+routerIGRPC["default-information"]["in"].WORD.enter = true;


+


+routerIGRPC["default-information"].out.enter = true;


+


+routerIGRPC["default-information"].out["<1-99>"].enter = true;


+


+routerIGRPC["default-information"].out["<1300-1999>"].enter = true;


+


+routerIGRPC["default-information"].out.WORD.enter = true;


+


+routerIGRPC.distance["<1-255>"].enter = true;


+


+routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1-99>"].enter = true;


+


+routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1300-1999>"].enter = true;


+


+routerIGRPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].WORD.enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"]["in"].Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.bgp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.connected.enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.egp["<0-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.igrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.rip.enter = true;


+


+routerIGRPC["distribute-list"]["<1-199>"].out.static.enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"]["in"].Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.bgp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.connected.enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.egp["<0-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.igrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.rip.enter = true;


+


+routerIGRPC["distribute-list"]["<1300-2699>"].out.static.enter = true;


+


+routerIGRPC["distribute-list"].WORD["in"].enter = true;


+


+routerIGRPC["distribute-list"].WORD["in"].Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.bgp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.connected.enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.egp["<0-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.igrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.rip.enter = true;


+


+routerIGRPC["distribute-list"].WORD.out.static.enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD["in"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD["in"].Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.connected.enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.egp["<0-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.rip.enter = true;


+


+routerIGRPC["distribute-list"].gateway.WORD.out.static.enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD["in"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD["in"].Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.Null["<0-0>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.connected.enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.egp["<0-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.rip.enter = true;


+


+routerIGRPC["distribute-list"].prefix.WORD.out.static.enter = true;


+


+routerIGRPC.exit.enter = true;


+


+routerIGRPC.help.enter = true;


+


+routerIGRPC["maximum-paths"]["<1-8>"].enter = true;


+


+routerIGRPC.metric.holddown.enter = true;


+


+routerIGRPC.metric["maximum-hops"]["<1-255>"].enter = true;


+


+routerIGRPC.metric.weights["<0-8>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"]["<0-4294967295>"].enter = true;


+


+routerIGRPC.neighbor["A.B.C.D"].enter = true;


+


+routerIGRPC.network["A.B.C.D"].enter = true;


+


+routerIGRPC["passive-interface"].enter = true;


+


+routerIGRPC["passive-interface"].Null["<0-0>"].enter = true;


+


+routerIGRPC["passive-interface"].Vlan["<1-1001>"].enter = true;


+


+routerIGRPC["passive-interface"]["default"].enter = true;


+


+routerIGRPC.redistribute.enter = true;


+


+routerIGRPC.redistribute.bgp["<1-65535>"].enter = true;


+


+routerIGRPC.redistribute.connected.enter = true;


+


+routerIGRPC.redistribute.egp["<0-65535>"].enter = true;


+


+routerIGRPC.redistribute.eigrp["<1-65535>"].enter = true;


+


+routerIGRPC.redistribute.igrp["<1-65535>"].enter = true;


+


+routerIGRPC.redistribute.isis.enter = true;


+


+routerIGRPC.redistribute.isis["level-1"].enter = true;


+


+routerIGRPC.redistribute.isis["level-1-2"].enter = true;


+


+routerIGRPC.redistribute.isis["level-2"].enter = true;


+


+routerIGRPC.redistribute.isis.WORD.enter = true;


+


+routerIGRPC.redistribute.isis.WORD["level-1"].enter = true;


+


+routerIGRPC.redistribute.isis.WORD["level-1-2"].enter = true;


+


+routerIGRPC.redistribute.isis.WORD["level-2"].enter = true;


+


+routerIGRPC.redistribute["iso-igrp"].enter = true;


+


+routerIGRPC.redistribute["iso-igrp"].WORD.enter = true;


+


+routerIGRPC.redistribute.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.mobile.enter = true;


+


+routerIGRPC.redistribute.mobile.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.odr.enter = true;


+


+routerIGRPC.redistribute.odr.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match.external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match.internal.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match.internal.external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.enter = true;


+


+routerIGRPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.enter = true;


+


+routerIGRPC.redistribute.rip.enter = true;


+


+routerIGRPC.redistribute.rip.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute["route-map"].WORD.enter = true;


+


+routerIGRPC.redistribute["route-map"].WORD.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.static.enter = true;


+


+routerIGRPC.redistribute.static.metric["<1-4294967295>"]["<0-4294967295>"]["<0-255>"]["<1-255>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.redistribute.static["route-map"].WORD.enter = true;


+


+routerIGRPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerIGRPC["traffic-share"].balanced.enter = true;


+


+routerIGRPC["traffic-share"].min["across-interfaces"].enter = true;


+


+routerIGRPC.variance["<1-128>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerOSPF.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerOSPF.txt
new file mode 100644
index 0000000..f5cb4be
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerOSPF.txt
@@ -0,0 +1,580 @@
+routerOSPFC.area["<0-4294967295>"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["default-cost"]["<0-16777215>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["filter-list"].prefix.WORD["in"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["filter-list"].prefix.WORD.out.enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa.enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["default-information-originate"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["default-information-originate"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["default-information-originate"]["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["no-redistribution"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["no-redistribution"]["default-information-originate"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["no-redistribution"]["default-information-originate"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["no-redistribution"]["default-information-originate"]["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].nssa["no-summary"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].advertise.enter = true;


+


+routerOSPFC.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"].cost["<0-16777215>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"]["not-advertise"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].range["A.B.C.D"]["A.B.C.D"]["not-advertise"].cost["<0-16777215>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"].stub.enter = true;


+


+routerOSPFC.area["<0-4294967295>"].stub["no-summary"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"].authentication.null.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["<0-4294967295>"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["default-cost"]["<0-16777215>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["filter-list"].prefix.WORD["in"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["filter-list"].prefix.WORD.out.enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa.enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["default-information-originate"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["default-information-originate"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["default-information-originate"]["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["no-redistribution"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["no-redistribution"]["default-information-originate"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["no-redistribution"]["default-information-originate"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["no-redistribution"]["default-information-originate"]["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].nssa["no-summary"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].advertise.enter = true;


+


+routerOSPFC.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"].cost["<0-16777215>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"]["not-advertise"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].range["A.B.C.D"]["A.B.C.D"]["not-advertise"].cost["<0-16777215>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"].stub.enter = true;


+


+routerOSPFC.area["A.B.C.D"].stub["no-summary"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"].authentication.null.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["dead-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["hello-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["retransmit-interval"]["<1-8192>"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication["message-digest"].enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"].authentication.null.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"]["authentication-key"].LINE.enter = true;


+


+routerOSPFC.area["A.B.C.D"]["virtual-link"]["A.B.C.D"]["transmit-delay"]["<1-8192>"]["message-digest-key"]["<1-255>"].md5.LINE.enter = true;


+


+routerOSPFC["default-information"].originate.enter = true;


+


+routerOSPFC["default-information"].originate.always.enter = true;


+


+routerOSPFC["default-information"].originate.metric["<0-16777214>"].enter = true;


+


+routerOSPFC["default-information"].originate.metric["<0-16777214>"].always.enter = true;


+


+routerOSPFC["default-information"].originate["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC["default-information"].originate["metric-type"]["<1-2>"].always.enter = true;


+


+routerOSPFC["default-information"].originate["metric-type"]["<1-2>"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC["default-information"].originate["metric-type"]["<1-2>"].metric["<0-16777214>"].always.enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD.enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD.always.enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD.metric["<0-16777214>"].always.enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD["metric-type"]["<1-2>"].enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD["metric-type"]["<1-2>"].always.enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD["metric-type"]["<1-2>"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC["default-information"].originate["route-map"].WORD["metric-type"]["<1-2>"].metric["<0-16777214>"].always.enter = true;


+


+routerOSPFC.distance["<1-255>"].enter = true;


+


+routerOSPFC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1-99>"].enter = true;


+


+routerOSPFC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1300-1999>"].enter = true;


+


+routerOSPFC.distance.ospf.external["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["inter-area"]["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["inter-area"]["<1-255>"].external["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["intra-area"]["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["intra-area"]["<1-255>"].external["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["intra-area"]["<1-255>"]["inter-area"]["<1-255>"].enter = true;


+


+routerOSPFC.distance.ospf["intra-area"]["<1-255>"]["inter-area"]["<1-255>"].external["<1-255>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"]["in"].Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.bgp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.connected.enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.egp["<0-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.igrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.rip.enter = true;


+


+routerOSPFC["distribute-list"]["<1-199>"].out.static.enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"]["in"].Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.bgp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.connected.enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.egp["<0-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.igrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.rip.enter = true;


+


+routerOSPFC["distribute-list"]["<1300-2699>"].out.static.enter = true;


+


+routerOSPFC["distribute-list"].WORD["in"].enter = true;


+


+routerOSPFC["distribute-list"].WORD["in"].Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.bgp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.connected.enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.egp["<0-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.igrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.ospf["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.rip.enter = true;


+


+routerOSPFC["distribute-list"].WORD.out.static.enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD["in"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD["in"].Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.connected.enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.egp["<0-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.rip.enter = true;


+


+routerOSPFC["distribute-list"].gateway.WORD.out.static.enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD["in"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD["in"].Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.Null["<0-0>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.connected.enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.egp["<0-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.rip.enter = true;


+


+routerOSPFC["distribute-list"].prefix.WORD.out.static.enter = true;


+


+routerOSPFC.exit.enter = true;


+


+routerOSPFC.help.enter = true;


+


+routerOSPFC["maximum-paths"]["<1-8>"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"].cost["<1-65535>"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"]["database-filter"].all.out.enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"]["database-filter"].all.out.cost["<1-65535>"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"]["poll-interval"]["<0-4294967295>"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"].priority["<0-255>"].enter = true;


+


+routerOSPFC.neighbor["A.B.C.D"].priority["<0-255>"]["poll-interval"]["<0-4294967295>"].enter = true;


+


+routerOSPFC.network["A.B.C.D"]["A.B.C.D"].area["<0-4294967295>"].enter = true;


+


+routerOSPFC.network["A.B.C.D"]["A.B.C.D"].area["A.B.C.D"].enter = true;


+


+routerOSPFC["passive-interface"].enter = true;


+


+routerOSPFC["passive-interface"].Null["<0-0>"].enter = true;


+


+routerOSPFC["passive-interface"].Vlan["<1-1001>"].enter = true;


+


+routerOSPFC["passive-interface"]["default"].enter = true;


+


+routerOSPFC.redistribute.enter = true;


+


+routerOSPFC.redistribute.bgp["<1-65535>"].enter = true;


+


+routerOSPFC.redistribute.connected.enter = true;


+


+routerOSPFC.redistribute.egp["<0-65535>"].enter = true;


+


+routerOSPFC.redistribute.eigrp["<1-65535>"].enter = true;


+


+routerOSPFC.redistribute.igrp["<1-65535>"].enter = true;


+


+routerOSPFC.redistribute.isis.enter = true;


+


+routerOSPFC.redistribute.isis["level-1"].enter = true;


+


+routerOSPFC.redistribute.isis["level-1-2"].enter = true;


+


+routerOSPFC.redistribute.isis["level-2"].enter = true;


+


+routerOSPFC.redistribute.isis.WORD.enter = true;


+


+routerOSPFC.redistribute.isis.WORD["level-1"].enter = true;


+


+routerOSPFC.redistribute.isis.WORD["level-1-2"].enter = true;


+


+routerOSPFC.redistribute.isis.WORD["level-2"].enter = true;


+


+routerOSPFC.redistribute["iso-igrp"].enter = true;


+


+routerOSPFC.redistribute["iso-igrp"].WORD.enter = true;


+


+routerOSPFC.redistribute.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.mobile.enter = true;


+


+routerOSPFC.redistribute.mobile.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.odr.enter = true;


+


+routerOSPFC.redistribute.odr.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match.internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match.internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match["nssa-external"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match.internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match.internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match["nssa-external"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match["nssa-external"].external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match["nssa-external"].internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].metric["<0-16777214>"].match["nssa-external"].internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16777214>"].match.external.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16777214>"].match.internal.enter = true;


+


+routerOSPFC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16777214>"].match["nssa-external"].enter = true;


+


+routerOSPFC.redistribute.rip.enter = true;


+


+routerOSPFC.redistribute.rip.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute["route-map"].WORD.enter = true;


+


+routerOSPFC.redistribute["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.static.enter = true;


+


+routerOSPFC.redistribute.static.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.static["route-map"].WORD.enter = true;


+


+routerOSPFC.redistribute.static["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.subnets.enter = true;


+


+routerOSPFC.redistribute.subnets.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.subnets["route-map"].WORD.enter = true;


+


+routerOSPFC.redistribute.subnets["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"]["route-map"].WORD.enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"]["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].subnets.enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].subnets.metric["<0-16777214>"].enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].subnets["route-map"].WORD.enter = true;


+


+routerOSPFC.redistribute.tag["<0-4294967295>"].subnets["route-map"].WORD.metric["<0-16777214>"].enter = true;


+


+routerOSPFC["summary-address"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerOSPFC["summary-address"]["A.B.C.D"]["A.B.C.D"]["not-advertise"].enter = true;


+


+routerOSPFC["summary-address"]["A.B.C.D"]["A.B.C.D"].tag["<0-4294967295>"].enter = true;


+


+routerOSPFC.timers["lsa-group-pacing"]["<10-1800>"].enter = true;


+


+routerOSPFC.timers.spf["<0-4294967295>"]["<0-4294967295>"].enter = true;


+


+routerOSPFC["traffic-share"].min["across-interfaces"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerRIP.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerRIP.txt
new file mode 100644
index 0000000..33ce318
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_routerRIP.txt
@@ -0,0 +1,350 @@
+routerRIPC["address-family"].ipv4.enter = true;


+


+routerRIPC["address-family"].ipv4.unicast.enter = true;


+


+routerRIPC["address-family"].ipv4.vrf.WORD.enter = true;


+


+routerRIPC["auto-summary"].enter = true;


+


+routerRIPC["default-information"].originate.enter = true;


+


+routerRIPC["default-information"].originate["route-map"].WORD.enter = true;


+


+routerRIPC.distance["<1-255>"].enter = true;


+


+routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].enter = true;


+


+routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1-99>"].enter = true;


+


+routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"]["<1300-1999>"].enter = true;


+


+routerRIPC.distance["<1-255>"]["A.B.C.D"]["A.B.C.D"].WORD.enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"]["in"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"]["in"].Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.bgp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.connected.enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.egp["<0-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.eigrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.igrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.rip.enter = true;


+


+routerRIPC["distribute-list"]["<1-199>"].out.static.enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"]["in"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"]["in"].Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"]["in"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.bgp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.connected.enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.egp["<0-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.eigrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.igrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.rip.enter = true;


+


+routerRIPC["distribute-list"]["<1300-2699>"].out.static.enter = true;


+


+routerRIPC["distribute-list"].WORD["in"].enter = true;


+


+routerRIPC["distribute-list"].WORD["in"].Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.enter = true;


+


+routerRIPC["distribute-list"].WORD.out.Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.bgp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.connected.enter = true;


+


+routerRIPC["distribute-list"].WORD.out.egp["<0-65535>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.igrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.ospf["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC["distribute-list"].WORD.out.rip.enter = true;


+


+routerRIPC["distribute-list"].WORD.out.static.enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD["in"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD["in"].Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.connected.enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.egp["<0-65535>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.rip.enter = true;


+


+routerRIPC["distribute-list"].gateway.WORD.out.static.enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD["in"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD["in"].Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD["in"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.Null["<0-0>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.Vlan["<1-1001>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.bgp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.connected.enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.egp["<0-65535>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.eigrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.igrp["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.rip.enter = true;


+


+routerRIPC["distribute-list"].prefix.WORD.out.static.enter = true;


+


+routerRIPC.exit.enter = true;


+


+routerRIPC.help.enter = true;


+


+routerRIPC["maximum-paths"]["<1-8>"].enter = true;


+


+routerRIPC.neighbor["A.B.C.D"].enter = true;


+


+routerRIPC.network["A.B.C.D"].enter = true;


+


+routerRIPC["passive-interface"].enter = true;


+


+routerRIPC["passive-interface"].Null["<0-0>"].enter = true;


+


+routerRIPC["passive-interface"].Vlan["<1-1001>"].enter = true;


+


+routerRIPC["passive-interface"]["default"].enter = true;


+


+routerRIPC.redistribute.enter = true;


+


+routerRIPC.redistribute.bgp["<1-65535>"].enter = true;


+


+routerRIPC.redistribute.connected.enter = true;


+


+routerRIPC.redistribute.egp["<0-65535>"].enter = true;


+


+routerRIPC.redistribute.eigrp["<1-65535>"].enter = true;


+


+routerRIPC.redistribute.igrp["<1-65535>"].enter = true;


+


+routerRIPC.redistribute.isis.enter = true;


+


+routerRIPC.redistribute.isis["level-1"].enter = true;


+


+routerRIPC.redistribute.isis["level-1-2"].enter = true;


+


+routerRIPC.redistribute.isis["level-2"].enter = true;


+


+routerRIPC.redistribute.isis.WORD.enter = true;


+


+routerRIPC.redistribute.isis.WORD["level-1"].enter = true;


+


+routerRIPC.redistribute.isis.WORD["level-1-2"].enter = true;


+


+routerRIPC.redistribute.isis.WORD["level-2"].enter = true;


+


+routerRIPC.redistribute["iso-igrp"].enter = true;


+


+routerRIPC.redistribute["iso-igrp"].WORD.enter = true;


+


+routerRIPC.redistribute.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.metric.transparent.enter = true;


+


+routerRIPC.redistribute.mobile.enter = true;


+


+routerRIPC.redistribute.mobile.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.mobile.metric.transparent.enter = true;


+


+routerRIPC.redistribute.odr.enter = true;


+


+routerRIPC.redistribute.odr.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.odr.metric.transparent.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match.internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].match["nssa-external"].internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match.internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric["<0-16>"].match["nssa-external"].internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match.internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].metric.transparent.match["nssa-external"].internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match.internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.match["nssa-external"].internal.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric["<0-16>"].match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.external.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match.internal.enter = true;


+


+routerRIPC.redistribute.ospf["<1-65535>"].vrf.WORD.metric.transparent.match["nssa-external"].enter = true;


+


+routerRIPC.redistribute.rip.enter = true;


+


+routerRIPC.redistribute.rip.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.rip.metric.transparent.enter = true;


+


+routerRIPC.redistribute["route-map"].WORD.enter = true;


+


+routerRIPC.redistribute["route-map"].WORD.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute["route-map"].WORD.metric.transparent.enter = true;


+


+routerRIPC.redistribute.static.enter = true;


+


+routerRIPC.redistribute.static.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.static.metric.transparent.enter = true;


+


+routerRIPC.redistribute.static["route-map"].WORD.enter = true;


+


+routerRIPC.redistribute.static["route-map"].WORD.metric["<0-16>"].enter = true;


+


+routerRIPC.redistribute.static["route-map"].WORD.metric.transparent.enter = true;


+


+routerRIPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerRIPC.timers.basic["<0-4294967295>"]["<1-4294967295>"]["<0-4294967295>"]["<1-4294967295>"]["<1-4294967295>"].enter = true;


+


+routerRIPC["traffic-share"].min["across-interfaces"].enter = true;


+


+routerRIPC.version["<1-2>"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_timeRange.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_timeRange.txt
new file mode 100644
index 0000000..62ac6e2
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_timeRange.txt
@@ -0,0 +1,4 @@
+timeRangeC.absolute.enter = true;


+


+timeRangeC.exit.enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_user.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_user.txt
new file mode 100644
index 0000000..da65721
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_user.txt
@@ -0,0 +1,24 @@
+userC.connect.enter = true;


+


+userC.connect.WORD.enter = true;


+userC.disable.enter = true;


+


+userC.disable["<0-15>"].enter = true;


+


+userC.enable.enter = true;


+


+userC.enable["<0-15>"].enter = true;


+


+userC.exit.enter = true;


+


+userC.help.enter = true;


+


+userC.ping.WORD.enter = true;


+


+userC.ping.ip.WORD.enter = true;


+


+userC.ping.tag.WORD.enter = true;


+


+userC.telnet.enter = true;


+


+userC.telnet.WORD.enter = true;


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_vlanDB.txt b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_vlanDB.txt
new file mode 100644
index 0000000..2137384
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/fnc_vlanDB.txt
@@ -0,0 +1,272 @@
+lanDBC.abort.enter = true;


+


+vlanDBC.apply.enter = true;


+


+vlanDBC.exit.enter = true;


+


+vlanDBC.reset.enter = true;


+


+vlanDBC.show.enter = true;


+


+vlanDBC.show.changes.enter = true;


+


+vlanDBC.show.changes["<1-1005>"].enter = true;


+


+vlanDBC.show.current.enter = true;


+


+vlanDBC.show.current["<1-1005>"].enter = true;


+


+vlanDBC.show.proposed.enter = true;


+


+vlanDBC.show.proposed["<1-1005>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge["<0-15>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge["<0-15>"].backupcrf.disable.enter = true;


+vlanDBC.vlan["<1-1005>"].bridge.type.srb.enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge.type.srb.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge.type.srb.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge.type.srt.enter = true;


+


+vlanDBC.vlan["<1-1005>"].bridge.type.srt.are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].media.ethernet.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].media.ethernet.backupcrf.enable.enter = true;


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge["<0-15>"].enter = true;


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge["<0-15>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge["<0-15>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge["<0-15>"].backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srb.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srb.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srb.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srb.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srt.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srt.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srt.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.ethernet.bridge.type.srt.backupcrf.enable.enter = true;


+vlanDBC.vlan["<1-1005>"].media.fddi.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge["<0-15>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge["<0-15>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge["<0-15>"].backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srb.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srb.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srb.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srb.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srt.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srt.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srt.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.fddi.bridge.type.srt.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge["<0-15>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge["<0-15>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge["<0-15>"].backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srb.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srb.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srb.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srb.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srt.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srt.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srt.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].media.tokenring.bridge.type.srt.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].mtu["<576-18190>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].mtu["<576-18190>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].mtu["<576-18190>"].backupcrf.disable.enter = true;


+vlanDBC.vlan["<1-1005>"].name.WORD.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.backupcrf.enable.enter = true;


+vlanDBC.vlan["<1-1005>"].name.WORD.bridge["<0-15>"].enter = true;


+vlanDBC.vlan["<1-1005>"].name.WORD.media.ethernet.enter = true;


+vlanDBC.vlan["<1-1005>"].name.WORD.media.ethernet.are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.bridge.type.srb.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.fddi.bridge.type.srt.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.tokenring.enter = true;


+


+vlanDBC.vlan["<1-1005>"].name.WORD.media.tokenring.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].parent["<0-1005>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].parent["<0-1005>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].parent["<0-1005>"].backupcrf.disable.enter = true;


+vlanDBC.vlan["<1-1005>"].ring["<1-4095>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].ring["<1-4095>"].are["<0-13>"].enter = true;


+


+vvlanDBC.vlan["<1-1005>"].said["<1-4294967294>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].said["<1-4294967294>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].said["<1-4294967294>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.active.bridge["<0-15>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.media.ethernet.enter = true;


+vlanDBC.vlan["<1-1005>"].state.suspend.media.fddi.enter = true;


+vlanDBC.vlan["<1-1005>"].state.suspend.media.tokenring.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.media.tokenring.are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].state.suspend.name.WORD.enter = true;


+


+vlanDBC.vlan["<1-1005>"].state.suspend.name.WORD.are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].state.suspend.ring["<1-4095>"].enter = true;


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].backupcrf.disable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].backupcrf.disable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].backupcrf.enable.enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].backupcrf.enable.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].bridge["<0-15>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].ste["<0-13>"].bridge["<0-15>"].are["<0-13>"].enter = true;


+vlanDBC.vlan["<1-1005>"].stp.type.auto.enter = true;


+


+vlanDBC.vlan["<1-1005>"].stp.type.auto.are["<0-13>"].enter = true;


+


+vlanDBC.vlan["<1-1005>"].stp.type.auto.backupcrf.disable.enter = true;


+vlanDBC.vlan["<1-1005>"].stp.type.auto.bridge.type.srb.enter = true;


+vlanDBC.vlan["<1-1005>"].stp.type.auto.ring["<1-4095>"].enter = true;


+vlanDBC.vlan["<1-1005>"].stp.type.ieee.enter = true;


+


+vlanDBC.vtp.client.enter = true;


+


+vlanDBC.vtp.domain.WORD.enter = true;


+


+vlanDBC.vtp.password.WORD.enter = true;


+


+vlanDBC.vtp.password["domain."].enter = true;


+


+vlanDBC.vtp.pruning.enter = true;


+


+vlanDBC.vtp.server.enter = true;


+


+vlanDBC.vtp.transparent.enter = true;


+


+vlanDBC.vtp["v2-mode"].enter = true;


+


diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/global.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/global.swf
new file mode 100644
index 0000000..bace473
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/global.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intG.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intG.swf
new file mode 100644
index 0000000..89a1f0a
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intG.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intLoopBack.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intLoopBack.swf
new file mode 100644
index 0000000..75ae735
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intLoopBack.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intVlan.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intVlan.swf
new file mode 100644
index 0000000..91369bc
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/intVlan.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linecon.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linecon.swf
new file mode 100644
index 0000000..4ecb342
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linecon.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linevty.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linevty.swf
new file mode 100644
index 0000000..882d097
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/linevty.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/mapClass.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/mapClass.swf
new file mode 100644
index 0000000..b9013a2
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/mapClass.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMap.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMap.swf
new file mode 100644
index 0000000..4564ccb
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMap.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMapClass.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMapClass.swf
new file mode 100644
index 0000000..820237a
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/policyMapClass.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routeMap.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routeMap.swf
new file mode 100644
index 0000000..b4feeb5
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routeMap.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerAF.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerAF.swf
new file mode 100644
index 0000000..badda2a
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerAF.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerBGP.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerBGP.swf
new file mode 100644
index 0000000..b4e761b
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerBGP.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerEIGRP.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerEIGRP.swf
new file mode 100644
index 0000000..6b80ca5
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerEIGRP.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerIGRP.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerIGRP.swf
new file mode 100644
index 0000000..bc37de1
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerIGRP.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerOSPF.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerOSPF.swf
new file mode 100644
index 0000000..15552dd
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerOSPF.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerRIP.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerRIP.swf
new file mode 100644
index 0000000..a4cb572
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/routerRIP.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/timeRange.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/timeRange.swf
new file mode 100644
index 0000000..4c17ce7
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/timeRange.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/user.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/user.swf
new file mode 100644
index 0000000..4bf7b5e
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/user.swf
diff --git a/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/vlanDB.swf b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/vlanDB.swf
new file mode 100644
index 0000000..0e2408e
--- /dev/null
+++ b/Bachelor/CCNA4/en_CCNA4_v30/elabs/Engine/Switch 4006 Sup 3/vlanDB.swf