diff --git a/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml b/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml
new file mode 100644
index 00000000..b02dbf19
--- /dev/null
+++ b/changelogs/fragments/T8609_rm_templates_regex_backtracking.yml
@@ -0,0 +1,12 @@
+---
+bugfixes:
+  - bgp_address_family.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - bgp_address_family_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - bgp_global.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - bgp_global_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - ospf_interfaces.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - ospf_interfaces_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - route_maps.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - route_maps_14.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - snmp_server.py - Fix slow parse() to stop regex backtracking on prefix-sharing inputs.
+  - test_rm_templates_perf.py - Add unit test for the bugfixes
diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
index f8f86cd2..fccfc9c2 100644
--- a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family.py
@@ -1,1450 +1,1435 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Bgp_address_family parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_bgp_af_aggregate_address(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} address-family ".format(**config_data)
     config_data = config_data["address_family"]
     if config_data["aggregate_address"].get("as_set"):
         command += afi + " aggregate-address {prefix} as-set".format(
             **config_data["aggregate_address"],
         )
     if config_data["aggregate_address"].get("summary_only"):
         command += afi + " aggregate-address {prefix} summary-only".format(
             **config_data["aggregate_address"],
         )
     return command
 
 
 def _tmplt_bgp_af_redistribute(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} address-family ".format(**config_data)
     config_data = config_data["address_family"]["redistribute"]
     command += afi + " redistribute {protocol}".format(**config_data)
     if config_data.get("metric"):
         command += " metric {metric}".format(**config_data)
     elif config_data.get("route_map"):
         command += " route-map {route_map}".format(**config_data)
     elif config_data.get("table"):
         command += " table {table}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_redistribute_delete(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} address-family ".format(**config_data)
     config_data = config_data["address_family"]["redistribute"]
     command += afi + " redistribute {protocol}".format(**config_data)
     if config_data.get("metric"):
         command += " metric"
     elif config_data.get("route_map"):
         command += " route-map"
     elif config_data.get("table"):
         command += " table"
     return command
 
 
 def _tmplt_bgp_af_neighbor_distribute_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["distribute_list"]:
         command.append(
             cmd + afi + " distribute-list " + list_el["action"] + " " + str(list_el["acl"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_route_map(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["route_map"]:
         command.append(
             cmd + afi + " route-map " + list_el["action"] + " " + str(list_el["route_map"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_prefix_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["prefix_list"]:
         command.append(
             cmd + afi + " prefix-list " + list_el["action"] + " " + str(list_el["prefix_list"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_filter_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["filter_list"]:
         command.append(
             cmd + afi + " filter-list " + list_el["action"] + " " + str(list_el["path_list"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_attribute(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp {as_number} neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for k in config_data["attribute_unchanged"].keys():
         if config_data["attribute_unchanged"][k]:
             k = re.sub("_", "-", k)
             c = cmd + afi + " attribute-unchanged " + k
             command.append(c)
     return command
 
 
 def _tmplt_bgp_af_neighbor_delete(config_data):
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} ".format(**config_data)
     command += (
         "neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
     )
     config_data = config_data["neighbors"]["address_family"]
     if config_data.get("allowas_in"):
         command += " allowas-in"
     elif config_data.get("as_override"):
         command += " as-override"
     elif config_data.get("attribute_unchanged"):
         command += " attribute-unchanged"
     elif config_data.get("capability"):
         command += " capability"
     elif config_data.get("default_originate"):
         command += " default-originate"
     elif config_data.get("maximum_prefix"):
         command += " maximum-prefix"
     elif config_data.get("nexthop_local"):
         command += " nexthop-local"
     elif config_data.get("nexthop_self"):
         command += " nexthop-self"
     elif config_data.get("peer_group"):
         command += " peer-group"
     elif config_data.get("remote_private_as"):
         command += " remote-private-as"
     elif config_data.get("route_reflector_client"):
         command += " route-reflector-client"
     elif config_data.get("route_server_client"):
         command += " route-server-client"
     elif config_data.get("soft_reconfiguration"):
         command += " soft-reconfiguration"
     elif config_data.get("unsuppress_map"):
         command += " unsuppress-map"
     elif config_data.get("weight"):
         command += " weight"
     elif config_data.get("filter_list"):
         command += " filter-list"
     elif config_data.get("prefix_list"):
         command += " prefix-list"
     elif config_data.get("distribute_list"):
         command += " distribute-list"
     elif config_data.get("route_map"):
         command += " route-map"
     return command
 
 
 def _tmplt_bgp_af_neighbor(config_data):
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} ".format(**config_data)
     command += (
         "neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
     )
     config_data = config_data["neighbors"]["address_family"]
     if config_data.get("allowas_in"):
         command += " allowas-in number {allowas_in}".format(**config_data)
     elif config_data.get("as_override"):
         command += " as-override"
     elif config_data.get("capability"):
         command += " capability "
         if config_data["capability"].get("dynamic"):
             command += "dynamic"
         elif config_data["capability"].get("orf"):
             command += " prefix-list {orf}".format(**config_data["capability"])
     elif config_data.get("default_originate"):
         command += " default-originate route-map {default_originate}".format(**config_data)
     elif config_data.get("maximum_prefix"):
         command += " maximum-prefix {maximum_prefix}".format(**config_data)
     elif config_data.get("nexthop_local"):
         command += " nexthop-local"
     elif config_data.get("nexthop_self"):
         command += " nexthop-self"
     elif config_data.get("peer_group"):
         command += " peer-group {peer_group}".format(**config_data)
     elif config_data.get("remote_private_as"):
         command += " remote-private-as"
     elif config_data.get("route_reflector_client"):
         command += " route-reflector-client"
     elif config_data.get("route_server_client"):
         command += " route-server-client"
     elif config_data.get("soft_reconfiguration"):
         command += " soft-reconfiguration inbound"
     elif config_data.get("unsuppress_map"):
         command += " unsuppress-map {unsuppress_map}".format(**config_data)
     elif config_data.get("weight"):
         command += " weight {weight}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_network(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} address-family ".format(**config_data)
     config_data = config_data["address_family"]["networks"]
     command += afi + " network {prefix}".format(**config_data)
     if config_data.get("backdoor"):
         command += " backdoor"
     elif config_data.get("route_map"):
         command += " route-map {route_map}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_network_delete(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp {as_number} address-family ".format(**config_data)
     config_data = config_data["address_family"]["networks"]
     command += afi + " network {prefix}".format(**config_data)
     if config_data.get("backdoor"):
         command += " backdoor"
     elif config_data.get("route_map"):
         command += " route_map"
     return command
 
 
 class Bgp_address_familyTemplate(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Bgp_address_familyTemplate, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "address_family",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast",
             "compval": "as_number",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                     },
                 },
             },
         },
         {
             "name": "aggregate_address",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+aggregate-address
                 \s+(?P<address>\S+)
-                \s*(?P<as_set>as-set)*
-                \s*(?P<summary_only>summary-only)*
+                \s*(?P<as_set>as-set)?
+                \s*(?P<summary_only>summary-only)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_aggregate_address,
             "remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast aggregate-address" +
                       " {{ address_family.aggregate_address.prefix }}",
             "compval": "address_family.aggregate_address",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "aggregate_address": [
                             {
                                 "prefix": "{{ address }}",
                                 "as_set": "{{ True if as_set is defined }}",
                                 "summary_only": "{{ True if summary_only is defined }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast network {{ address_family.networks.prefix }}",
             "compval": "address_family.networks.prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.backdoor",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+backdoor
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.backdoor",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "backdoor": "{{ True }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.path_limit",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+path-limit
-                \s+(?P<limit>\S+)
-                *$""",
+                \s+(?P<limit>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.path_limit",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "path_limit": "{{ limit|int }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": "protocols bgp {{ as_number }} address-family {{ address_family.afi }}-unicast redistribute {{ address_family.redistribute.protocol }}",
             "compval": "address_family.redistribute.protocol",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.metric",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
                 \s+metric
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.metric",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                                 "metric": "{{ val|int }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.table",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+table
-                \s+(?P<tab>\S+)
-                *$""",
+                \s+(?P<tab>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.table",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "table": "{{ tab }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbors",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbors.neighbor_address }} address-family",
             "compval": "neighbors",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                     },
                 },
             },
         },
         {
             "name": "neighbors.address_family",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbors.neighbor_address }} address-family {{ neighbors.address_family.afi }}-unicast",
             "compval": "neighbors",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.allowas_in",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+allowas-in
                 \s+number
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.allowas_in",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "allowas_in": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.as_override",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+as-override
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.as_override",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "as_override": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>as-path)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.as_path",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "as_path": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>med)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "med": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.next_hop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>next-hop)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.next_hop",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "next_hop": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.capability_dynamic",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+capability
                 \s+dynamic
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.capability.dynamic",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "capability": {
                                     "dynamic": "{{ true }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.capability_orf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+capability
                 \s+prefix-list
-                \s+(?P<orf>\S+)
-                *$""",
+                \s+(?P<orf>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.capability.orf",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "capability": {
                                     "orf": "{{ orf }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.default_originate",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+default-originate
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.default_originate",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "default_originate": "{{ map }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.distribute_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+distribute-list
                 \s+(?P<action>export|import)
                 \s+(?P<list>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_distribute_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.distribute_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "distribute_list": [
                                     {
                                         "action": "{{ action }}",
                                         "acl": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.prefix_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+prefix-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_prefix_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.prefix_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "prefix_list": [
                                     {
                                         "action": "{{ action }}",
                                         "prefix_list": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.filter_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+filter-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_filter_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.filter_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "filter_list": [
                                     {
                                         "action": "{{ action }}",
                                         "path_list": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.maximum_prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+maximum-prefix
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.maximum_prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "maximum_prefix": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.nexthop_local",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+nexthop-local
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.nexthop_local",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "nexthop_local": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.nexthop_self",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+nexthop-self
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.nexthop_self",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "nexthop_self": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.peer_group",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+peer-group
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.peer_group",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "peer_group": "{{ name }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.remove_private_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+remove-private-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.remove_private_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "remove_private_as": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-map
                 \s+(?P<action>export|import)
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_route_map,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_map": [
                                     {
                                         "action": "{{ action }}",
                                         "route_map": "{{ map }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_reflector_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-reflector-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_reflector_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_reflector_client": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_server_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-server-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_server_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_server_client": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.soft_reconfiguration",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+soft-reconfiguration
                 \s+inbound
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.soft_reconfiguration",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "soft_reconfiguration": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.unsuppress_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+unsuppress-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.unsuppress_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "unsuppress_map": "{{ map }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.weight",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+weight
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.weight",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "weight": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
index fd4c9de9..09cd41a7 100644
--- a/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_address_family_14.py
@@ -1,1433 +1,1418 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Bgp_address_family parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_bgp_af_aggregate_address(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp address-family ".format(**config_data)
     config_data = config_data["address_family"]
     if config_data["aggregate_address"].get("as_set"):
         command += afi + " aggregate-address {prefix} as-set".format(
             **config_data["aggregate_address"],
         )
     if config_data["aggregate_address"].get("summary_only"):
         command += afi + " aggregate-address {prefix} summary-only".format(
             **config_data["aggregate_address"],
         )
     return command
 
 
 def _tmplt_bgp_af_redistribute(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp address-family ".format(**config_data)
     config_data = config_data["address_family"]["redistribute"]
     command += afi + " redistribute {protocol}".format(**config_data)
     if config_data.get("metric"):
         command += " metric {metric}".format(**config_data)
     elif config_data.get("route_map"):
         command += " route-map {route_map}".format(**config_data)
     elif config_data.get("table"):
         command += " table {table}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_redistribute_delete(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp address-family ".format(**config_data)
     config_data = config_data["address_family"]["redistribute"]
     command += afi + " redistribute {protocol}".format(**config_data)
     if config_data.get("metric"):
         command += " metric"
     elif config_data.get("route_map"):
         command += " route-map"
     elif config_data.get("table"):
         command += " table"
     return command
 
 
 def _tmplt_bgp_af_neighbor_distribute_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["distribute_list"]:
         command.append(
             cmd + afi + " distribute-list " + list_el["action"] + " " + str(list_el["acl"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_route_map(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["route_map"]:
         command.append(
             cmd + afi + " route-map " + list_el["action"] + " " + str(list_el["route_map"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_prefix_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["prefix_list"]:
         command.append(
             cmd + afi + " prefix-list " + list_el["action"] + " " + str(list_el["prefix_list"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_filter_list(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for list_el in config_data["filter_list"]:
         command.append(
             cmd + afi + " filter-list " + list_el["action"] + " " + str(list_el["path_list"]),
         )
     return command
 
 
 def _tmplt_bgp_af_neighbor_attribute(config_data):
     command = []
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     cmd = "protocols bgp neighbor ".format(**config_data)
     cmd += "{neighbor_address} address-family ".format(**config_data["neighbors"])
     config_data = config_data["neighbors"]["address_family"]
     for k in config_data["attribute_unchanged"].keys():
         if config_data["attribute_unchanged"][k]:
             k = re.sub("_", "-", k)
             c = cmd + afi + " attribute-unchanged " + k
             command.append(c)
     return command
 
 
 def _tmplt_bgp_af_neighbor_delete(config_data):
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     command = "protocols bgp ".format(**config_data)
     command += (
         "neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
     )
     config_data = config_data["neighbors"]["address_family"]
     if config_data.get("allowas_in"):
         command += " allowas-in"
     elif config_data.get("as_override"):
         command += " as-override"
     elif config_data.get("attribute_unchanged"):
         command += " attribute-unchanged"
     elif config_data.get("capability"):
         command += " capability"
     elif config_data.get("default_originate"):
         command += " default-originate"
     elif config_data.get("maximum_prefix"):
         command += " maximum-prefix"
     elif config_data.get("nexthop_local"):
         command += " nexthop-local"
     elif config_data.get("nexthop_self"):
         command += " nexthop-self"
     elif config_data.get("peer_group"):
         command += " peer-group"
     elif config_data.get("remote_private_as"):
         command += " remote-private-as"
     elif config_data.get("route_reflector_client"):
         command += " route-reflector-client"
     elif config_data.get("route_server_client"):
         command += " route-server-client"
     elif config_data.get("soft_reconfiguration"):
         command += " soft-reconfiguration"
     elif config_data.get("unsuppress_map"):
         command += " unsuppress-map"
     elif config_data.get("weight"):
         command += " weight"
     elif config_data.get("filter_list"):
         command += " filter-list"
     elif config_data.get("prefix_list"):
         command += " prefix-list"
     elif config_data.get("distribute_list"):
         command += " distribute-list"
     elif config_data.get("route_map"):
         command += " route-map"
     return command
 
 
 def _tmplt_bgp_af_neighbor(config_data):
     afi = config_data["neighbors"]["address_family"]["afi"] + "-unicast"
     command = "protocols bgp ".format(**config_data)
     command += (
         "neighbor {neighbor_address} address-family ".format(**config_data["neighbors"]) + afi
     )
     config_data = config_data["neighbors"]["address_family"]
     if config_data.get("allowas_in"):
         command += " allowas-in number {allowas_in}".format(**config_data)
     elif config_data.get("as_override"):
         command += " as-override"
     elif config_data.get("capability"):
         command += " capability "
         if config_data["capability"].get("dynamic"):
             command += "dynamic"
         elif config_data["capability"].get("orf"):
             command += " prefix-list {orf}".format(**config_data["capability"])
     elif config_data.get("default_originate"):
         command += " default-originate route-map {default_originate}".format(**config_data)
     elif config_data.get("maximum_prefix"):
         command += " maximum-prefix {maximum_prefix}".format(**config_data)
     elif config_data.get("nexthop_local"):
         command += " nexthop-local"
     elif config_data.get("nexthop_self"):
         command += " nexthop-self"
     elif config_data.get("peer_group"):
         command += " peer-group {peer_group}".format(**config_data)
     elif config_data.get("remote_private_as"):
         command += " remote-private-as"
     elif config_data.get("route_reflector_client"):
         command += " route-reflector-client"
     elif config_data.get("route_server_client"):
         command += " route-server-client"
     elif config_data.get("soft_reconfiguration"):
         command += " soft-reconfiguration inbound"
     elif config_data.get("unsuppress_map"):
         command += " unsuppress-map {unsuppress_map}".format(**config_data)
     elif config_data.get("weight"):
         command += " weight {weight}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_network(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp address-family ".format(**config_data)
     config_data = config_data["address_family"]["networks"]
     command += afi + " network {prefix}".format(**config_data)
     if config_data.get("backdoor"):
         command += " backdoor"
     elif config_data.get("route_map"):
         command += " route-map {route_map}".format(**config_data)
     return command
 
 
 def _tmplt_bgp_af_network_delete(config_data):
     afi = config_data["address_family"]["afi"] + "-unicast"
     command = "protocols bgp address-family ".format(**config_data)
     config_data = config_data["address_family"]["networks"]
     command += afi + " network {prefix}".format(**config_data)
     if config_data.get("backdoor"):
         command += " backdoor"
     elif config_data.get("route_map"):
         command += " route_map"
     return command
 
 
 class Bgp_address_familyTemplate14(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Bgp_address_familyTemplate14, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "system_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+system-as
                 \s+(?P<as_num>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp system-as {{ as_number }}",
             "compval": "as_number",
             "result": {
                 "as_number": "{{ as_num }}",
             },
         },
         {
             "name": "address_family",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp address-family {{ address_family.afi }}-unicast",
             "compval": "as_number",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                     },
                 },
             },
         },
         {
             "name": "aggregate_address",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+aggregate-address
                 \s+(?P<address>\S+)
-                \s*(?P<as_set>as-set)*
-                \s*(?P<summary_only>summary-only)*
+                \s*(?P<as_set>as-set)?
+                \s*(?P<summary_only>summary-only)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_aggregate_address,
             "remval": "protocols bgp address-family {{ address_family.afi }}-unicast aggregate-address" +
                       " {{ address_family.aggregate_address.prefix }}",
             "compval": "address_family.aggregate_address",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "aggregate_address": [
                             {
                                 "prefix": "{{ address }}",
                                 "as_set": "{{ True if as_set is defined }}",
                                 "summary_only": "{{ True if summary_only is defined }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": "protocols bgp address-family {{ address_family.afi }}-unicast network {{ address_family.networks.prefix }}",
             "compval": "address_family.networks.prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.backdoor",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+backdoor
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.backdoor",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "backdoor": "{{ True }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.path_limit",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+path-limit
-                \s+(?P<limit>\S+)
-                *$""",
+                \s+(?P<limit>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.path_limit",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "path_limit": "{{ limit|int }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "network.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+network
                 \s+(?P<address>\S+)
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_network,
             "remval": _tmplt_bgp_af_network_delete,
             "compval": "address_family.networks.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "networks": [
                             {
                                 "prefix": "{{ address }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": "protocols bgp address-family {{ address_family.afi }}-unicast redistribute {{ address_family.redistribute.protocol }}",
             "compval": "address_family.redistribute.protocol",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.metric",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
-                \s+metric\s+(?P<val>\S+)
-                *$""",
+                \s+metric\s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.metric",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                                 "metric": "{{ val }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+(?P<proto>\S+)
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "protocol": "{{ proto }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "redistribute.table",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+redistribute
                 \s+table
-                \s+(?P<tab>\S+)
-                *$""",
+                \s+(?P<tab>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_redistribute,
             "remval": _tmplt_bgp_af_redistribute_delete,
             "compval": "address_family.redistribute.table",
             "result": {
                 "as_number": "{{ as_num }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": "{{ afi }}",
                         "redistribute": [
                             {
                                 "table": "{{ tab }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbors",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbors.neighbor_address }} address-family",
             "compval": "neighbors",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                     },
                 },
             },
         },
         {
             "name": "neighbors.address_family",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbors.neighbor_address }} address-family {{ neighbors.address_family.afi }}-unicast",
             "compval": "neighbors",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.allowas_in",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+allowas-in
                 \s+number
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.allowas_in",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "allowas_in": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.as_override",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+as-override
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.as_override",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "as_override": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>as-path)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.as_path",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "as_path": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>med)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "med": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.attribute_unchanged.next_hop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+attribute-unchanged
                 \s+(?P<val>next-hop)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_attribute,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.attribute_unchanged.next_hop",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "attribute_unchanged": {
                                     "next_hop": "{{ True }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.capability_dynamic",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+capability
                 \s+dynamic
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.capability.dynamic",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "capability": {
                                     "dynamic": "{{ true }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.capability_orf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+capability
                 \s+prefix-list
-                \s+(?P<orf>\S+)
-                *$""",
+                \s+(?P<orf>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.capability.orf",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "capability": {
                                     "orf": "{{ orf }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.default_originate",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+default-originate
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.default_originate",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "default_originate": "{{ map }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.distribute_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+distribute-list
                 \s+(?P<action>export|import)
                 \s+(?P<list>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_distribute_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.distribute_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "distribute_list": [
                                     {
                                         "action": "{{ action }}",
                                         "acl": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.prefix_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+prefix-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_prefix_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.prefix_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "prefix_list": [
                                     {
                                         "action": "{{ action }}",
                                         "prefix_list": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.filter_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+filter-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_filter_list,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.filter_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "filter_list": [
                                     {
                                         "action": "{{ action }}",
                                         "path_list": "{{ list }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.maximum_prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+maximum-prefix
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.maximum_prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "maximum_prefix": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.nexthop_local",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+nexthop-local
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.nexthop_local",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "nexthop_local": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.nexthop_self",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+nexthop-self
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.nexthop_self",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "nexthop_self": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.peer_group",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+peer-group
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.peer_group",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "peer_group": "{{ name }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.remove_private_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+remove-private-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.remove_private_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "remove_private_as": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-map
                 \s+(?P<action>export|import)
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor_route_map,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_map": [
                                     {
                                         "action": "{{ action }}",
                                         "route_map": "{{ map }}",
                                     },
                                 ],
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_reflector_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-reflector-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_reflector_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_reflector_client": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.route_server_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+route-server-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.route_server_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "route_server_client": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.soft_reconfiguration",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+soft-reconfiguration
                 \s+inbound
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.soft_reconfiguration",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "soft_reconfiguration": "{{ True }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.unsuppress_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+unsuppress-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.unsuppress_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "unsuppress_map": "{{ map }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbors.weight",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+address-family
                 \s+(?P<afi>\S+)-unicast
                 \s+weight
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_af_neighbor,
             "remval": _tmplt_bgp_af_neighbor_delete,
             "compval": "neighbors.address_family.weight",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbors": {
                     "{{ address }}": {
                         "neighbor_address": "{{ address }}",
                         "address_family": {
                             "{{ afi }}": {
                                 "afi": "{{ afi }}",
                                 "weight": "{{ num }}",
                             },
                         },
                     },
                 },
             },
         },
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_global.py b/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
index 8c2e2f55..03f6265b 100644
--- a/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_global.py
@@ -1,1859 +1,1828 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Bgp_global parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_bgp_params_confederation(config_data):
     command = []
     for list_el in config_data["bgp_params"]["confederation"]:
         for k, v in list_el.items():
             command.append(
                 "protocols bgp {as_number} parameters confederation ".format(**config_data)
                 + k
                 + " "
                 + str(v),
             )
 
     return command
 
 
 def _tmplt_bgp_maximum_paths(config_data):
     command = []
     for list_el in config_data["maximum_paths"]:
         command.append(
             "protocols bgp {as_number} maximum-paths ".format(**config_data)
             + list_el["path"]
             + " "
             + str(list_el["count"]),
         )
     return command
 
 
 def _tmplt_delete_bgp_maximum_paths(config_data):
     command = "protocols bgp {as_number} maximum-paths".format(**config_data)
     return command
 
 
 def _tmplt_bgp_params_default(config_data):
     command = "protocols bgp {as_number} parameters default".format(**config_data)
     if config_data["bgp_params"]["default"].get("no_ipv4_unicast"):
         command += " no-ipv4-unicast"
     if config_data["bgp_params"]["default"].get("local_pref"):
         command += " local-pref {local_pref}".format(**config_data["bgp_params"]["default"])
     return command
 
 
 def _tmplt_bgp_neighbor_timers(config_data):
     command = []
     for k, v in config_data["neighbor"]["timers"].items():
         command.append(
             "protocols bgp {as_number} neighbor ".format(**config_data)
             + config_data["neighbor"]["address"]
             + " timers "
             + k
             + " "
             + str(v),
         )
 
     return command
 
 
 def _tmplt_bgp_timers(config_data):
     command = []
     for k, v in config_data["timers"].items():
         command.append(
             "protocols bgp {as_number} ".format(**config_data) + "timers " + k + " " + str(v),
         )
 
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_as_path(config_data):
     command = "protocols bgp {as_number} ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged as-path".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_med(config_data):
     command = "protocols bgp {as_number} ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged med".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_next_hop(config_data):
     command = "protocols bgp {as_number} ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged next-hop".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_distribute_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["distribute_list"]:
         command.append(
             "protocols bgp {as_number} ".format(**config_data)
             + "neighbor {address} distribute-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["acl"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_route_map(config_data):
     command = []
     for list_el in config_data["neighbor"]["route_map"]:
         command.append(
             "protocols bgp {as_number} ".format(**config_data)
             + "neighbor {address} route-map ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["route_map"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_prefix_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["prefix_list"]:
         command.append(
             "protocols bgp {as_number} ".format(**config_data)
             + "neighbor {address} prefix-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["prefix_list"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_filter_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["filter_list"]:
         command.append(
             "protocols bgp {as_number} ".format(**config_data)
             + "neighbor {address} filter-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["path_list"]),
         )
     return command
 
 
 def _tmplt_bgp_params_distance(config_data):
     command = (
         "protocols bgp {as_number} parameters distance global ".format(**config_data)
         + config_data["bgp_params"]["distance"]["type"]
         + " "
         + str(config_data["bgp_params"]["distance"]["value"])
     )
     return command
 
 
 class Bgp_globalTemplate(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Bgp_globalTemplate, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "router",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }}",
             "compval": "as_number",
             "result": {
                 "as_number": "{{ as_num }}",
             },
         },
         {
             "name": "maximum_paths",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+maximum-paths
                 \s+(?P<path>ebgp|ibgp)
                 \s+(?P<count>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_maximum_paths,
             "remval": _tmplt_delete_bgp_maximum_paths,
             "compval": "maximum_paths",
             "result": {
                 "as_number": "{{ as_num }}",
                 "maximum_paths": [
                     {
                         "path": "{{ path }}",
                         "count": "{{ count }}",
                     },
                 ],
             },
         },
         {
             "name": "neighbor.advertisement_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+advertisement-interval
-                \s+(?P<interval>\S+)
-                *$""",
+                \s+(?P<interval>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} advertisement-interval {{ neighbor.advertisement_interval }}",
             "remval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} advertisement-interval",
             "compval": "neighbor.advertisement_interval",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "advertisement_interval": "{{ interval }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.allowas_in",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+allowas-in
                 \s+number
                 \s+(?P<num>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} allowas-in number {{ neighbor.allowas_in }}",
             "compval": "neighbor.allowas_in",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "allowas_in": "{{ count }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.as_override",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+as-override
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} as-override",
             "compval": "neighbor.as_override",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "as_override": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>as-path)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_as_path,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'as_path' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>med)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_med,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'med' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.next_hop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>next-hop)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_next_hop,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'next_hop' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.capability_dynamic",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+capability
                 \s+(?P<dynamic>dynamic)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} capability dynamic",
             "compval": "neighbor.capability.dynamic",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "capability": {
                             "dynamic": "{{ True if dynamic is defined}}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.capability_orf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+capability
                 \s+orf
                 \s+prefix-list
-                \s+(?P<orf>\S+)
-                *$""",
+                \s+(?P<orf>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} capability orf prefix-list {{ neighbor.capability.orf }}",
             "compval": "neighbor.capability.orf",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "capability": {
                             "orf": "{{ orf }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.default_originate",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+default-originate
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} default-originate route-map {{ neighbor.default_originate }}",
             "compval": "neighbor.advertisement_interval",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "default_originate": "{{ map }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.description",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+description
-                \s+(?P<desc>\S+)
-                *$""",
+                \s+(?P<desc>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} description {{ neighbor.description }}",
             "compval": "neighbor.description",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "description": "{{ desc }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_capability_negotiation",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-capability-negotiation
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-capability-negotiation",
             "compval": "neighbor.disable_capability_negotiation",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_capability_negotiation": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_connected_check",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-connected-check
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-connected-check",
             "compval": "neighbor.disable_connected_check",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_connected_check": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_send_community",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-send-community
-                \s+(?P<comm>\S+)
-                *$""",
+                \s+(?P<comm>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} disable-send-community {{ neighbor.disable_send_community }}",
             "compval": "neighbor.disable_send_community",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_send_community": "{{ comm }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.distribute_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+distribute-list
                 \s+(?P<action>export|import)
                 \s+(?P<list>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_distribute_list,
             "compval": "neighbor.distribute_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "distribute_list": [
                             {
                                 "action": "{{ action }}",
                                 "acl": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.ebgp_multihop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+ebgp-multihop
-                \s+(?P<hop>\S+)
-                *$""",
+                \s+(?P<hop>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} ebgp-multihop {{ neighbor.ebgp_multihop }}",
             "compval": "neighbor.ebgp_multihop",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "ebgp_multihop": "{{ hop|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.filter_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+filter-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_filter_list,
             "compval": "neighbor.filter_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "filter_list": [
                             {
                                 "action": "{{ action }}",
                                 "path_list": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.local_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+local-as
                 \s+(?P<as>\S+)
                 \s+no-prepend
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} local-as {{ neighbor.local_as }} no-prepend",
             "compval": "neighbor.local_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "local_as": "{{ as }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.maximum_prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+maximum-prefix
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} maximum-prefix {{ neighbor.maximum_prefix }}",
             "compval": "neighbor.maximum_prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "maximum_prefix": "{{ num }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.nexthop_self",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+nexthop-self
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} nexthop-self",
             "compval": "neighbor.nexthop_self",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "nexthop_self": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.override_capability",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+override-capability
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} override-capability",
             "compval": "neighbor.override_capability",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "override_capability": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.passive",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+passive
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} passive",
             "compval": "neighbor.passive",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "passive": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.password",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+password
-                \s+(?P<pwd>\S+)
-                *$""",
+                \s+(?P<pwd>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} password {{ neighbor.password }}",
             "compval": "neighbor.password",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "password": "{{ pwd }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.peer_group_name",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+peer-group
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} peer-group {{ neighbor.peer_group_name }}",
             "compval": "neighbor.peer_group_name",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "peer_group_name": "{{ name }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.port",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+port
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} port {{ neighbor.port }}",
             "compval": "neighbor.port",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "port": "{{ num|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.prefix_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+prefix-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_prefix_list,
             "compval": "neighbor.prefix_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "prefix_list": [
                             {
                                 "action": "{{ action }}",
                                 "prefix_list": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.remote_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+remote-as
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} remote-as {{ neighbor.remote_as }}",
             "compval": "neighbor.remote_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "remote_as": "{{ num|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.remove_private_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+remote-private-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} remote-private-as",
             "compval": "neighbor.remove_private_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "remove_private_as": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-map
                 \s+(?P<action>export|import)
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_route_map,
             "compval": "neighbor.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_map": [
                             {
                                 "action": "{{ action }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_reflector_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-reflector-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} router-reflector-client",
             "compval": "neighbor.route_reflector_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_reflector_client": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_server_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-server-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} route-server-client",
             "compval": "neighbor.route_server_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_server_client": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.shutdown",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+shutdown
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} shutdown",
             "compval": "neighbor.shutdown",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "shutdown": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.soft_reconfiguration",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+soft-reconfiguration
                 \s+inbound
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} soft-reconfiguration",
             "compval": "neighbor.soft_reconfiguration",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "soft_reconfiguration": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.strict_capability_match",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+strict-capability-match
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} strict-capability-match",
             "compval": "neighbor.strict_capability_match",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "strict_capability_match": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.unsuppress_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+unsuppress-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} unsuppress-map {{ neighbor.unsuppress_map }}",
             "compval": "neighbor.unsuppress_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "unsuppress_map": "{{ map }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.update_source",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+update-source
-                \s+(?P<src>\S+)
-                *$""",
+                \s+(?P<src>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} update-source {{ neighbor.update_source }}",
             "compval": "neighbor.update_source",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "update_source": "{{ src }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.weight",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+weight
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} weight {{ neighbor.weight }}",
             "compval": "neighbor.weight",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "weight": "{{ num }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.ttl_security",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+ttl-security
