diff --git a/plugins/module_utils/network/vyos/config/vrrp/vrrp.py b/plugins/module_utils/network/vyos/config/vrrp/vrrp.py
index 12c865e9..fc61ebb2 100644
--- a/plugins/module_utils/network/vyos/config/vrrp/vrrp.py
+++ b/plugins/module_utils/network/vyos/config/vrrp/vrrp.py
@@ -1,214 +1,214 @@
 #
 # -*- 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 vyos_vrrp config file.
 It is in this file where the current configuration (as dict)
 is compared to the provided configuration (as dict) and the command set
 necessary to bring the current configuration to its desired end-state is
 created.
 """
 
 from copy import deepcopy
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.resource_module import (
     ResourceModule,
 )
 
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.facts.facts import Facts
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.vrrp import (
     VrrpTemplate,
 )
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.utils import combine
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.utils.version import (
     LooseVersion,
 )
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.vyos import get_os_version
 
 
 # from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.utils import (
 #     dict_merge,
 # )
 
 
 class Vrrp(ResourceModule):
     """
     The vyos_vrrp config class
     """
 
     def __init__(self, module):
         super(Vrrp, self).__init__(
             empty_fact_val={},
             facts_module=Facts(module),
             module=module,
             resource="vrrp",
             tmplt=VrrpTemplate(),
         )
         self.parsers = [
             "disable",
         ]
 
     def _validate_template(self):
         version = get_os_version(self._module)
         if LooseVersion(version) >= LooseVersion("1.4"):
             self._tmplt = VrrpTemplate()
         else:
             self._module.fail_json(msg="VRRP is not supported in this version of VyOS")
 
     def parse(self):
         """override parse to check template"""
         self._validate_template()
         return super().parse()
 
     def get_parser(self, name):
         """get_parsers"""
         self._validate_template()
         return super().get_parser(name)
 
     def execute_module(self):
         """Execute the module
 
         :rtype: A dictionary
         :returns: The result from module execution
         """
         if self.state not in ["parsed", "gathered"]:
             self.generate_commands()
             self.run_commands()
 
         return self.result
 
     def generate_commands(self):
         """Generate configuration commands to send based on
         want, have and desired state.
         """
         wantd = {}
         haved = {}
         wantd = deepcopy(self.want)
         haved = deepcopy(self.have)
 
         # self._module.fail_json(msg="WanT: " + str(self.want) + "========== H:  " + str(self.have))
 
         # if state is merged, merge want onto have and then compare
         if self.state in ["merged"]:
             wantd = combine(haved, wantd, recursive=True)
-            self._module.fail_json(msg="Want: " + str(wantd) + "**** H:  " + str(haved))
+            # self._module.fail_json(msg="Want: " + str(wantd) + "**** H:  " + str(haved))
 
         # if state is deleted, delete and empty out wantd
         # if self.state == "deleted":
         #     w = deepcopy(wantd)
         #     if w == {} and haved != {}:
         #         self.commands = ["delete vrrp"]
         #         return
         #     for k, want in w.items():
         #         if not (k in haved and haved[k]):
         #             del wantd[k]
         #         else:
         #             if isinstance(want, list):
         #                 for entry in want:
         #                     wname = entry.get("name")
         #                     haved["instances"] = [
         #                         i for i in haved.get("instances", []) if i.get("name") != wname
         #                     ]
         #                     self.commands.append("delete vrrp name {}".format(wname))
         #             else:
         #                 self.commands.append("delete vrrp {}".format(k.replace("_", "-")))
         #                 del wantd[k]
         #
         # if self.state == "overridden":
         #     w = deepcopy(wantd)
         #     h = deepcopy(haved)
         #     for k, want in w.items():
         #         if k in haved anzd haved[k] != want:
         #             if isinstance(want, list):
         #                 for entry in want:
         #                     wname = entry.get("name")
         #                     hdict = next(
         #                         (inst for inst in haved["instances"] if inst["name"] == wname),
         #                         None,
         #                     )
         #                     if entry != hdict:
         #                         # self._module.fail_json(msg="Want: " + str(entry) + "**** H:  " + str(hdict))
         #                         haved["instances"] = [
         #                             i for i in haved.get("instances", []) if i.get("name") != wname
         #                         ]
         #                         self.commands.append("delete vrrp name {}".format(wname))
         #                         self.commands.append("commit")
         #
         for k, want in wantd.items():
             if k == "vrrp":
                 self._compare_vrrp(want, haved.get(k, {}))
             # self._module.fail_json(msg=k)
             # if isinstance(want, list):
             # self._module.fail_json(msg=str(want) + " +++ " + str(haved.pop(k, {})))
             self.compare(
                 parsers=self.parsers,
                 want={k: want},
                 have={k: haved.pop(k, {})},
             )
         self._module.fail_json(msg=self.commands)
 
     # def _compare_vsrvs(self, want, have):
     #     """Compare virtual servers of VRRP.py"""
     #     parsers = [
     #         "virtual_servers",
     #         "virtual_servers.real_servers",
     #     ]
     #     # self._module.fail_json(msg="want: " + str(want) + "**** have:  " + str(have))
     #
     #     # for entry in want:
     #     #     h = {}
     #     #     wname = entry.get("name")
     #     #     # h = next((vrrp for vrrp in have if vrrp["name"] == wname), {})
     #     #     h = {
     #     #         k: v
     #     #         for vrrp in have
     #     #         if vrrp.get("name") == wname
     #     #         for k, v in vrrp.items()
     #     #         if k != "address_family"
     #     #     }
     #         self.compare(parsers=parsers, want=entry, have=h)
     #
     # if "address_family" in entry:
     #     wafi = {"name": wname, "address_family": entry.get("address_family", [])}
     #     # hdict = next((item for item in have if item["name"] == wname), None)
     #     hdict = next((d for d in have if d.get("name") == wname), None)
     #
     #     hafi = {
     #         "name": (hdict or {"name": wname})["name"],
     #         "address_family": hdict.get("address_family", []) if hdict else [],
     #     }
 
     # self._module.fail_json(msg="wafi: " + str(wafi) + "**** hafi:  " + str(hafi))
 
     def _compare_vrrp(self, want, have):
         """Compare the instances of VRRP"""
         vrrp_parsers = [
             "vrrp.snmp",
             "vrrp.sync_groups.member",
             # "vrrp.sync_groups.health_check",
             # "vrrp.sync_groups.transition_script",
             "vrrp.global_parameters.garp",
             "vrrp.global_parameters",
             # "version",
             # "vrrp.group",
             # "vrrp.group.aunthentication",
             # "vrrp.group.garp",
             # "vrrp.group.transition_script",
             # "vrrp.group.health_check",
             # "vrrp.group.track",
             # "vrrp.group.transition_script",
         ]
         # self._module.fail_json(msg="wvrrp: " + str(want) + "**** hvrrp:  " + str(have))
 
-        self._module.fail_json(msg="want: " + str(want) + "**** have:  " + str(have))
+        # self._module.fail_json(msg="want: " + str(want) + "**** have:  " + str(have))
 
         self.compare(parsers=vrrp_parsers, want={"vrrp": want}, have={"vrrp": have})
diff --git a/plugins/module_utils/network/vyos/facts/vrrp/vrrp.py b/plugins/module_utils/network/vyos/facts/vrrp/vrrp.py
index 2a2be2da..23f6e1dc 100644
--- a/plugins/module_utils/network/vyos/facts/vrrp/vrrp.py
+++ b/plugins/module_utils/network/vyos/facts/vrrp/vrrp.py
@@ -1,151 +1,150 @@
 # -*- 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 vyos vrrp fact class
 It is in this file the configuration is collected from the device
 for a given resource, parsed, and the facts tree is populated
 based on the configuration.
 """
 
 import re
 
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common import utils
 
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.argspec.vrrp.vrrp import (
     VrrpArgs,
 )
 from ansible_collections.vyos.vyos.plugins.module_utils.network.vyos.rm_templates.vrrp import (
     VrrpTemplate,
 )
 
 
 class VrrpFacts(object):
     """The vyos vrrp facts class"""
 
     def __init__(self, module, subspec="config", options="options"):
         self._module = module
         self.argument_spec = VrrpArgs.argument_spec
 
     def get_device_data(self, connection):
         return connection.get('show configuration commands |  match "set high-availability"')
 
     def get_config_set(self, data, connection):
         """To classify the configurations beased on vrrp"""
         config_dict = {}
         for config_line in data.splitlines():
             vrrp_grp = re.search(r"set high-availability vrrp group (\S+).*", config_line)
             vrrp_gp = re.search(
                 r"set high-availability vrrp global-parameters (\S+).*",
                 config_line,
             )
             vrrp_sg = re.search(r"set high-availability vrrp sync-group (\S+).*", config_line)
             vrrp_vsrv = re.search(r"set high-availability virtual-server (\S+).*", config_line)
             vrrp_disable = re.search(r"set high-availability disable", config_line)
             vrrp_snmp = re.search(r"set high-availability vrrp snmp", config_line)
             if vrrp_disable:
                 config_dict["disable"] = config_dict.get("disable", "") + config_line + "\n"
             if vrrp_gp:
-                config_dict["global_parameters"] = (
-                    config_dict.get(vrrp_gp.group(1), "") + config_line + "\n"
-                )
+                # config_dict["global_parameters"] = (
+                #     config_dict.get(vrrp_gp.group(1), "") + config_line + "\n"
+                # )
+                config_dict.setdefault("global_parameters", []).append(config_line)
             if vrrp_vsrv:
                 config_dict[vrrp_vsrv.group(1)] = (
                     config_dict.get(vrrp_vsrv.group(1), "") + config_line + "\n"
                 )
             if vrrp_sg:
                 config_dict[vrrp_sg.group(1)] = (
                     config_dict.get(vrrp_sg.group(1), "") + config_line + "\n"
                 )
             if vrrp_grp:
                 config_dict[vrrp_grp.group(1)] = (
                     config_dict.get(vrrp_grp.group(1), "") + config_line + "\n"
                 )
         return list(config_dict.values())
 
     def deep_merge(self, dest, src):
         for key, value in src.items():
             if key in dest and isinstance(dest[key], dict) and isinstance(value, dict):
                 self.deep_merge(dest[key], value)
             else:
                 dest[key] = value
         return dest
 
     def populate_facts(self, connection, ansible_facts, data=None):
         """Populate the facts for vrrp network resource
 
         :param connection: the device connection
         :param ansible_facts: Facts dictionary
         :param data: previously collected conf
 
         :rtype: dictionary
         :returns: facts
         """
         facts = {}
         objs = {}
         config_lines = []
 
         if not data:
             data = self.get_device_data(connection)
         resources = self.get_config_set(data, connection)