-                \s+(?P<ttl>\S+)
-                *$""",
+                \s+(?P<ttl>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} ttl-security {{ neighbor.ttl_security }}",
             "compval": "neighbor.ttl_security",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "ttl_security": "{{ ttl|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.timers",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+timers
                 \s+(?P<type>connect|holdtime|keepalive)
-                \s+(?P<sec>\S+)
-                *$""",
+                \s+(?P<sec>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_timers,
             "remval": "protocols bgp {{ as_number }} neighbor {{ neighbor.address }} timers",
             "compval": "neighbor.timers",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "timers": {
                             "{{ type }}": "{{ sec }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "timers",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+timers
                 \s+(?P<type>\S+)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_timers,
             "remval": "protocols bgp {{ as_number }} timers",
             "compval": "timers",
             "result": {
                 "as_number": "{{ as_num }}",
                 "timers": {
                     "{{ type }}": "{{ val }}",
                 },
             },
         },
         {
             "name": "bgp_params.always_compare_med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+always-compare-med
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters always-compare-med",
             "compval": "bgp_params.always_compare_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "always_compare_med": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+bestpath
                 \s+as-path
                 \s+(?P<path>confed|ignore)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters bestpath as-path {{ bgp_params.bestpath.as_path }}",
             "compval": "bgp_params.bestpath.as_path",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "as_path": "{{ path }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.compare_routerid",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+bestpath
                 \s+compare-routerid
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters bestpath compare-routerid",
             "compval": "bgp_params.bestpath.compare_routerid",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "compare_routerid": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+bestpath
                 \s+med
                 \s+(?P<path>confed|missing-as-worst)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters bestpath med {{ bestpath.med }}",
             "compval": "bgp_params.bestpath.med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "med": "{{ path }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.cluster_id",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+cluster-id
-                \s+(?P<id>\S+)
-                *$""",
+                \s+(?P<id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters cluster-id {{ bgp_params.cluster_id }}",
             "compval": "bgp_params.cluster_id",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "cluster_id": "{{ id }}",
                 },
             },
         },
         {
             "name": "bgp_params.confederation",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+confederation
                 \s+(?P<type>identifier|peers)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_confederation,
             "compval": "bgp_params.always_compare_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "confederation": [
                         {
                             "peers": "{{ val if type == 'peers' }}",
                             "identifier": "{{ val if type == 'identifier' }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.dampening_half_life",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+dampening
                 \s+half-life
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters dampening half-life {{ bgp_params.dampening.half_life}}",
             "compval": "bgp_params.dampening.half_life",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "half_life": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_max_suppress_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+dampening
                 \s+max-suppress-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters dampening max-suppress-time {{ bgp_params.dampening.max_suppress_time}}",
             "compval": "bgp_params.dampening.max_suppress_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "max_suppress_time": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_re_use",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+dampening
                 \s+re-use
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters dampening re-use {{ bgp_params.dampening.re_use}}",
             "compval": "bgp_params.dampening.re_use",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "re_use": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_start_suppress_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+dampening
                 \s+start-suppress-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters dampening start-suppress-time {{ bgp_params.dampening.start_suppress_time}}",
             "compval": "bgp_params.dampening.start_suppress_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "start_suppress_time": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.default",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+default
-                \s*(?P<no_ipv4_unicast>no-ipv4-unicast)*
-                \s*(?P<local_pref>local-pref\s\S+)
-                *$""",
+                \s*(?P<no_ipv4_unicast>no-ipv4-unicast)?
+                \s*(?P<local_pref>local-pref\s\S+)?\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_default,
             "remval": "protocols bgp {{ as_number }} parameters default",
             "compval": "bgp_params.default",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "default": {
                         "no_ipv4_unicast": "{{ True if no_ipv4_unicast is defined }}",
                         "local_pref": "{{ local_pref.split(" " )[1] if local_pref is defined }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.deterministic_med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+deterministic-med
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters deterministic-med",
             "compval": "bgp_params.deterministic_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "deterministic_med": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.disbale_network_import_check",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+disable-network-import-check
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters disable-network-import-check",
             "compval": "bgp_params.disable_network_import_check",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "disable_network_import_check": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.distance.prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+distance\sprefix
                 \s+(?P<prefix>\S+)
                 \s+distance
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters distance prefix {{ bgp_params.distance.prefix }} distance {{ bgp_params.distance.value }}",
             "compval": "bgp_params.distance.prefix",
             "remval": "protocols bgp {{ as_number }} parameters distance prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "distance": [
                         {
                             "prefix": "{{ prefix }}",
                             "value": "{{ val }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.distance.global",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+distance\sglobal
                 \s+(?P<type>\S+)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_distance,
             "remval": "protocols bgp {{ as_number }} parameters distance global",
             "compval": "bgp_params.distance",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "distance": [
                         {
                             "type": "{{ type }}",
                             "value": "{{ val }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.enforce_first_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+enforce-first-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters enforce-first-as",
             "compval": "bgp_params.enforce_first_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "enforce_first_as": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.graceful_restart",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+graceful-restart\s+stalepath-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters graceful-restart stalepath-time {{ bgp_params.graceful_restart }}",
             "compval": "bgp_params.graceful_restart",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "graceful_restart": "{{ val }}",
                 },
             },
         },
         {
             "name": "bgp_params.log_neighbor_changes",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+log-neighbor-changes
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters log-neighbor-changes",
             "compval": "bgp_params.log_neighbor_changes",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "log_neighbor_changes": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.no_client_to_client_reflection",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+no-client-to-client-reflection
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters no-client-to-client-reflection",
             "compval": "bgp_params.log_neighbor_changes",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "no_client_to_client_reflection": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.no_fast_external_failover",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+no-fast-external-failover
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters no-fast-external-failover",
             "compval": "bgp_params.no_fast_external_failover",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "no_fast_external_failover": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.routerid",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+router-id
-                \s+(?P<id>\S+)
-                *$""",
+                \s+(?P<id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters router-id {{ bgp_params.router_id }}",
             "compval": "bgp_params.router_id",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "router_id": "{{ id }}",
                 },
             },
         },
         {
             "name": "bgp_params.scan_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+(?P<as_num>\d+)
                 \s+parameters
                 \s+scan-time
                 \s+(?P<sec>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp {{ as_number }} parameters scan-time {{ bgp_params.scan_time }}",
             "compval": "bgp_params.scan_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "scan_time": "{{ val }}",
                 },
             },
         },
 
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py b/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
index 39855c1c..cbe21e3a 100644
--- a/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
+++ b/plugins/module_utils/network/vyos/rm_templates/bgp_global_14.py
@@ -1,1795 +1,1764 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Bgp_global parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_bgp_params_confederation(config_data):
     command = []
     for list_el in config_data["bgp_params"]["confederation"]:
         for k, v in list_el.items():
             command.append(
                 "protocols bgp parameters confederation ".format(**config_data) + k + " " + str(v),
             )
 
     return command
 
 
 def _tmplt_bgp_maximum_paths(config_data):
     command = []
     for list_el in config_data["maximum_paths"]:
         command.append(
             "protocols bgp maximum-paths ".format(**config_data)
             + list_el["path"]
             + " "
             + str(list_el["count"]),
         )
     return command
 
 
 def _tmplt_delete_bgp_maximum_paths(config_data):
     command = "protocols bgp maximum-paths".format(**config_data)
     return command
 
 
 def _tmplt_bgp_params_default(config_data):
     command = "protocols bgp parameters default".format(**config_data)
     if config_data["bgp_params"]["default"].get("no_ipv4_unicast"):
         command += " no-ipv4-unicast"
     if config_data["bgp_params"]["default"].get("local_pref"):
         command += " local-pref {local_pref}".format(**config_data["bgp_params"]["default"])
     return command
 
 
 def _tmplt_bgp_neighbor_timers(config_data):
     command = []
     for k, v in config_data["neighbor"]["timers"].items():
         command.append(
             "protocols bgp neighbor ".format(**config_data)
             + config_data["neighbor"]["address"]
             + " timers "
             + k
             + " "
             + str(v),
         )
 
     return command
 
 
 def _tmplt_bgp_timers(config_data):
     command = []
     for k, v in config_data["timers"].items():
         command.append(
             "protocols bgp ".format(**config_data) + "timers " + k + " " + str(v),
         )
 
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_as_path(config_data):
     command = "protocols bgp ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged as-path".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_med(config_data):
     command = "protocols bgp ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged med".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_attribute_unchanged_next_hop(config_data):
     command = "protocols bgp ".format(
         **config_data,
     ) + "neighbor {address} attribute-unchanged next-hop".format(**config_data["neighbor"])
     return command
 
 
 def _tmplt_bgp_neighbor_distribute_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["distribute_list"]:
         command.append(
             "protocols bgp ".format(**config_data)
             + "neighbor {address} distribute-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["acl"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_route_map(config_data):
     command = []
     for list_el in config_data["neighbor"]["route_map"]:
         command.append(
             "protocols bgp ".format(**config_data)
             + "neighbor {address} route-map ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["route_map"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_prefix_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["prefix_list"]:
         command.append(
             "protocols bgp ".format(**config_data)
             + "neighbor {address} prefix-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["prefix_list"]),
         )
     return command
 
 
 def _tmplt_bgp_neighbor_filter_list(config_data):
     command = []
     for list_el in config_data["neighbor"]["filter_list"]:
         command.append(
             "protocols bgp ".format(**config_data)
             + "neighbor {address} filter-list ".format(**config_data["neighbor"])
             + list_el["action"]
             + " "
             + str(list_el["path_list"]),
         )
     return command
 
 
 def _tmplt_bgp_params_distance(config_data):
     command = (
         "protocols bgp parameters distance global ".format(**config_data)
         + config_data["bgp_params"]["distance"]["type"]
         + " "
         + str(config_data["bgp_params"]["distance"]["value"])
     )
     return command
 
 
 class Bgp_globalTemplate14(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Bgp_globalTemplate14, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "router",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s*system-as
                 \s+(?P<as_num>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp system-as {{ as_number }}",
             "remval": "protocols bgp",
             "compval": "as_number",
             "result": {
                 "as_number": "{{ as_num }}",
             },
         },
         {
             "name": "maximum_paths",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+maximum-paths
                 \s+(?P<path>ebgp|ibgp)
                 \s+(?P<count>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_maximum_paths,
             "remval": _tmplt_delete_bgp_maximum_paths,
             "compval": "maximum_paths",
             "result": {
                 "as_number": "{{ as_num }}",
                 "maximum_paths": [
                     {
                         "path": "{{ path }}",
                         "count": "{{ count }}",
                     },
                 ],
             },
         },
         {
             "name": "neighbor.advertisement_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+advertisement-interval
-                \s+(?P<interval>\S+)
-                *$""",
+                \s+(?P<interval>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} advertisement-interval {{ neighbor.advertisement_interval }}",
             "remval": "protocols bgp neighbor {{ neighbor.address }} advertisement-interval",
             "compval": "neighbor.advertisement_interval",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "advertisement_interval": "{{ interval }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.allowas_in",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+allowas-in
                 \s+number
                 \s+(?P<num>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} allowas-in number {{ neighbor.allowas_in }}",
             "compval": "neighbor.allowas_in",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "allowas_in": "{{ count }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.as_override",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+as-override
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} as-override",
             "compval": "neighbor.as_override",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "as_override": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>as-path)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_as_path,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'as_path' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>med)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_med,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'med' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.attribute_unchanged.next_hop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+attribute-unchanged
                 \s+(?P<val>next-hop)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_attribute_unchanged_next_hop,
             "compval": "neighbor.attribute_unchanged",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "attribute_unchanged": {
                             "{{ 'next_hop' }}": "{{ True }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.capability_dynamic",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+capability
                 \s+(?P<dynamic>dynamic)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} capability dynamic",
             "compval": "neighbor.capability.dynamic",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "capability": {
                             "dynamic": "{{ True if dynamic is defined}}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.capability_orf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+capability
                 \s+orf
                 \s+prefix-list
-                \s+(?P<orf>\S+)
-                *$""",
+                \s+(?P<orf>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} capability orf prefix-list {{ neighbor.capability.orf }}",
             "compval": "neighbor.capability.orf",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "capability": {
                             "orf": "{{ orf }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "neighbor.default_originate",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+default-originate
                 \s+route-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} default-originate route-map {{ neighbor.default_originate }}",
             "compval": "neighbor.advertisement_interval",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "default_originate": "{{ map }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.description",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+description
-                \s+(?P<desc>\S+)
-                *$""",
+                \s+(?P<desc>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} description {{ neighbor.description }}",
             "compval": "neighbor.description",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "description": "{{ desc }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_capability_negotiation",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-capability-negotiation
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} disable-capability-negotiation",
             "compval": "neighbor.disable_capability_negotiation",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_capability_negotiation": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_connected_check",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-connected-check
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} disable-connected-check",
             "compval": "neighbor.disable_connected_check",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_connected_check": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.disable_send_community",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+disable-send-community
-                \s+(?P<comm>\S+)
-                *$""",
+                \s+(?P<comm>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} disable-send-community {{ neighbor.disable_send_community }}",
             "compval": "neighbor.disable_send_community",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "disable_send_community": "{{ comm }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.distribute_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+distribute-list
                 \s+(?P<action>export|import)
                 \s+(?P<list>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_distribute_list,
             "compval": "neighbor.distribute_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "distribute_list": [
                             {
                                 "action": "{{ action }}",
                                 "acl": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.ebgp_multihop",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+ebgp-multihop
-                \s+(?P<hop>\S+)
-                *$""",
+                \s+(?P<hop>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} ebgp-multihop {{ neighbor.ebgp_multihop }}",
             "compval": "neighbor.ebgp_multihop",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "ebgp_multihop": "{{ hop|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.filter_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+filter-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_filter_list,
             "compval": "neighbor.filter_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "filter_list": [
                             {
                                 "action": "{{ action }}",
                                 "path_list": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.local_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+local-as
                 \s+(?P<as>\S+)
                 \s+no-prepend
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} local-as {{ neighbor.local_as }} no-prepend",
             "compval": "neighbor.local_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "local_as": "{{ as }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.maximum_prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+maximum-prefix
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} maximum-prefix {{ neighbor.maximum_prefix }}",
             "compval": "neighbor.maximum_prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "maximum_prefix": "{{ num }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.nexthop_self",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+nexthop-self
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} nexthop-self",
             "compval": "neighbor.nexthop_self",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "nexthop_self": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.override_capability",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+override-capability
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} override-capability",
             "compval": "neighbor.override_capability",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "override_capability": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.passive",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+passive
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} passive",
             "compval": "neighbor.passive",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "passive": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.password",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+password
-                \s+(?P<pwd>\S+)
-                *$""",
+                \s+(?P<pwd>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} password {{ neighbor.password }}",
             "compval": "neighbor.password",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "password": "{{ pwd }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.peer_group_name",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+peer-group
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} peer-group {{ neighbor.peer_group_name }}",
             "compval": "neighbor.peer_group_name",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "peer_group_name": "{{ name }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.port",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+port
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} port {{ neighbor.port }}",
             "compval": "neighbor.port",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "port": "{{ num|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.prefix_list",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+prefix-list
                 \s+(?P<action>export|import)
-                \s+(?P<list>\S+)
-                *$""",
+                \s+(?P<list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_prefix_list,
             "compval": "neighbor.prefix_list",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "prefix_list": [
                             {
                                 "action": "{{ action }}",
                                 "prefix_list": "{{ list }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.remote_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+remote-as
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} remote-as {{ neighbor.remote_as }}",
             "compval": "neighbor.remote_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "remote_as": "{{ num|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.remove_private_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+remote-private-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} remote-private-as",
             "compval": "neighbor.remove_private_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "remove_private_as": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-map
                 \s+(?P<action>export|import)
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_route_map,
             "compval": "neighbor.route_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_map": [
                             {
                                 "action": "{{ action }}",
                                 "route_map": "{{ map }}",
                             },
                         ],
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_reflector_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-reflector-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} router-reflector-client",
             "compval": "neighbor.route_reflector_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_reflector_client": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.route_server_client",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+route-server-client
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} route-server-client",
             "compval": "neighbor.route_server_client",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "route_server_client": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.shutdown",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+shutdown
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} shutdown",
             "compval": "neighbor.shutdown",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "shutdown": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.soft_reconfiguration",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+soft-reconfiguration
                 \s+inbound
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} soft-reconfiguration",
             "compval": "neighbor.soft_reconfiguration",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "soft_reconfiguration": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.strict_capability_match",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+strict-capability-match
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} strict-capability-match",
             "compval": "neighbor.strict_capability_match",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "strict_capability_match": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.unsuppress_map",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+unsuppress-map