-        self._module.fail_json(msg=str(resources))
         vrrp_facts = {"disable": False, "virtual_servers": {}, "vrrp": {}}
         for resource in resources:
             vrrp_parser = VrrpTemplate(
-                lines=resource.split("\n"),
+                lines=resource,
                 module=self._module,
             )
             objs = vrrp_parser.parse()
             if "disable" in objs:
                 vrrp_facts["disable"] = objs["disable"]
             for section in ("virtual_servers", "vrrp"):
                 if section in objs:
-                    self._module.fail_json(msg=str(objs[section]))
                     for name, data in objs[section].items():
                         existing = vrrp_facts[section].get(name, {})
                         vrrp_facts[section][name] = self.deep_merge(existing, data)
         ansible_facts["ansible_network_resources"].pop("vrrp", None)
         #
         vrrp_facts = self.normalize_config(vrrp_facts)
         #
         validate_parser = VrrpTemplate(lines=[], module=self._module)
         params = utils.remove_empties(
             validate_parser.validate_config(
                 self.argument_spec,
                 {"config": vrrp_facts},
                 redact=True,
             ),
         )
 
         facts["vrrp"] = params.get("config", [])
         ansible_facts["ansible_network_resources"].update(facts)
         return ansible_facts
 
     def normalize_config(self, config):
         if not config:
             return config
 
         # Normalize virtual_servers
         if isinstance(config.get("virtual_servers"), dict):
             config["virtual_servers"] = list(config["virtual_servers"].values())
 
         # Normalize vrrp
         vrrp = config.get("vrrp", {})
         if isinstance(vrrp.get("groups"), dict):
             vrrp["groups"] = list(vrrp["groups"].values())
         if isinstance(vrrp.get("sync_groups"), dict):
             vrrp["sync_groups"] = list(vrrp["sync_groups"].values())
 
         # Normalize real_server inside each virtual_server
         for vs in config.get("virtual_servers", []):
             if isinstance(vs.get("real_servers"), dict):
                 vs["real_servers"] = list(vs["real_servers"].values())
 
         return config
diff --git a/plugins/module_utils/network/vyos/rm_templates/vrrp.py b/plugins/module_utils/network/vyos/rm_templates/vrrp.py
index 6ec9909b..543bdc5d 100644
--- a/plugins/module_utils/network/vyos/rm_templates/vrrp.py
+++ b/plugins/module_utils/network/vyos/rm_templates/vrrp.py
@@ -1,763 +1,761 @@
 # -*- 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.module_utils.six import iteritems
 from ansible_collections.ansible.netcommon.plugins.module_utils.network.common.rm_base.network_template import (
     NetworkTemplate,
 )
 
 
 def _tmplt_vsrvs(config_data):
     config_data = config_data["virtual-server"]
     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_vsrvs_rsrv(config_data):
     config_data = config_data["virtual-server"]["real_servers"]
     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_sgroup_hc(config_data):
     config_data = config_data["sync-group"]["health-check"]
     command = []
     cmd = "high-availability vrrp sync-group health-check {health_check}".format(**config_data)
     if "failure_count" in config_data:
         failure_count_cmd = cmd + " failure-count {failure_count}".format(**config_data)
         command.append(failure_count_cmd)
     if "interval" in config_data:
         interval_cmd = cmd + " interval {interval}".format(**config_data)
         command.append(interval_cmd)
     if "ping" in config_data:
         ping_cmd = cmd + " ping {ping}".format(**config_data)
         command.append(ping_cmd)
     if "script" in config_data:
         script_cmd = cmd + " script {script}".format(**config_data)
         command.append(script_cmd)
     return command
 
 
 def _tmplt_sgroup_ts(config_data):
     config_data = config_data["sync-group"]["transition-script"]
     command = []
     cmd = "high-availability vrrp sync-group transition-script {transition_script}".format(
         **config_data,
     )
     if "backup" in config_data:
         backup_cmd = cmd + " backup {backup}".format(**config_data)
         command.append(backup_cmd)
     if "fault" in config_data:
         fault_cmd = cmd + " fault {fault}".format(**config_data)
         command.append(fault_cmd)
     if "master" in config_data:
         master_cmd = cmd + " master {master}".format(**config_data)
         command.append(master_cmd)
     if "stop" in config_data:
         stop_cmd = cmd + " stop {stop}".format(**config_data)
         command.append(stop_cmd)
     return command
 
 
 def _tmplt_vrrp_gp(config_data):
     config_data = config_data["vrrp"]["global_parameters"]
     command = []
     cmd = "high-availability vrrp global-parameters"
     if "version" in config_data:
         version_cmd = cmd + " version {version}".format(**config_data)
         command.append(version_cmd)
     if "startup_delay" in config_data:
         startup_delay_cmd = cmd + " startup-delay {startup_delay}".format(**config_data)
         command.append(startup_delay_cmd)
     return command
 
 
 def _tmplt_vrrp_gp_garp(config_data):
     config_data = config_data["vrrp"]["global_parameters"]["garp"]
     command = []