-                \s+(?P<map>\S+)
-                *$""",
+                \s+(?P<map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} unsuppress-map {{ neighbor.unsuppress_map }}",
             "compval": "neighbor.unsuppress_map",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "unsuppress_map": "{{ map }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.update_source",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+update-source
-                \s+(?P<src>\S+)
-                *$""",
+                \s+(?P<src>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} update-source {{ neighbor.update_source }}",
             "compval": "neighbor.update_source",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "update_source": "{{ src }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.weight",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+weight
-                \s+(?P<num>\S+)
-                *$""",
+                \s+(?P<num>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} weight {{ neighbor.weight }}",
             "compval": "neighbor.weight",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "weight": "{{ num }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.ttl_security",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+ttl-security
-                \s+(?P<ttl>\S+)
-                *$""",
+                \s+(?P<ttl>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp neighbor {{ neighbor.address }} ttl-security {{ neighbor.ttl_security }}",
             "compval": "neighbor.ttl_security",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "ttl_security": "{{ ttl|int }}",
                     },
                 },
             },
         },
         {
             "name": "neighbor.timers",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+neighbor
                 \s+(?P<address>\S+)
                 \s+timers
                 \s+(?P<type>connect|holdtime|keepalive)
-                \s+(?P<sec>\S+)
-                *$""",
+                \s+(?P<sec>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_neighbor_timers,
             "remval": "protocols bgp neighbor {{ neighbor.address }} timers",
             "compval": "neighbor.timers",
             "result": {
                 "as_number": "{{ as_num }}",
                 "neighbor": {
                     "{{ address }}": {
                         "address": "{{ address }}",
                         "timers": {
                             "{{ type }}": "{{ sec }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "timers",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+timers
                 \s+(?P<type>\S+)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_timers,
             "remval": "protocols bgp timers",
             "compval": "timers",
             "result": {
                 "as_number": "{{ as_num }}",
                 "timers": {
                     "{{ type }}": "{{ val }}",
                 },
             },
         },
         {
             "name": "bgp_params.always_compare_med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+always-compare-med
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters always-compare-med",
             "compval": "bgp_params.always_compare_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "always_compare_med": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.as_path",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+bestpath
                 \s+as-path
                 \s+(?P<path>confed|ignore)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters bestpath as-path {{ bgp_params.bestpath.as_path }}",
             "compval": "bgp_params.bestpath.as_path",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "as_path": "{{ path }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.compare_routerid",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+bestpath
                 \s+compare-routerid
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters bestpath compare-routerid",
             "compval": "bgp_params.bestpath.compare_routerid",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "compare_routerid": "{{ True }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.bestpath.med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+bestpath
                 \s+med
                 \s+(?P<path>confed|missing-as-worst)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters bestpath med {{ bestpath.med }}",
             "compval": "bgp_params.bestpath.med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "bestpath": {
                         "med": "{{ path }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.cluster_id",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+cluster-id
-                \s+(?P<id>\S+)
-                *$""",
+                \s+(?P<id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters cluster-id {{ bgp_params.cluster_id }}",
             "compval": "bgp_params.cluster_id",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "cluster_id": "{{ id }}",
                 },
             },
         },
         {
             "name": "bgp_params.confederation",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+confederation
                 \s+(?P<type>identifier|peers)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_confederation,
             "compval": "bgp_params.always_compare_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "confederation": [
                         {
                             "peers": "{{ val if type == 'peers' }}",
                             "identifier": "{{ val if type == 'identifier' }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.dampening_half_life",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+dampening
                 \s+half-life
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters dampening half-life {{ bgp_params.dampening.half_life}}",
             "compval": "bgp_params.dampening.half_life",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "half_life": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_max_suppress_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+dampening
                 \s+max-suppress-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters dampening max-suppress-time {{ bgp_params.dampening.max_suppress_time}}",
             "compval": "bgp_params.dampening.max_suppress_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "max_suppress_time": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_re_use",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+dampening
                 \s+re-use
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters dampening re-use {{ bgp_params.dampening.re_use}}",
             "compval": "bgp_params.dampening.re_use",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "re_use": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.dampening_start_suppress_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+dampening
                 \s+start-suppress-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters dampening start-suppress-time {{ bgp_params.dampening.start_suppress_time}}",
             "compval": "bgp_params.dampening.start_suppress_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "dampening": {
                         "start_suppress_time": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.default",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+default
-                \s*(?P<no_ipv4_unicast>no-ipv4-unicast)*
-                \s*(?P<local_pref>local-pref\s\S+)
-                *$""",
+                \s*(?P<no_ipv4_unicast>no-ipv4-unicast)?
+                \s*(?P<local_pref>local-pref\s\S+)?\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_default,
             "remval": "protocols bgp parameters default",
             "compval": "bgp_params.default",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "default": {
                         "no_ipv4_unicast": "{{ True if no_ipv4_unicast is defined }}",
                         "local_pref": "{{ local_pref.split(" " )[1] if local_pref is defined }}",
                     },
                 },
             },
         },
         {
             "name": "bgp_params.deterministic_med",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+deterministic-med
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters deterministic-med",
             "compval": "bgp_params.deterministic_med",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "deterministic_med": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.disbale_network_import_check",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+disable-network-import-check
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters disable-network-import-check",
             "compval": "bgp_params.disable_network_import_check",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "disable_network_import_check": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.distance.prefix",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+distance\sprefix
                 \s+(?P<prefix>\S+)
                 \s+distance
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters distance prefix {{ bgp_params.distance.prefix }} distance {{ bgp_params.distance.value }}",
             "compval": "bgp_params.distance.prefix",
             "remval": "protocols bgp parameters distance prefix",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "distance": [
                         {
                             "prefix": "{{ prefix }}",
                             "value": "{{ val }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.distance.global",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+distance\sglobal
                 \s+(?P<type>\S+)
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_bgp_params_distance,
             "remval": "protocols bgp parameters distance global",
             "compval": "bgp_params.distance",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "distance": [
                         {
                             "type": "{{ type }}",
                             "value": "{{ val }}",
                         },
                     ],
                 },
             },
         },
         {
             "name": "bgp_params.enforce_first_as",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+enforce-first-as
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters enforce-first-as",
             "compval": "bgp_params.enforce_first_as",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "enforce_first_as": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.graceful_restart",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+graceful-restart\s+stalepath-time
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters graceful-restart stalepath-time {{ bgp_params.graceful_restart }}",
             "compval": "bgp_params.graceful_restart",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "graceful_restart": "{{ val }}",
                 },
             },
         },
         {
             "name": "bgp_params.log_neighbor_changes",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+log-neighbor-changes
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters log-neighbor-changes",
             "compval": "bgp_params.log_neighbor_changes",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "log_neighbor_changes": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.no_client_to_client_reflection",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+no-client-to-client-reflection
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters no-client-to-client-reflection",
             "compval": "bgp_params.log_neighbor_changes",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "no_client_to_client_reflection": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.no_fast_external_failover",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+no-fast-external-failover
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters no-fast-external-failover",
             "compval": "bgp_params.no_fast_external_failover",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "no_fast_external_failover": "{{ True }}",
                 },
             },
         },
         {
             "name": "bgp_params.routerid",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+router-id
-                \s+(?P<id>\S+)
-                *$""",
+                \s+(?P<id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters router-id {{ bgp_params.router_id }}",
             "compval": "bgp_params.router_id",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "router_id": "{{ id }}",
                 },
             },
         },
         {
             "name": "bgp_params.scan_time",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+bgp
                 \s+parameters
                 \s+scan-time
                 \s+(?P<sec>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": "protocols bgp parameters scan-time {{ bgp_params.scan_time }}",
             "compval": "bgp_params.scan_time",
             "result": {
                 "as_number": "{{ as_num }}",
                 "bgp_params": {
                     "scan_time": "{{ val }}",
                 },
             },
         },
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
index 134effca..af04da3b 100644
--- a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
+++ b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces.py
@@ -1,776 +1,773 @@
 # -*- coding: utf-8 -*-
 # Copyright 2020 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Ospf_interfaces parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import (
     get_interface_type,
     get_interface_with_vif,
 )
 
 
 def _get_parameters(data):
     if data["afi"] == "ipv6":
         val = ["ospfv3", "ipv6"]
     else:
         val = ["ospf", "ip"]
     return val
 
 
 def _tmplt_ospf_int_delete(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = "interfaces " + int_type + " " + name + " " + params[1] + " " + params[0]
 
     return command
 
 
 def _tmplt_ospf_int_cost(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " cost {cost}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_auth_password(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " authentication plaintext-password {plaintext_password}".format(
             **config_data["address_family"]["authentication"],
         )
     )
     return command
 
 
 def _tmplt_ospf_int_auth_md5(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " authentication md5 key-id {key_id} ".format(
             **config_data["address_family"]["authentication"]["md5_key"],
         )
         + "md5-key {key}".format(**config_data["address_family"]["authentication"]["md5_key"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_auth_md5_delete(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " authentication"
     )
 
     return command
 
 
 def _tmplt_ospf_int_bw(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " bandwidth {bandwidth}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_hello_interval(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " hello-interval {hello_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_dead_interval(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " dead-interval {dead_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_mtu_ignore(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces " + int_type + " " + name + " " + params[1] + " " + params[0] + " mtu-ignore"
     )
 
     return command
 
 
 def _tmplt_ospf_int_network(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " network {network}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_priority(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " priority {priority}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_retransmit_interval(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " retransmit-interval {retransmit_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_transmit_delay(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " transmit-delay {transmit_delay}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_ifmtu(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " ifmtu {ifmtu}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_instance(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = (
         "interfaces "
         + int_type
         + " "
         + name
         + " "
         + params[1]
         + " "
         + params[0]
         + " instance-id {instance}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_passive(config_data):
     int_type = get_interface_type(config_data["name"])
     name = get_interface_with_vif(config_data["name"])
     params = _get_parameters(config_data["address_family"])
     command = "interfaces " + int_type + " " + name + " " + params[1] + " " + params[0] + " passive"
 
     return command
 
 
 class Ospf_interfacesTemplate(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Ospf_interfacesTemplate, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "ip_ospf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 *$""",
                 re.VERBOSE,
             ),
             "remval": _tmplt_ospf_int_delete,
             "compval": "address_family",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                     },
                 },
             },
         },
         {
             "name": "authentication_password",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+authentication
                 \s+plaintext-password
-                \s+(?P<text>\S+)
-                *$""",
+                \s+(?P<text>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_auth_password,
             "compval": "address_family.authentication",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "authentication": {
                             "plaintext_password": "{{ text }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "authentication_md5",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+authentication
                 \s+md5
                 \s+key-id
                 \s+(?P<id>\d+)
                 \s+md5-key
-                \s+(?P<text>\S+)
-                *$""",
+                \s+(?P<text>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_auth_md5,
             "remval": _tmplt_ospf_int_auth_md5_delete,
             "compval": "address_family.authentication",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "authentication": {
                             "md5_key": {
                                 "key_id": "{{ id }}",
                                 "key": "{{ text }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "bandwidth",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+bandwidth
                 \s+(?P<bw>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_bw,
             "compval": "address_family.bandwidth",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "bandwidth": "{{ bw }}",
                     },
                 },
             },
         },
         {
             "name": "cost",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+cost
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_cost,
             "compval": "address_family.cost",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "cost": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "hello_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+hello-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_hello_interval,
             "compval": "address_family.hello_interval",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "hello_interval": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "dead_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+dead-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_dead_interval,
             "compval": "address_family.dead_interval",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "dead_interval": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "mtu_ignore",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+(?P<mtu>mtu-ignore)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_mtu_ignore,
             "compval": "address_family.mtu_ignore",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "mtu_ignore": "{{ True if mtu is defined }}",
                     },
                 },
             },
         },
         {
             "name": "network",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+network
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_network,
             "compval": "address_family.network",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "network": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "priority",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+priority
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_priority,
             "compval": "address_family.priority",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "priority": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "retransmit_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+retransmit-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_retransmit_interval,
             "compval": "address_family.retransmit_interval",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "retransmit_interval": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "transmit_delay",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+transmit-delay
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_transmit_delay,
             "compval": "address_family.transmit_delay",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "transmit_delay": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "ifmtu",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+ifmtu
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_ifmtu,
             "compval": "address_family.ifmtu",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "ifmtu": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "instance",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+instance-id
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_instance,
             "compval": "address_family.instance",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "instance": "{{ val }}",
                     },
                 },
             },
         },
         {
             "name": "passive",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 \s+(?P<afi>ip|ipv6)
                 \s+(?P<proto>ospf|ospfv3)
                 \s+(?P<pass>passive)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_passive,
             "compval": "address_family.passive",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
                 "address_family": {
                     "{{ afi }}": {
                         "afi": '{{ "ipv4" if afi == "ip" else "ipv6" }}',
                         "passive": "{{ True if pass is defined }}",
                     },
                 },
             },
         },
         {
             "name": "interface_name",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+interfaces
                 \s+(?P<type>\S+)
                 \s+(?P<name>\S+)
                 (?:\s+vif\s+(?P<vif>\d+))?
                 .*$""",
                 re.VERBOSE,
             ),
             "setval": "set interface {{ type }} {{ name }}",
             "result": {
                 "name": "{{ name + '.' + vif if vif is defined else name }}",
             },
         },
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
index 0d3aa5a7..484d7c44 100644
--- a/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
+++ b/plugins/module_utils/network/vyos/rm_templates/ospf_interfaces_14.py
@@ -1,651 +1,647 @@
 # -*- coding: utf-8 -*-
 # Copyright 2020 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Ospf_interfaces parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _get_parameters(data):
     if data["afi"] == "ipv6":
         val = ["ospfv3", "ipv6"]
     else:
         val = ["ospf", "ip"]
     return val
 
 
 def _tmplt_ospf_int_delete(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols " + params[0] + " interface {name}".format(**config_data)
     )
 
     return command
 
 
 def _tmplt_ospf_int_cost(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " cost {cost}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_auth_password(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " authentication plaintext-password {plaintext_password}".format(
             **config_data["address_family"]["authentication"]
         )
     )
     return command
 
 
 def _tmplt_ospf_int_auth_md5(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " authentication md5 key-id {key_id} ".format(
             **config_data["address_family"]["authentication"]["md5_key"]
         )
         + "md5-key {key}".format(**config_data["address_family"]["authentication"]["md5_key"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_auth_md5_delete(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " authentication"
     )
 
     return command
 
 
 def _tmplt_ospf_int_bw(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " bandwidth {bandwidth}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_hello_interval(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " hello-interval {hello_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_dead_interval(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " dead-interval {dead_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_mtu_ignore(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " mtu-ignore"
     )
 
     return command
 
 
 def _tmplt_ospf_int_network(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " network {network}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_priority(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " priority {priority}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_retransmit_interval(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " retransmit-interval {retransmit_interval}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_transmit_delay(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " transmit-delay {transmit_delay}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_ifmtu(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " ifmtu {ifmtu}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_instance(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " instance-id {instance}".format(**config_data["address_family"])
     )
 
     return command
 
 
 def _tmplt_ospf_int_passive(config_data):
     params = _get_parameters(config_data["address_family"])
     command = (
         "protocols "
         + params[0]
         + " interface {name}".format(**config_data)
         + " passive"
     )
 
     return command
 
 
 class Ospf_interfacesTemplate14(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Ospf_interfacesTemplate14, self).__init__(
             lines=lines, tmplt=self, prefix=prefix, module=module
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "ip_ospf",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "remval": _tmplt_ospf_int_delete,
             "compval": "address_family",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                     }
                 }
             }
         },
         {
             "name": "authentication_password",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+authentication
                 \s+plaintext-password
-                \s+(?P<text>\S+)
-                *$""",
+                \s+(?P<text>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_auth_password,
             "compval": "address_family.authentication",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "authentication": {
                             "plaintext_password": "{{ text }}"
                         }
                     }
                 }
             }
         },
         {
             "name": "authentication_md5",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+authentication
                 \s+md5
                 \s+key-id
                 \s+(?P<id>\d+)
                 \s+md5-key
-                \s+(?P<text>\S+)
-                *$""",
+                \s+(?P<text>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_auth_md5,
             "remval": _tmplt_ospf_int_auth_md5_delete,
             "compval": "address_family.authentication",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "authentication": {
                             "md5_key": {
                                 "key_id": "{{ id }}",
                                 "key": "{{ text }}"
                             }
                         }
                     }
                 }
             }
         },
         {
             "name": "bandwidth",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+bandwidth
                 \s+(?P<bw>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_bw,
             "compval": "address_family.bandwidth",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "bandwidth": "{{ bw }}"
                     }
                 }
             }
         },
         {
             "name": "cost",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+cost
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_cost,
             "compval": "address_family.cost",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "cost": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "hello_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+hello-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_hello_interval,
             "compval": "address_family.hello_interval",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "hello_interval": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "dead_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+dead-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_dead_interval,
             "compval": "address_family.dead_interval",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "dead_interval": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "mtu_ignore",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+(?P<mtu>mtu-ignore)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_mtu_ignore,
             "compval": "address_family.mtu_ignore",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "mtu_ignore": "{{ True if mtu is defined }}"
                     }
                 }
             }
         },
         {
             "name": "network",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+network
-                \s+(?P<val>\S+)
-                *$""",
+                \s+(?P<val>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_network,
             "compval": "address_family.network",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "network": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "priority",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+priority
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_priority,
             "compval": "address_family.priority",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "priority": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "retransmit_interval",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+retransmit-interval
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_retransmit_interval,
             "compval": "address_family.retransmit_interval",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "retransmit_interval": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "transmit_delay",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+transmit-delay
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_transmit_delay,
             "compval": "address_family.transmit_delay",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "transmit_delay": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "ifmtu",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+ifmtu
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_ifmtu,
             "compval": "address_family.ifmtu",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "ifmtu": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "instance",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+instance-id
                 \s+(?P<val>\'\d+\')
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_instance,
             "compval": "address_family.instance",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "instance": "{{ val }}"
                     }
                 }
             }
         },
         {
             "name": "passive",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 \s+(?P<pass>passive)
                 *$""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_ospf_int_passive,
             "compval": "address_family.passive",
             "result": {
                 "name": "{{ name }}",
                 "address_family": {
                     '{{ "ipv4" if proto == "ospf" else "ipv6" }}': {
                         "afi": '{{ "ipv4" if proto == "ospf" else "ipv6" }}',
                         "passive": "{{ True if pass is defined }}"
                     }
                 }
             }
         },
         {
             "name": "interface_name",
             "getval": re.compile(
                 r"""
                 ^set
                 \s+protocols
                 \s+(?P<proto>ospf|ospfv3)
                 \s+interface
                 \s+(?P<name>\S+)
                 .*$""",
                 re.VERBOSE,
             ),
             "setval": "set protocols {{ proto }} interface {{ name }}",
             "result": {
                 "name": "{{ name }}",
             }
         },
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/route_maps.py b/plugins/module_utils/network/vyos/rm_templates/route_maps.py
index c6b88f7b..51d0ea1c 100644
--- a/plugins/module_utils/network/vyos/rm_templates/route_maps.py
+++ b/plugins/module_utils/network/vyos/rm_templates/route_maps.py
@@ -1,1405 +1,1358 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Route_maps parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 class Route_mapsTemplate(NetworkTemplate):
     def __init__(self, lines=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Route_mapsTemplate, self).__init__(lines=lines, tmplt=self, prefix=prefix)
 
     # fmt: off
     PARSERS = [
         {
             "name": "route_map",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "route_map",
             "setval": "policy route-map {{route_map}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                     },
                 },
             },
         },
         {
             "name": "sequence",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "sequence",
             "setval": "policy route-map {{route_map}} rule {{sequence}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "call",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} call {{call}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "call": "{{call}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "description",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} description {{description}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "description": "{{description}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "action",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} action {{action}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "action": "{{action}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "continue_sequence",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} continue {{continue_sequence}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "continue_sequence": "{{continue}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "on_match_next",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "on_match.next",
             "setval": "policy route-map {{route_map}} rule {{sequence}} on-match next",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "on_match": {
                                         "next": "{{True if next is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "on_match_goto",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "on_match.goto",
             "setval": "policy route-map {{route_map}} rule {{sequence}} on-match goto {{on_match.goto}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "on_match": {
                                         "goto": "{{goto}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_aggregator_ip",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.aggregator.ip",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator ip {{set.aggregator.ip}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "aggregator": {
                                             "ip": "{{ip}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_aggregator_as",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.aggregator.as",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator as {{set.aggregator.as}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "aggregator": {
                                             "as": "{{as}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_as_path_exclude",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-exclude\s(?P<as>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-exclude\s(?P<as>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.as_path_exclude",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set as-path-exclude {{set.as_path_exclude}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "as_path_exclude": "{{as}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_as_path_prepend",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path-prepend\s(?P<as>.*)
                 $""",
                 re.VERBOSE,
             ),
             "compval": "set.as_path_prepend",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set as-path-prepend '{{set.as_path_prepend}}'",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "as_path_prepend": "{{as}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_atomic_aggregate",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.atomic_aggregate",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set atomic-aggregate",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "atomic_aggregate": "{{True if as is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_bgp_extcommunity_rt",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.bgp_extcommunity_rt",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set bgp-extcommunity-rt {{set.bgp_extcommunity_rt}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "bgp_extcommunity_rt": "{{bgp}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_comm_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community community-list {{set.comm_list.comm_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"community_list": "{{comm_list}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_comm_list_delete",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\sdelete(?P<delete>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\s(?P<delete>delete)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.comm_list.comm_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set comm-list delete",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "comm_list": {"delete": "{{True if delete is defined}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_rt",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-rt\s(?P<extcommunity_rt>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-rt\s(?P<extcommunity_rt>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_rt",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity-rt {{set.extcommunity_rt}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_rt": "{{extcommunity_rt}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_soo",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-soo\s(?P<extcommunity_soo>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity-soo\s(?P<extcommunity_soo>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_soo",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity-soo {{set.extcommunity_soo}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_soo": "{{set.extcommunity_soo}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_bandwidth",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_bandwidth",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity bandwidth {{set.extcommunity_bandwidth}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_bandwidth": "{{extcommunity_bw}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_bandwidth_non_transitive",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
+                \sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_bandwidth_non_transitive",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity bandwidth-non-transitive",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_bandwidth_non_transitive": "{{True if extcommunity_bw_nt is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_ip_next_hop",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.ip_next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set ip-next-hop {{set.ip_next_hop}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "ip_next_hop": "{{ip_next_hop}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_ipv6_next_hop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sipv6-next-hop
                 \s(?P<type>global|local)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.ipv6_next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set ipv6-next-hop {{set.ipv6_next_hop.ip_type}} {{set.ipv6_next_hop.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "ipv6_next_hop": {
                                             "ip_type": "{{type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_large_community",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<large_community>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<large_community>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.large_community",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set large-community {{set.large_community}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "large_community": "{{large_community}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_local_preference",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.local_preference",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set local-preference {{set.local_preference}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "local_preference": "{{local_preference}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_metric",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.metric",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set metric {{set.metric}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "metric": "{{metric}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_metric_type",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.metric_type",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set metric-type {{set.metric_type}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "metric_type": "{{metric_type}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_origin",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.origin",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set origin {{set.origin}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "origin": "{{origin}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_originator_id",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.originator_id",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set originator-id {{set.originator_id}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "originator_id": "{{originator_id}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_src",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.src",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set src {{set.src}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "src": "{{src}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_tag",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.tag",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set tag {{set.tag}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "tag": "{{tag}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_weight",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.weight",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set weight {{set.weight}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "weight": "{{weight}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_table",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.weight",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set table {{set.table}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "table": "{{table}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_community",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<value>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.community.value",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set community {{set.community.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "community": {
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_as_path",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.as_path",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match as-path {{match.as_path}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "as_path": "{{as_path}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_community_community_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community community-list {{match.community.community_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"community_list": "{{community_list}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_community_exact_match",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.exact_match",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community exact-match",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"exact_match": "{{True if exact_match is defined}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_extcommunity",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.extcommunity",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match extcommunity {{match.extcommunity}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "extcommunity": "{{extcommunity}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_interface",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.interface",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match interface {{match.interface}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "interface": "{{interface}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_large_community_large_community_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.large_community_large_community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match large-community large-community-list {{match.large_community_large_community_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "large_community_large_community_list": "{{lc}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_metric",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.metric",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match metric {{match.metric}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "metric": "{{metric}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_origin",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.origin",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match origin {{match.origin}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "origin": "{{origin}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_peer",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.peer",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match peer {{match.peer}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "peer": "{{peer}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_address",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\saddress
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.address",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip address {{match.ip.address.list_type}} {{match.ip.address.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "address": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_next_hop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\snexthop
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip nexthop {{match.ip.next_hop.list_type}} {{match.ip.next_hop.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "next_hop": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_route_source",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\sroute-source
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.route_source",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip route-source {{match.ip.route_source.list_type}} {{match.ip.route_source.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "route_source": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ipv6_address",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\saddress
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ipv6.address",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ipv6 address {{match.ipv6.address.list_type}} {{match.ipv6.address.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ipv6": {
                                         "address": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ipv6_nexthop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\snexthop
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ipv6.next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ipv6 nexthop {{match.ipv6.next_hop}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ipv6": {
                                         "next_hop": "{{value}}",
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_protocol",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.protocol",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match protocol {{match.protocol}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "protocol": "{{value}}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_rpki",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\srpki
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.rpki",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match rpki {{match.rpki}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "rpki": "{{value}}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
 
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py b/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
index 6564280d..ea61a555 100644
--- a/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
+++ b/plugins/module_utils/network/vyos/rm_templates/route_maps_14.py
@@ -1,1405 +1,1364 @@
 # -*- coding: utf-8 -*-
 # Copyright 2021 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Route_maps parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 class Route_mapsTemplate14(NetworkTemplate):
     def __init__(self, lines=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Route_mapsTemplate14, self).__init__(lines=lines, tmplt=self, prefix=prefix)
 
     # fmt: off
     PARSERS = [
         {
             "name": "route_map",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "route_map",
             "setval": "policy route-map {{route_map}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                     },
                 },
             },
         },
         {
             "name": "sequence",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)
                 *$""",
                 re.VERBOSE,
             ),
             "compval": "sequence",
             "setval": "policy route-map {{route_map}} rule {{sequence}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "call",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scall\s(?P<call>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} call {{call}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "call": "{{call}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "description",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sdescription\s(?P<description>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} description {{description}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "description": "{{description}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "action",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\saction\s(?P<action>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} action {{action}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "action": "{{action}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "continue_sequence",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\scontinue\s(?P<continue>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "policy route-map {{route_map}} rule {{sequence}} continue {{continue_sequence}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "continue_sequence": "{{continue}}",
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "on_match_next",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\s(?P<next>next)
                 *$""",
                 re.VERBOSE,
             ),
             "compval": "on_match.next",
             "setval": "policy route-map {{route_map}} rule {{sequence}} on-match next",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "on_match": {
                                         "next": "{{True if next is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "on_match_goto",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\son-match\sgoto\s(?P<goto>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "on_match.goto",
             "setval": "policy route-map {{route_map}} rule {{sequence}} on-match goto {{on_match.goto}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "on_match": {
                                         "goto": "{{goto}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_aggregator_ip",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sip\s(?P<ip>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.aggregator.ip",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator ip {{set.aggregator.ip}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "aggregator": {
                                             "ip": "{{ip}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_aggregator_as",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\saggregator\sas\s(?P<as>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.aggregator.as",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set aggregator as {{set.aggregator.as}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "aggregator": {
                                             "as": "{{as}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_as_path_exclude",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sexclude\s(?P<as>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sexclude\s(?P<as>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.as_path_exclude",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set as-path exclude {{set.as_path_exclude}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "as_path_exclude": "{{as}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_as_path_prepend",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sas-path\sprepend\s(?P<as>.*)
                 $""",
                 re.VERBOSE,
             ),
             "compval": "set.as_path_prepend",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set as-path prepend '{{set.as_path_prepend}}'",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "as_path_prepend": "{{as}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_atomic_aggregate",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\s(?P<as>atomic-aggregate)
                 *$""",
                 re.VERBOSE,
             ),
             "compval": "set.atomic_aggregate",
             "setval": "policy route-map {{route_map}} rule {{sequence}} set atomic-aggregate",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "atomic_aggregate": "{{True if as is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_bgp_extcommunity_rt",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sbgp-extcommunity-rt\s(?P<bgp>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.bgp_extcommunity_rt",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set bgp-extcommunity-rt {{set.bgp_extcommunity_rt}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "bgp_extcommunity_rt": "{{bgp}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_comm_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<comm_list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community community-list {{set.comm_list.comm_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"community_list": "{{comm_list}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_comm_list_delete",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\sdelete(?P<delete>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scomm-list\s(?P<delete>delete)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.comm_list.comm_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set comm-list delete",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "comm_list": {"delete": "{{True if delete is defined}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_rt",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\srt\s(?P<extcommunity_rt>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\srt\s(?P<extcommunity_rt>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_rt",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity rt {{set.extcommunity_rt}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_rt": "{{extcommunity_rt}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_soo",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\ssoo\s(?P<extcommunity_soo>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\ssoo\s(?P<extcommunity_soo>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_soo",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity soo {{set.extcommunity_soo}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_soo": "{{extcommunity_soo}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_bandwidth",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\sbandwidth\s(?P<extcommunity_bw>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_bandwidth",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity bandwidth {{set.extcommunity_bandwidth}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_bandwidth": "{{extcommunity_bw}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_extcommunity_bandwidth_non_transitive",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sextcommunity\s(?P<extcommunity_bw_nt>bandwidth-non-transitive)
                 *$""",
                 re.VERBOSE,
             ),
             "compval": "set.extcommunity_bandwidth_non_transitive",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set extcommunity bandwidth-non-transitive",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "extcommunity_bandwidth_non_transitive": "{{True if extcommunity_bw_nt is defined}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_ip_next_hop",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sip-next-hop\s(?P<ip_next_hop>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.ip_next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set ip-next-hop {{set.ip_next_hop}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "ip_next_hop": "{{ip_next_hop}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_ipv6_next_hop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sipv6-next-hop
                 \s(?P<type>global|local)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.ipv6_next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set ipv6-next-hop {{set.ipv6_next_hop.ip_type}} {{set.ipv6_next_hop.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "ipv6_next_hop": {
                                             "ip_type": "{{type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_large_community",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slarge-community\s(?P<op>none|replace\s(?P<large_community>\S+))
                 $""",
                 re.VERBOSE,
             ),
             "compval": "set.large_community",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set large-community {{set.large_community if set.large_community == 'none' else 'replace ' + set.large_community}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "large_community": "{{op if op == 'none' else large_community}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_local_preference",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\slocal-preference\s(?P<local_preference>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.local_preference",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set local-preference {{set.local_preference}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "local_preference": "{{local_preference}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_metric",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric\s(?P<metric>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.metric",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set metric {{set.metric}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "metric": "{{metric}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_metric_type",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\smetric-type\s(?P<metric_type>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.metric_type",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set metric-type {{set.metric_type}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "metric_type": "{{metric_type}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_origin",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sorigin\s(?P<origin>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.origin",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set origin {{set.origin}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "origin": "{{origin}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_originator_id",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\soriginator-id\s(?P<originator_id>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.originator_id",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set originator-id {{set.originator_id}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "originator_id": "{{originator_id}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_src",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\ssrc\s(?P<src>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.src",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set src {{set.src}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "src": "{{src}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_tag",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stag\s(?P<tag>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.tag",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set tag {{set.tag}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "tag": "{{tag}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_weight",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\sweight\s(?P<weight>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.weight",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set weight {{set.weight}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "weight": "{{weight}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_table",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\stable\s(?P<table>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "set.weight",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set table {{set.table}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "table": "{{table}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "set_community",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\sset\scommunity\s(?P<op>none|replace\s(?P<value>\S+))
                 $""",
                 re.VERBOSE,
             ),
             "compval": "set.community.value",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "set community {{set.community.value if set.community.value == 'none' else 'replace ' + set.community.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "set": {
                                         "community": {
                                             "value": "{{op if op == 'none' else value}}",
                                         },
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_as_path",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sas-path\s(?P<as_path>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.as_path",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match as-path {{match.as_path}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "as_path": "{{as_path}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_community_community_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\scommunity-list\s(?P<community_list>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community community-list {{match.community.community_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"community_list": "{{community_list}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_community_exact_match",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\scommunity\sexact-match(?P<exact_match>)
                 *$""",
                 re.VERBOSE,
             ),
             "compval": "match.community.exact_match",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match community exact-match",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "community": {"exact_match": "{{True if exact_match is defined}}"},
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_extcommunity",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sextcommunity\s(?P<extcommunity>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.extcommunity",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match extcommunity {{match.extcommunity}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "extcommunity": "{{extcommunity}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_interface",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sinterface\s(?P<interface>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.interface",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match interface {{match.interface}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "interface": "{{interface}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_large_community_large_community_list",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\slarge-community\slarge-community-list\s(?P<lc>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.large_community_large_community_list",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match large-community large-community-list {{match.large_community_large_community_list}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "large_community_large_community_list": "{{lc}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_metric",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\smetric\s(?P<metric>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.metric",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match metric {{match.metric}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "metric": "{{metric}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_origin",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sorigin\s(?P<origin>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.origin",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match origin {{match.origin}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "origin": "{{origin}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_peer",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\speer\s(?P<peer>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.peer",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match peer {{match.peer}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}":
                                 {
                                     "sequence": "{{sequence}}",
                                     "match": {
                                         "peer": "{{peer}}",
                                     },
                                 },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_address",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\saddress
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.address",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip address {{match.ip.address.list_type}} {{match.ip.address.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "address": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_next_hop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\snexthop
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip nexthop {{match.ip.next_hop.list_type}} {{match.ip.next_hop.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "next_hop": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ip_route_source",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sip\sroute-source
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ip.route_source",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ip route-source {{match.ip.route_source.list_type}} {{match.ip.route_source.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ip": {
                                         "route_source": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ipv6_address",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\saddress
                 \s(?P<list_type>access-list|prefix-list)
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ipv6.address",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ipv6 address {{match.ipv6.address.list_type}} {{match.ipv6.address.value}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ipv6": {
                                         "address": {
                                             "list_type": "{{list_type}}",
                                             "value": "{{value}}",
                                         },
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_ipv6_nexthop",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sipv6\snexthop
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.ipv6.next_hop",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match ipv6 nexthop {{match.ipv6.next_hop}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "ipv6": {
                                         "next_hop": "{{value}}",
                                     },
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_protocol",
             "getval": re.compile(
                 r"""
-                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)
-                *$""",
+                ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\sprotocol\s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.protocol",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match protocol {{match.protocol}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "protocol": "{{value}}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "match_rpki",
             "getval": re.compile(
                 r"""
                 ^set\spolicy\sroute-map\s(?P<route_map>\S+)\srule\s(?P<sequence>\d+)\smatch\srpki
-                \s(?P<value>\S+)
-                *$""",
+                \s(?P<value>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "compval": "match.rpki",
             "setval": "policy route-map {{route_map}} rule {{sequence}} "
                       "match rpki {{match.rpki}}",
             "result": {
                 "route_maps": {
                     "{{ route_map }}": {
                         "route_map": '{{ route_map }}',
                         "entries": {
                             "{{sequence}}": {
                                 "sequence": "{{sequence}}",
                                 "match": {
                                     "rpki": "{{value}}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
 
     ]
     # fmt: on
diff --git a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
index 71753083..ff1c6465 100644
--- a/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
+++ b/plugins/module_utils/network/vyos/rm_templates/snmp_server.py
@@ -1,610 +1,602 @@
 # -*- coding: utf-8 -*-
 # Copyright 2022 Red Hat
 # GNU General Public License v3.0+
 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
 
 from __future__ import absolute_import, division, print_function
 
 
 __metaclass__ = type
 
 """
 The Snmp_server parser templates file. This contains
 a list of parser definitions and associated functions that
 facilitates both facts gathering and native command generation for
 the given network resource.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_snmp_server_communities(config_data):
     config_data = config_data["communities"]
     command = []
     cmd = "service snmp community {name}".format(**config_data)
     if "authorization_type" in config_data:
         auth_cmd = cmd + " authorization {authorization_type}".format(**config_data)
         command.append(auth_cmd)
     if "clients" in config_data:
         for c in config_data["clients"]:
             client_cmd = cmd + " client " + c
             command.append(client_cmd)
     if "networks" in config_data:
         for n in config_data["networks"]:
             network_command = cmd + " network " + n
             command.append(network_command)
     if not command:
         command.append(cmd)
     return command
 
 
 def _tmplt_snmp_server_trap_target(config_data):
     config_data = config_data["trap_target"]
     command = "service snmp trap-target {address}".format(**config_data)
     if "authorization_type" in config_data:
         command += " authorization {authorization_type}".format(**config_data)
     if "client" in config_data:
         command += " client {client}".format(**config_data)
     if "network" in config_data:
         command += " network {network}".format(**config_data)
     return command
 
 
 def _tmplt_snmp_server_v3_groups(config_data):
     config_data = config_data["snmp_v3"]["groups"]
     command = []
     cmd = "service snmp v3 group {group}".format(**config_data)
     if "mode" in config_data:
         mode_cmd = cmd + " mode {mode}".format(**config_data)
         command.append(mode_cmd)
     if "seclevel" in config_data:
         sec_cmd = cmd + " seclevel {seclevel}".format(**config_data)
         command.append(sec_cmd)
     if "view" in config_data:
         view_cmd = cmd + " view {view}".format(**config_data)
         command.append(view_cmd)
     return command
 
 
 def _tmplt_snmp_server_v3_trap_target(config_data):
     config_data = config_data["snmp_v3"]["trap_targets"]
     command = "service snmp v3 trap-target {address} ".format(**config_data)
     if "authentication" in config_data:
         command += " auth"
         config_data = config_data["authentication"]
     if "privacy" in config_data:
         command += " privacy"
         config_data = config_data["privacy"]
     if "type" in config_data:
         command += " type {mode}".format(**config_data)
     if "encrypted_key" in config_data:
         command += " encrypted-password {encrypted_key}".format(**config_data)
     if "plaintext_key" in config_data:
         command += " plaintext-password {plaintext_key}".format(**config_data)
     return command
 
 
 def _tmplt_snmp_server_v3_user(config_data):
     config_data = config_data["snmp_v3"]["users"]
     command = []
     cmd = "service snmp v3 user {user}".format(**config_data)
     for k in ["authentication", "privacy"]:
         if config_data.get(k):
             config = config_data[k]
             if k == "authentication":
                 val = " auth"
             else:
                 val = " privacy"
             if "type" in config:
                 type_cmd = cmd + val + " type {type}".format(**config)
                 command.append(type_cmd)
             if "encrypted_key" in config:
                 enc_cmd = cmd + val + " encrypted-password {encrypted_key}".format(**config)
                 command.append(enc_cmd)
             if "plaintext_key" in config:
                 plain_cmd = cmd + val + " plaintext-password {plaintext_key}".format(**config)
                 command.append(plain_cmd)
     return command
 
 
 def _tmplt_snmp_server_v3_views(config_data):
     config_data = config_data["snmp_v3"]["views"]
     command = "service snmp v3 view {view} oid {oid}".format(**config_data)
     if "exclude" in config_data:
         command += " exclude {exclude}".format(**config_data)
     if "mask" in config_data:
         command += " mask {mask}".format(**config_data)
     return command
 
 
 class Snmp_serverTemplate(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(Snmp_serverTemplate, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         # service snmp community <>
         {
             "name": "communities",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\scommunity
                 \s+(?P<name>\S+)
-                \s*(?P<auth>authorization\srw|authorization\sro)*
-                \s*(client\s(?P<client>\S+))*
-                \s*(network\s(?P<network>\S+))*
+                \s*(?P<auth>authorization\srw|authorization\sro)?
+                \s*(client\s(?P<client>\S+))?
+                \s*(network\s(?P<network>\S+))?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_communities,
             "result": {
                 "communities": {
                     "{{ name }}": {
                         "name": "{{ name }}",
                         "clients": ['{{ client if client is defined else "None" }}'],
                         "networks": ['{{ network if network is defined else "None" }}'],
                         "authorization_type": '{{ auth.split(" ")[1] if auth is defined else None }}',
                     },
                 },
             },
         },
         # service snmp contact <>
         {
             "name": "contact",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\scontact
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "service snmp contact {{ contact }}",
             "result": {
                 "contact": "{{ name }}",
             },
         },
         # service snmp description <>
         {
             "name": "description",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sdescription
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "service snmp description {{ description }}",
             "result": {
                 "description": "{{ name }}",
             },
         },
         # service snmp listen-address <> port <>
         {
             "name": "listen_addresses",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\slisten-address
                 \s+(?P<addr>\S+)
-                \s*(port)*
-                \s*(?P<port>\d+)*
+                \s*(port)?
+                \s*(?P<port>\d+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp listen-address {{ listen_addresses.address }}"
                       "{{ (' port ' + listen_addresses.port|string) if listen_addresses.port is defined else '' }}",
             "result": {
                 "listen_addresses": {
                     "{{ addr }}": {
                         "address": "{{ addr }}",
                         "port": "{{ port }}",
                     },
                 },
             },
         },
         # service snmp location <>
         {
             "name": "location",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\slocation
                 \s(?P<name>.*)
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp location {{ '\\'' + location + '\\''}}",
             "result": {
                 "location": "{{ name }}",
             },
         },
         # service snmp smux-peer <>
         {
             "name": "smux_peer",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\ssmux-peer
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "service snmp smux-peer {{ smux_peer }}",
             "result": {
                 "smux_peer": "{{ name }}",
             },
         },
         # service snmp trap-source <>
         {
             "name": "trap_source",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\strap-source
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "service snmp trap-source {{ trap_source }}",
             "result": {
                 "trap_source": "{{ name }}",
             },
         },
         # service snmp trap-target <>
         {
             "name": "trap_target",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\strap-target
                 \s+(?P<name>\S+)
-                \s*(?P<comm>community\s\S+)*
-                \s*(?P<port>port\s\d+)*
-                $""",
+                \s*(?P<comm>community\s\S+)?
+                \s*(?P<port>port\s\d+)?                $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_trap_target,
             "result": {
                 "trap_target": {
                     "address": "{{ name }}",
                     "community": "{{ comm.split(" ")[1] if comm is defined else None }}",
                     "port": "{{ port.split(" ")[1] if port is defined else None }}",
                 },
             },
         },
         # service snmp v3 engineid <>
         {
             "name": "snmp_v3.engine_id",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\sengineid
-                \s+(?P<name>\S+)
-                *$""",
+                \s+(?P<name>\S+)\s*$""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 engineid {{ snmp_v3.engine_id }}",
             "result": {
                 "snmp_v3": {
                     "engine_id": "{{ name }}",
                 },
             },
         },
         # service snmp v3 group <>
         {
             "name": "snmp_v3.groups",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\sgroup
                 \s+(?P<name>\S+)
-                \s*(?P<mode>mode\s\S+)*
-                \s*(?P<sec>seclevel\s\S+)*
-                \s*(?P<view>view\s\S+)*
+                \s*(?P<mode>mode\s\S+)?
+                \s*(?P<sec>seclevel\s\S+)?
+                \s*(?P<view>view\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_groups,
             "result": {
                 "snmp_v3": {
                     "groups": {
                         "{{ name }}": {
                             "group": "{{ name }}",
                             "mode": '{{ mode.split(" ")[1] if mode is defined else None }}',
                             "seclevel": '{{ sec.split(" ")[1] if sec is defined else None }}',
                             "view": '{{ view.split(" ")[1] if view is defined else None }}',
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> auth <>
         {
             "name": "snmp_v3.trap_targets.authentication",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
                 \s+auth
-                \s*(?P<enc>encrypted-password\s\S+)*
-                \s*(?P<plain>plaintext-password\s\S+)*
-                \s*(?P<type>type\s\S+)*
+                \s*(?P<enc>encrypted-password\s\S+)?
+                \s*(?P<plain>plaintext-password\s\S+)?
+                \s*(?P<type>type\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_trap_target,
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "authentication": {
                                 "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
                                 "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
                                 "type": '{{ type.split(" ")[1] if type is defined else None }}',
                             },
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> port <>
         {
             "name": "snmp_v3.trap_targets.port",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
-                \s+(?P<port>port\s\d+)*
-                $""",
+                \s+(?P<port>port\s\d+)?                $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 trap-target port {{ snmp_v3.trap_targets.port }}",
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "port": "{{ port }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> protocol <>
         {
             "name": "snmp_v3.trap_targets.protocol",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
-                \s+(?P<protocol>protocol\s\S+)*
+                \s+(?P<protocol>protocol\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 trap-target protocol {{ snmp_v3.trap_targets.protocol }}",
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "protocol": "{{ protocol }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> type <>
         {
             "name": "snmp_v3.trap_targets.type",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
-                \s+(?P<type>type\s\S+)*
+                \s+(?P<type>type\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 trap-target type {{ snmp_v3.trap_targets.type }}",
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "type": "{{ type }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> user <>
         {
             "name": "snmp_v3.trap_targets.user",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
-                \s+(?P<user>user\s\S+)*
+                \s+(?P<user>user\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 trap-target user {{ snmp_v3.trap_targets.user }}",
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "user": "{{ user }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3 trap-target <> privacy <>
         {
             "name": "snmp_v3.trap_targets.privacy",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\strap-target
                 \s+(?P<name>\S+)
                 \s+privacy
-                \s*(?P<enc>encrypted-password\s\S+)*
-                \s*(?P<plain>plaintext-password\s\S+)*
-                \s*(?P<type>type\s\S+)*
+                \s*(?P<enc>encrypted-password\s\S+)?
+                \s*(?P<plain>plaintext-password\s\S+)?
+                \s*(?P<type>type\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_trap_target,
             "result": {
                 "snmp_v3": {
                     "trap_targets": {
                         "{{ name }}": {
                             "address": "{{ name }}",
                             "privacy": {
                                 "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
                                 "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
                                 "type": '{{ type.split(" ")[1] if type is defined else None }}',
                             },
                         },
                     },
                 },
             },
         },
         # service snmp v3 user <> auth <>
         {
             "name": "snmp_v3.users.authentication",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\suser
                 \s+(?P<name>\S+)
                 \s+auth
-                \s*(?P<enc>encrypted-password\s\S+)*
-                \s*(?P<plain>plaintext-password\s\S+)*
-                \s*(?P<type>type\s\S+)*
+                \s*(?P<enc>encrypted-password\s\S+)?
+                \s*(?P<plain>plaintext-password\s\S+)?
+                \s*(?P<type>type\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_user,
             "result": {
                 "snmp_v3": {
                     "users": {
                         "{{ name }}": {
                             "user": "{{ name }}",
                             "authentication": {
                                 "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
                                 "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
                                 "type": '{{ type.split(" ")[1] if type is defined else None }}',
                             },
                         },
                     },
                 },
             },
         },
         # service snmp v3 user <> privacy <>
         {
             "name": "snmp_v3.users.privacy",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\suser
                 \s+(?P<name>\S+)
                 \s+privacy
-                \s*(?P<enc>encrypted-password\s\S+)*
-                \s*(?P<plain>plaintext-password\s\S+)*
-                \s*(?P<type>type\s\S+)*
+                \s*(?P<enc>encrypted-password\s\S+)?
+                \s*(?P<plain>plaintext-password\s\S+)?
+                \s*(?P<type>type\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_user,
             "result": {
                 "snmp_v3": {
                     "users": {
                         "{{ name }}": {
                             "user": "{{ name }}",
                             "privacy": {
                                 "encrypted_key": '{{ enc.split(" ")[1] if enc is defined else None }}',
                                 "plaintext_key": '{{ plain.split(" ")[1] if plain is defined else None }}',
                                 "type": '{{ type.split(" ")[1] if type is defined else None }}',
                             },
                         },
                     },
                 },
             },
         },
         # service snmp v3 user <> group <>
         {
             "name": "snmp_v3.users.group",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\suser
                 \s+(?P<name>\S+)
-                \s+(?P<group>group\s.+)*
-                $""",
+                \s+(?P<group>group\s.+)?                $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 user {{ snmp_v3.users.user }} group {{ snmp_v3.users.group }}",
             "result": {
                 "snmp_v3": {
                     "users": {
                         "{{ name }}": {
                             "user": "{{ name }}",
                             "group": "{{ group.split(" ")[1] if group is defined else None }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3  user <> mode <>
         {
             "name": "snmp_v3.users.mode",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\suser
                 \s+(?P<name>\S+)
-                \s+(?P<mode>mode\s\S+)*
+                \s+(?P<mode>mode\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": "service snmp v3 user {{ snmp_v3.users.user }} mode {{ snmp_v3.users.mode }}",
             "result": {
                 "snmp_v3": {
                     "users": {
                         "{{ name }}": {
                             "user": "{{ name }}",
                             "mode": "{{ mode }}",
                         },
                     },
                 },
             },
         },
         # service snmp v3 view <>
         {
             "name": "snmp_v3.views",
             "getval": re.compile(
                 r"""
                 ^set\sservice\ssnmp\sv3\sview
                 \s+(?P<name>\S+)
                 \s+(?P<oid>oid\s\S+)
-                \s*(?P<ex>exclude\s\S+)*
-                \s*(?P<mask>mask\s\S+)*
+                \s*(?P<ex>exclude\s\S+)?
+                \s*(?P<mask>mask\s\S+)?
                 $""",
                 re.VERBOSE,
             ),
             "setval": _tmplt_snmp_server_v3_views,
             "result": {
                 "snmp_v3": {
                     "views": {
                         "{{ name }}": {
                             "view": "{{ name }}",
                             "oid": '{{ oid.split(" ")[1] if oid is defined else None }}',
                             "exclude": '{{ ex.split(" ")[1] if ex is defined else None }}',
                             "mask": '{{ mask.split(" ")[1] if mask is defined else None }}',
                         },
                     },
                 },
             },
         },
     ]
     # fmt: on
diff --git a/tests/unit/modules/network/vyos/test_rm_templates_perf.py b/tests/unit/modules/network/vyos/test_rm_templates_perf.py
new file mode 100644
index 00000000..d2060f46
--- /dev/null
+++ b/tests/unit/modules/network/vyos/test_rm_templates_perf.py
@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# Copyright 2026 Red Hat
+# GNU General Public License v3.0+
+# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""Performance budget tests for rm_templates parsers.
+
+These tests guard against re-introducing catastrophic regex backtracking
+in the rm_template parsers (T8609).  Pre-fix, parse() over realistic
+device-output input could take 50+ seconds because of `(group)*`
+quantifiers on groups containing `\\S+`.  Post-fix, the same input
+parses in single-digit milliseconds.
+
+A 1-second budget is comfortably above post-fix runtime and well below
+the pre-regression cliff, so the test fails sharply if the bug returns.
+"""
+
+from __future__ import absolute_import, division, print_function
+
+
+__metaclass__ = type
+
+import time
+
+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.bgp_address_family_14 import (
+    Bgp_address_familyTemplate14,
+)
+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.bgp_global_14 import (
+    Bgp_globalTemplate14,
+)
+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.route_maps_14 import (
+    Route_mapsTemplate14,
+)
+from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.snmp_server import (
+    Snmp_serverTemplate,
+)
+
+
+PARSE_BUDGET_SECONDS = 1.0
+
+
+def _time_parse(parser_class, lines):
+    """Time a single ``parse()`` call against ``lines``; returns elapsed seconds."""
+    parser = parser_class(lines=lines)
+    t0 = time.perf_counter()
+    parser.parse()
+    return time.perf_counter() - t0
+
+
+def test_route_maps_14_parse_budget():
+    """Realistic route-map config: parse() must finish under 1s.
+
+    Pre-T8609: ~50s.  Post-fix: <50ms.  Inputs use 20+ char names
+    because the backtracking is exponential in the first \\S+ run
+    after the prefix.
+    """
+    lines = [
+        "set policy route-map ADVERTISE-ANYCAST-v6 rule 10 action 'permit'",
+        "set policy route-map ADVERTISE-ANYCAST-v6 rule 10 match ipv6 address prefix-list 'ANYCAST-AGGREGATE-v6'",
+        "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 action 'permit'",
+        "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 match ipv6 address prefix-list 'AS64496-SENTINEL-v6'",
+        "set policy route-map DEFAULT-ORIGINATE-SENTINEL-v6 rule 10 set local-preference '120'",
+        "set policy route-map IXP-PEER-INGRESS-v4 rule 10 action 'permit'",
+        "set policy route-map IXP-PEER-INGRESS-v4 rule 10 match ip address prefix-list 'IXP-INBOUND-v4'",
+        "set policy route-map IXP-PEER-INGRESS-v4 rule 10 set community 'additive 65000:100'",
+        "set policy route-map TRANSIT-EGRESS-v4 rule 100 action 'permit'",
+        "set policy route-map TRANSIT-EGRESS-v4 rule 100 match ip address prefix-list 'CUSTOMER-PREFIXES-v4'",
+        "set policy route-map TRANSIT-EGRESS-v4 rule 100 set as-path prepend '65000 65000'",
+        "set policy route-map UPSTREAM-INGRESS-v4 rule 10 action 'permit'",
+    ]
+    elapsed = _time_parse(Route_mapsTemplate14, lines)
+    assert elapsed < PARSE_BUDGET_SECONDS, (
+        "Route_mapsTemplate14.parse() took %.2fs (budget %.2fs); "
+        "possible regression of T8609 (rm_templates regex backtracking)."
+        % (elapsed, PARSE_BUDGET_SECONDS)
+    )
+
+
+def test_bgp_global_14_parse_budget():
+    """Realistic BGP neighbor/address-family config: parse() under 1s."""
+    lines = [
+        "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 remote-as '65002'",
+        "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 description 'IXP-PEER-1'",
+        "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 address-family ipv6-unicast route-map import 'IXP-INGRESS-v6'",
+        "set protocols bgp 65001 neighbor 2001:db8:abcd:1234::1 address-family ipv6-unicast route-map export 'IXP-EGRESS-v6'",
+        "set protocols bgp 65001 neighbor 192.0.2.1 remote-as '65003'",
+        "set protocols bgp 65001 neighbor 192.0.2.1 description 'TRANSIT-PROVIDER-1'",
+        "set protocols bgp 65001 neighbor 192.0.2.1 address-family ipv4-unicast route-map import 'TRANSIT-INGRESS-v4'",
+        "set protocols bgp 65001 neighbor 192.0.2.1 address-family ipv4-unicast route-map export 'TRANSIT-EGRESS-v4'",
+    ]
+    elapsed = _time_parse(Bgp_globalTemplate14, lines)
+    assert elapsed < PARSE_BUDGET_SECONDS, (
+        "Bgp_globalTemplate14.parse() took %.2fs (budget %.2fs); "
+        "possible regression of T8609 (rm_templates regex backtracking)."
+        % (elapsed, PARSE_BUDGET_SECONDS)
+    )
+
+
+def test_snmp_server_parse_budget():
+    """Realistic SNMP v3 config: parse() under 1s."""
+    lines = [
+        "set service snmp community PUBLIC-COMMUNITY-NAME-1 authorization 'ro'",
+        "set service snmp community PUBLIC-COMMUNITY-NAME-1 client '192.0.2.0/24'",
+        "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 user 'monitor'",
+        "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 protocol 'udp'",
+        "set service snmp v3 trap-target TRAP-TARGET-LONG-NAME-1 port '162'",
+        "set service snmp v3 user TRAP-USER-LONG-NAME-1 mode 'auth'",
+        "set service snmp v3 user TRAP-USER-LONG-NAME-1 group 'monitor'",
+    ]
+    elapsed = _time_parse(Snmp_serverTemplate, lines)
+    assert elapsed < PARSE_BUDGET_SECONDS, (
+        "Snmp_serverTemplate.parse() took %.2fs (budget %.2fs); "
+        "possible regression of T8609 (rm_templates regex backtracking)."
+        % (elapsed, PARSE_BUDGET_SECONDS)
+    )
+
+
+def test_bgp_address_family_14_parse_budget():
+    """Realistic BGP address-family aggregate config: parse() under 1s."""
+    lines = [
+        "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 backdoor",
+        "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 path-limit '4'",
+        "set protocols bgp 65001 address-family ipv4-unicast network 198.51.100.0/24 route-map 'NET-IN-v4'",
+        "set protocols bgp 65001 address-family ipv4-unicast aggregate-address 203.0.113.0/24 as-set",
+        "set protocols bgp 65001 address-family ipv4-unicast aggregate-address 203.0.113.0/24 summary-only",
+        "set protocols bgp 65001 address-family ipv6-unicast network 2001:db8:abcd:1234::/64 backdoor",
+        "set protocols bgp 65001 address-family ipv6-unicast network 2001:db8:abcd:1234::/64 route-map 'NET-IN-v6'",
+        "set protocols bgp 65001 address-family ipv6-unicast aggregate-address 2001:db8::/32 as-set",
+        "set protocols bgp 65001 address-family ipv6-unicast aggregate-address 2001:db8::/32 summary-only",
+    ]
+    elapsed = _time_parse(Bgp_address_familyTemplate14, lines)
+    assert elapsed < PARSE_BUDGET_SECONDS, (
+        "Bgp_address_familyTemplate14.parse() took %.2fs (budget %.2fs); "
+        "possible regression of T8609 (rm_templates regex backtracking)."
+        % (elapsed, PARSE_BUDGET_SECONDS)
+    )
+
+
+def test_route_maps_14_set_comm_list_delete_matches_setval():
+    """Round-trip check: the `set_comm_list_delete` parser must match the line its setval generates.
+
+    `set_comm_list_delete`'s setval emits `set policy route-map X rule N set
+    comm-list delete` with no token after `delete`.  Pre-T8609 the getval
+    happened to match this by accident (a `*` quantifier on the trailing
+    `(?P<delete>\\S+)` made the group optional after VERBOSE-strip).  An
+    earlier draft of T8609's fix made the group required, causing the
+    parser to silently ignore its own output.  This test guards the
+    round-trip.
+    """
+    line = "set policy route-map MY-MAP rule 10 set comm-list delete"
+    parser = Route_mapsTemplate14(lines=[line])
+    result = parser.parse()
+    rm = result.get("route_maps", {}).get("MY-MAP")
+    assert rm is not None, (
+        "route_maps_14: set_comm_list_delete parser failed to match its "
+        "own setval-generated line %r; the parser is broken." % line
+    )
+    entry = rm.get("entries", {}).get(10, {})
+    comm_list = entry.get("set", {}).get("comm_list", {})
+    assert comm_list.get("delete"), (
+        "route_maps_14: set_comm_list_delete matched the line but did not "
+        "populate set.comm_list.delete; check the result template."
+    )