-    cmd = "high-availability vrrp global-parameters garp {garp}".format(**config_data)
+    cmd = "high-availability vrrp global-parameters garp"
     if "interval" in config_data:
         interval_cmd = cmd + " interval {interval}".format(**config_data)
         command.append(interval_cmd)
     if "master_delay" in config_data:
         master_delay_cmd = cmd + " master-delay {master_delay}".format(**config_data)
         command.append(master_delay_cmd)
     if "master_refresh" in config_data:
         master_refresh_cmd = cmd + " master-refresh {master_refresh}".format(**config_data)
         command.append(master_refresh_cmd)
     if "master_refresh_repeat" in config_data:
         master_refresh_repeat_cmd = cmd + " master-refresh-repeat {master_refresh_repeat}".format(
             **config_data,
         )
         command.append(master_refresh_repeat_cmd)
     if "master_repeat" in config_data:
         master_repeat_cmd = cmd + " master-repeat {master_repeat}".format(**config_data)
         command.append(master_repeat_cmd)
     return command
 
 
 def _tmplt_vrrp_group(config_data):
     config_data = config_data["vrrp"]["group"]
     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_vrrp_group_track(config_data):
     config_data = config_data["vrrp"]["group"]["track"]
     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_vrrp_group_hc(config_data):
     config_data = config_data["vrrp"]["group"]["health-check"]
     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_vrrp_group_ts(config_data):
     config_data = config_data["vrrp"]["group"]["transcription-script"]
     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_vrrp_group_garp(config_data):
     config_data = config_data["vrrp"]["group"]["garp"]
     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_vrrp_group_auth(config_data):
     config_data = config_data["vrrp"]["group"]["authentication"]
     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
 
 
 class VrrpTemplate(NetworkTemplate):
     def __init__(self, lines=None, module=None):
         prefix = {"set": "set", "remove": "delete"}
         super(VrrpTemplate, self).__init__(
             lines=lines,
             tmplt=self,
             prefix=prefix,
             module=module,
         )
 
     # fmt: off
     PARSERS = [
         {
             "name": "disable",
             "getval": re.compile(
                 r"""
                 ^set
                 \shigh-availability
                 \s(?P<disable>disable)
                 $""",
                 re.VERBOSE,
             ),
             "setval": "high-availability disable",
             "result": {
                 "disable": "{{ True if disable is defined }}",
             },
         },
         {
             "name": "virtual_servers",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svirtual-server
                 \s+(?P<alias>\S+)
                 (?:\s+address\s+(?P<address>\S+))?
                 (?:\s+algorithm\s+(?P<algorithm>\S+))?
                 (?:\s+delay-loop\s+(?P<delay_loop>\S+))?
                 (?:\s+forward-method\s+(?P<forward_method>\S+))?
                 (?:\s+fwmark\s+(?P<fwmark>\S+))?
                 (?:\s+persistence-timeout\s+(?P<persistence_timeout>\S+))?
                 (?:\s+port\s+(?P<port>\S+))?
                 (?:\s+protocol\s+(?P<protocol>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vsrvs,
             "result": {
                 "virtual_servers": {
                     "{{ alias }}": {
                         "alias": "{{ alias }}",
                         "address": "{{ address if address is defined else None }}",
                         "algorithm": "{{ algorithm if algorithm is defined else None }}",
                         "delay_loop": "{{ delay_loop if delay_loop is defined else None }}",
                         "forward_method": "{{ forward_method if forward_method is defined else None }}",
                         "fwmark": "{{ fwmark if fwmark is defined else None }}",
                         "persistence_timeout": "{{ persistence_timeout if persistence_timeout is defined else None }}",
                         "port": "{{ port if port is defined else None }}",
                         "protocol": "{{ protocol if protocol is defined else None }}",
                     },
                 },
             },
         },
         {
             "name": "virtual_servers.real_servers",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svirtual-server
                 \s+(?P<alias>\S+)
                 \sreal-server
                 \s+(?P<address>\S+)
                 (?:\s+port\s+(?P<port>\S+))?
                 (?:\s+health-check\sscript\s+(?P<hcscript>\S+))?
                 (?:\s+connection-timeout\s+(?P<cont>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vsrvs_rsrv,
             # "compval": "global_parameters.garp.master_refersh_repeat",
             "result": {
                 "virtual_servers": {
                     "{{ alias }}": {
                         "alias": "{{ alias }}",
                         "real_servers": {
                             "{{ address }}": {
                                 "address": "{{ address }}",
                                 "port": "{{ port if port is defined else None }}",
                                 "health_check_script": "{{ hcscript if hcscript is defined else None }}",
                                 "connection_timeout": "{{ cont if cont is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         # {
         #     "name": "vrrp.sync_groups.member",
         #     "getval": re.compile(
         #         r"""
         #         ^set\shigh-availability\svrrp\ssync-group
         #         \s+(?P<sgname>\S+)
         #         \smember
         #         \s+(?P<member>\S+)
         #         $
         #         """,
         #         re.VERBOSE,
         #     ),
         #     "setval": "set high-availability vrrp sync-group {{sgname}} member {{member}}",
         #     "result": {
         #         "vrrp": {
         #             "sync_groups": {
         #                 "{{ sgname }}": {
         #                     "name": "{{ sgname }}",
         #                     "member": [
         #                         "{{ member }}"
         #                     ],
         #                 },
         #             },
         #         },
         #     },
         # },
         {
             "name": "vrrp.sync_groups.member",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\ssync-group
                 \s+(?P<sgname>\S+)
                 \smember
                 \s+(?P<member>\S+)
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": "set high-availability vrrp sync-group {{sgname}} member {{member}}",
             "result": {
                 "vrrp": {
                     "sync_groups": [
                         {
                             "name": "{{ sgname }}",
                             "member": ["{{ member }}"],
                         },
                     ],
                 },
             },
         },
         {
             "name": "vrrp.sync_groups.health_check",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\ssync-group
                 \s+(?P<sgname>\S+)
                 \shealth-check
                 (?:\s+failure-count\s+(?P<failure_count>\S+))
                 ?(?:\s+interval\s+(?P<int>\S+))
                 ?(?:\s+ping\s+(?P<ping>\S+))
                 ?(?:\s+script\s+(?P<script>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_sgroup_hc,
             # "compval": "vrrp.sync_groups",
             "result": {
                 "vrrp": {
                     "sync_groups": {
                         "{{ sgname }}": {
                             "name": "{{ sgname }}",
                             "health_check": {
                                 "failure_count": "{{ failure_count if failure_count is defined else None }}",
                                 "interval": "{{ int if int is defined else None }}",
                                 "ping": "{{ ping if ping is defined else None }}",
                                 "script": "{{ script if script is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.sync_groups.transition_script",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\ssync-group
                 \s+(?P<sgname>\S+)
                 \stransition-script
                 (?:\s+backup\s+(?P<backup>\S+))?
                 (?:\s+fault\s+(?P<fault>\S+))?
                 (?:\s+master\s+(?P<master>\S+))?
                 (?:\s+stop\s+(?P<stop>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_sgroup_ts,
             # "compval": "global_parameters.garp.master_refersh_repeat",
             "result": {
                 "vrrp": {
                     "sync_groups": {
                         "{{ sgname }}": {
                             "name": "{{ sgname }}",
                             "transition_script": {
                                 "backup": "{{ backup if backup is defined else None }}",
                                 "fault": "{{ fault if fault is defined else None }}",
                                 "master": "{{ master if master is defined else None }}",
                                 "stop": "{{ stop if stop is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.global_parameters.garp",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sglobal-parameters
                 \s+garp
                 (?:\s+interval\s+(?P<interval>\S+))?
                 (?:\s+master-delay\s+(?P<master_delay>\S+))?
                 (?:\s+master-refresh\s+(?P<master_refresh>\S+))?
                 (?:\s+master-refresh-repeat\s+(?P<master_refresh_repeat>\S+))?
                 (?:\s+master-repeat\s+(?P<master_repeat>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_gp_garp,
-            # "compval": "global_parameters.garp",
             "result": {
                 "vrrp": {
                     "global_parameters": {
                         "garp": {
                             "interval": "{{ interval if interval is defined else None }}",
                             "master_delay": "{{ master_delay if master_delay is defined else None }}",
                             "master_refresh": "{{ master_refresh if master_refresh is defined else None }}",
                             "master_refresh_repeat": "{{ master_refresh_repeat if master_refresh_repeat is defined else None }}",
                             "master_repeat": "{{ master_repeat if master_repeat is defined else None }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.global_parameters",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sglobal-parameters
                 (?:\s+startup-delay\s+(?P<startup_delay>\S+))?
                 (?:\s+version\s+(?P<version>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_gp,
-            "compval": "vrrp.global_parameters",
             "result": {
                 "vrrp": {
                     "global_parameters": {
                         "startup_delay": "{{ startup_delay if startup_delay is defined else None }}",
                         "version": "{{ version if version is defined else None }}",
                     },
                 },
             },
         },
         {
             "name": "vrrp.group",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<group_name>\S+)
                 (?:\s+address\s+(?P<address>\S+))?
                 (?:\s+description\s+(?P<description>'.+?'|\S+))?
                 (?:\s+advertise-interval\s+(?P<advertise_interval>\S+))?
                 (?:\s+hello-source-address\s+(?P<hello_source>\S+))?
                 (?:\s+interface\s+(?P<interface>\S+))?
                 (?:\s+(?P<no_preempt>no-preempt))?
                 (?:\s+peer-address\s+(?P<peer_address>\S+))?
                 (?:\s+priority\s+(?P<priority>\S+))?
                 (?:\s+vrid\s+(?P<vrid>\S+))?
                 (?:\s+rfc3768-compatibility\s+(?P<rfc3768_compatibility>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group,
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ group_name }}": {
                             "name": "{{ group_name }}",
                             "address": "{{ address if address is defined else None }}",
                             "description": "{{ description.strip(\"'\") if description is defined else None }}",
                             "advertise_interval": "{{ advertise_interval if advertise_interval is defined else None }}",
                             "hello_source_address": "{{ hello_source if hello_source is defined else None }}",
                             "interface": "{{ interface if interface is defined else None }}",
                             "no_preempt": "{{ True if no_preempt is defined else False }}",
                             "peer_address": "{{ peer_address if peer_address is defined else None }}",
                             "priority": "{{ priority if priority is defined else None }}",
                             "vrid": "{{ vrid if vrid is defined else None }}",
                             "rfc3768_compatibility": "{{ rfc3768_compatibility if rfc3768_compatibility is defined else None }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.authentication",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<group_name>\S+)
                 \s+(?P<authentication>\S+)
                 (?:\s+password\s+(?P<password>\S+))?
                 (?:\s+type\s+(?P<type>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_auth,
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ group_name }}": {
                             "name": "{{ group_name }}",
                             "authentication": {
                                 "password": "{{ password if password is defined else None }}",
                                 "type": "{{ type if type is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.garp",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+garp
                 (?:\s+interval\s+(?P<interval>\S+))?
                 (?:\s+master-delay\s+(?P<master_delay>\S+))?
                 (?:\s+master-refresh\s+(?P<master_refresh>\S+))?
                 (?:\s+master-refresh-repeat\s+(?P<master_refresh_repeat>\S+))?
                 (?:\s+master-repeat\s+(?P<master_repeat>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_garp,
             "result": {
                 "vrrp": {
                     "groups": {
                         "garp": {
                             "interval": "{{ interval if interval is defined else None }}",
                             "master_delay": "{{ master_delay if master_delay is defined else None }}",
                             "master_refresh": "{{ master_refresh if master_refresh is defined else None }}",
                             "master_refresh_repeat": "{{ master_refresh_repeat if master_refresh_repeat is defined else None }}",
                             "master_repeat": "{{ master_repeat if master_repeat is defined else None }}",
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.transition_script",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<gname>\S+)
                 \stransition-script
                 (?:\s+backup\s+(?P<backup>\S+))?
                 (?:\s+fault\s+(?P<fault>\S+))?
                 (?:\s+master\s+(?P<master>\S+))?
                 (?:\s+stop\s+(?P<stop>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_ts,
             # "compval": "global_parameters.garp.master_refersh_repeat",
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ gname }}": {
                             "name": "{{ gname }}",
                             "transition_script": {
                                 "backup": "{{ backup if backup is defined else None }}",
                                 "fault": "{{ fault if fault is defined else None }}",
                                 "master": "{{ master if master is defined else None }}",
                                 "stop": "{{ stop if stop is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.health_check",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<group_name>\S+)
                 \shealth-check
                 (?:\s+failure-count\s+(?P<failure_count>\S+))
                 ?(?:\s+interval\s+(?P<int>\S+))
                 ?(?:\s+ping\s+(?P<ping>\S+))
                 ?(?:\s+script\s+(?P<script>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_hc,
             # "compval": "global_parameters.garp.master_refersh_repeat",
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ group_name }}": {
                             "name": "{{ group_name }}",
                             "health_check": {
                                 "failure_count": "{{ failure_count if failure_count is defined else None }}",
                                 "interval": "{{ int if int is defined else None }}",
                                 "ping": "{{ ping if ping is defined else None }}",
                                 "script": "{{ script if script is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.track",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<group_name>\S+)
                 \strack
                 (?:\s+exculde-vrrp-interface\s+(?P<exclude_vrrp_inter>\S+))?
                 (?:\s+interface\s+(?P<interface>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_track,
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ group_name }}": {
                             "name": "{{ group_name }}",
                             "track": {
                                 "exclude_vrrp_interface": "{{ exclude_vrrp_inter if exclude-vrrp-inter is defined else None }}",
                                 "interface": "{{ interface if interface is defined else None }}",
                             },
                         },
                     },
                 },
             },
         },
         {
             "name": "vrrp.group.excluded_address",
             "getval": re.compile(
                 r"""
                 ^set\shigh-availability\svrrp\sgroup
                 \s+(?P<group_name>\S+)
                 \sexcluded-address\s+(?P<address>\S+)
                 (?:\s+interface\s+(?P<interface>\S+))?
                 $
                 """,
                 re.VERBOSE,
             ),
             "setval": _tmplt_vrrp_group_auth,
             "result": {
                 "vrrp": {
                     "groups": {
                         "{{ group_name }}": {
                             "name": "{{ group_name }}",
                             "excluded_address": {
                                 "{{ address }}": {
                                     "name": "{{ address }}",
                                     "interface": "{{ interface if interface is defined else None }}",
                                 },
                             },
                         },
                     },
                 },
             },
         },
         # {
         #     "name": "vrrp.snmp",
         #     "getval": re.compile(
         #         r"""
         #         ^set\shigh-availability\svrrp\ssnmp
         #         \s+(?P<snmp>snmp\S+)
         #         $
         #         """,
         #         re.VERBOSE,
         #     ),
         #     "setval": _tmplt_vrrp_group_auth,
         #     "result": {
         #         "vrrp": {
         #             "snmp": {
         #                 "{{ snmp }}": {
         #                     "name": "{{ snmp }}",
         #                     "excluded_address": {
         #                         "{{ address }}": {
         #                             "name": "{{ address }}",
         #                             "interface": "{{ interface if interface is defined else None }}",
         #                         },
         #                     },
         #                 },
         #             },
         #         },
         #     },
         # }
         {
             "name": "vrrp.snmp",
             "getval": re.compile(
                 r"""
                 ^set
                 \shigh-availability
                 \svrrp
                 \s(?P<snmp>snmp)
                 $""",
                 re.VERBOSE,
             ),
             "setval": "high-availability vrrp snmp",
             "result": {
                 "vrrp": {
                     "snmp": "{{ True if snmp is defined }}",
                 },
             },
         },
     ]
     # fmt: on