From b61c359fcb05c50de730e1785cec5d9f8880ced9 Mon Sep 17 00:00:00 2001 From: Thomas Vreys Date: Wed, 28 Jan 2026 10:38:17 +0100 Subject: [PATCH 1/3] Implemented ipxact2py This python generator generates 2 files: acces_layer.py, which defines objects that represent hardware. The second generated file is a register defintion file based on the ipxaxt standard. It is tested with the different .ini files. This work was sponsored by OIP Sensor Systems Signed-off-by: Bruce Benedictus Signed-off-by: Thomas Vreys --- Makefile | 42 ++-- README.md | 3 +- ipxact2systemverilog/cli.py | 27 ++- ipxact2systemverilog/ipxact2hdlCommon.py | 177 ++++++++++++++- ipxact2systemverilog/ipxact2pyCommon.py | 264 +++++++++++++++++++++++ pyproject.toml | 3 +- 6 files changed, 489 insertions(+), 27 deletions(-) create mode 100644 ipxact2systemverilog/ipxact2pyCommon.py diff --git a/Makefile b/Makefile index 617c23b..86ecedf 100644 --- a/Makefile +++ b/Makefile @@ -15,23 +15,26 @@ gen: ipxact2vhdl --srcFile example/input/test.xml --destDir example/output ipxact2md --srcFile example/input/test.xml --destDir example/output ipxact2c --srcFile example/input/test.xml --destDir example/output + ipxact2py --srcFile example/input/test.xml --destDir example/output pandoc -s example/output/example.rst -o example/output/example.html pandoc -s example/output/example.rst -o example/output/example.rtf pandoc -s example/output/example.rst -o example/output/example.pdf - # default config - ipxact2systemverilog --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini - ipxact2rst --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini - ipxact2md --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini - ipxact2vhdl --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini - ipxact2c --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini - - # no default config - ipxact2systemverilog --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini - ipxact2rst --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini - ipxact2md --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini - ipxact2vhdl --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini - ipxact2c --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + # default config + ipxact2systemverilog --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini + ipxact2rst --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini + ipxact2md --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini + ipxact2vhdl --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini + ipxact2c --srcFile example/input/test.xml --destDir example/output_default --config example/input/default.ini + ipxact2py --srcFile example/input/test.xml --destDir example/output_default -- config example/input/default.ini + + # no default config + ipxact2systemverilog --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + ipxact2rst --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + ipxact2md --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + ipxact2vhdl --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + ipxact2c --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini + ipxact2py --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini # RestructuredText and Sphinx with Wavedrom ipxact2rst --srcFile example/input/test.xml --destDir example/output_sphinx --config example/input/sphinx.ini @@ -46,13 +49,7 @@ gen: ipxact2vhdl --srcFile example/input/test2.xml --destDir example/output ipxact2md --srcFile example/input/test2.xml --destDir example/output ipxact2c --srcFile example/input/test2.xml --destDir example/output - pandoc -s example/output/example2.rst -o example/output/example2.pdf - - cp example/output/example2.rst example/output_sphinx2 - ipxact2rst --srcFile example/input/test2.xml --destDir example/output_sphinx2 --config example/input/sphinx.ini - sphinx-build example/output_sphinx2 example/output_sphinx2/build -q -b latex - make -C example/output_sphinx2/build - cp example/output_sphinx2/build/example2.pdf example/output_sphinx2/example2.pdf + ipxact2py --srcFile example/input/test.xml --destDir example/output compile: @@ -105,6 +102,11 @@ test_rst: rst-lint example/output_default/*.rst rst-lint example/output_no_default/*.rst +test_py: + pylint example/output/*.py + pylint example/output_default/*.py + pylint example/output_no_default/*.py + venv: requirements.txt python3 -m venv ./venv pip install wheel diff --git a/README.md b/README.md index d909f5a..7f8476a 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# ipxact2systemverilog ipxact2rst ipxact2md ipxact2vhdl ipxact2c +# ipxact2systemverilog ipxact2rst ipxact2md ipxact2vhdl ipxact2c ipxact2py [![CI](https://github.com/oddball/ipxact2systemverilog/actions/workflows/ci.yml/badge.svg)](https://github.com/oddball/ipxact2systemverilog/actions/workflows/ci.yml) @@ -21,6 +21,7 @@ ipxact2rst --srcFile FILE --destDir DIR ipxact2md --srcFile FILE --destDir DIR ipxact2vhdl --srcFile FILE --destDir DIR ipxact2c --srcFile FILE --destDir DIR +ipxact2py --srcFile FILE --destDir DIR ``` ## Development diff --git a/ipxact2systemverilog/cli.py b/ipxact2systemverilog/cli.py index f8a7c77..d2ef0d1 100644 --- a/ipxact2systemverilog/cli.py +++ b/ipxact2systemverilog/cli.py @@ -9,6 +9,7 @@ from .ipxact2hdlCommon import rstAddressBlock from .ipxact2hdlCommon import systemVerilogAddressBlock from .ipxact2hdlCommon import vhdlAddressBlock +from ipxact2systemverilog.ipxact2hdlCommon import pyAddressBlock from .ipxact2hdlCommon import DEFAULT_INI from .validate import validate @@ -18,7 +19,7 @@ def main_c(): parser.add_argument('-d', '--destDir', help="write generated file to dir", required=True) parser.add_argument('-c', '--config', help="configuration ini file") - args, unknown_args = parser.parse_known_args() + args, _ = parser.parse_known_args() if not validate(args.srcFile): print(f"{args.srcFile} doesn't validate") @@ -132,3 +133,27 @@ def main_vhdl(): generator = ipxact2otherGenerator(args.destDir, config) generator.generate(vhdlAddressBlock, document) +def main_py(): + parser = argparse.ArgumentParser(description='ipxact2python') + parser.add_argument('-s', '--srcFile', help='ipxact xml input file', required=True) + parser.add_argument('-d', '--destDir', help="write generated file to dir", required=True) + parser.add_argument('-c', '--config', help="configuration ini file") + + args, _ = parser.parse_known_args() + + if not validate(args.srcFile): + print("%s doesn't validate" % args.srcFile) + sys.exit(1) + + config = configparser.ConfigParser() + if args.config: + config.read_dict(DEFAULT_INI) + config.read(args.config) + else: + config.read_dict(DEFAULT_INI) + + e = ipxactParser(args.srcFile, config) + document = e.returnDocument() + generator = ipxact2otherGenerator(args.destDir, config) + generator.generate(pyAddressBlock, document) + diff --git a/ipxact2systemverilog/ipxact2hdlCommon.py b/ipxact2systemverilog/ipxact2hdlCommon.py index df4836c..8dcde80 100644 --- a/ipxact2systemverilog/ipxact2hdlCommon.py +++ b/ipxact2systemverilog/ipxact2hdlCommon.py @@ -30,10 +30,11 @@ DEFAULT_INI = {'global': {'unusedholes': 'yes', 'onebitenum': 'no'}, - 'vhdl': {'PublicConvFunct': 'no', + 'vhdl': {'PublicConvFunct': 'no', 'std': 'unresolved'}, - 'rst': {'sphinx': 'no', - 'wavedrom': 'no'}} + 'rst': {'sphinx': 'no', + 'wavedrom': 'no'}, + 'py': {'imports': 'absolute'}} def sortRegisterAndFillHoles(regName, @@ -189,6 +190,159 @@ def compare(self, other): def compareLists(self, list1, list2): return list1 == list2 + + +class pyAddressBlock(addressBlockClass): + """Generates a Python file from a IP-XACT register description""" + + def __init__(self, name, description, baseAddress, addrWidth, dataWidth, config): + self.name = name + self.description = description + self.baseAddress = baseAddress + self.addrWidth = addrWidth + self.dataWidth = dataWidth + self.registerList = [] + self.suffix = ".py" + self.library = "" + self.config = config + if self.config['py']['imports'] == "absolute": + self.imports = "absolute" + else: + self.imports = "relative" + + + def returnAsString(self): + r = '' + r += self.returnPkgHeaderString() + r += self.returnObjectClass() + r += self.returnRegistersClass() + r += self.returnIPClass() + return r + + def returnIncludeString(self): + lib_file = os.path.join(os.path.dirname(__file__), "ipxact2pyCommon" + self.suffix) + f = open(lib_file, "r", encoding='utf-8') + return f.read() + + def returnPkgHeaderString(self): + r = '' + r += "# Automatically generated\n" + r += f"# with the command '{' '.join(sys.argv)}'\n" + r += "#\n" + r += "# Do not manually edit!\n" + r += "#\n" + r += "\n" + return r + + def returnObjectClass(self): + r = '' + r += "from enum import IntEnum\n\n" + + if self.imports == "absolute": + r += "from acces_layer import *\n" + else: + r += "from .acces_layer import *\n" + + r += "\n\n" + return r + + def returnRegistersClass(self): + r = '' + + # Do for all registers + for reg in self.registerList: + + for i, enum in enumerate(reg.enumTypeList): + if enum: + r += f"# {reg.fieldDescList[i]}\n" + r += f"class {enum.name}_enum(IntEnum):\n" + for i in range(len(enum.keyList)): + r += f" {enum.keyList[i]} = {enum.valueList[i]}" + if enum.descrList[i]: + r += f" # {enum.descrList[i]}" + + r += "\n" + r += "\n\n" + + r += f"class {reg.name}_type(Register):\n" + if reg.desc: + r += ' """\n' + r += f' {reg.desc}\n' + r += ' """\n\n' + + # r += " def __init__(self, parent_ip, address_offset):\n" + r += " def __init__(\n" + r += " self,\n" + r += " parent_ip: IP,\n" + r += " address_offset: int,\n" + r += " ):\n" + # r += " super().__init__(parent_ip, address_offset)\n" + r += " super().__init__(\n" + r += " parent_ip,\n" + r += " address_offset,\n" + r += " )" + r += "\n" + + for i in list(range(len(reg.fieldNameList))): + bits = f"[{reg.bitOffsetList[i] + reg.bitWidthList[i] - 1}:{reg.bitOffsetList[i]}]" + bit = f"[{reg.bitOffsetList[i]}]" + if reg.bitWidthList[i] == 1: # field with only one bit + r += f" # {bit}\n" + else: + r += f" # {bits}\n" + if reg.fieldDescList[i]: + desc_lines = reg.fieldDescList[i].split("\n") + for line in desc_lines: + r += f' # {line}\n' + if reg.enumTypeList[i]: + r += f' self._{reg.fieldNameList[i]} = EnumField(\n' + r += f' self,\n' + r += f' bit_width={reg.bitWidthList[i]},\n' + r += f' bit_offset={reg.bitOffsetList[i]},\n' + r += f' access="{reg.access}",\n' + r += f' enum_type={reg.enumTypeList[i].name}_enum,\n' + r += f' )' + else: + r += f' self._{reg.fieldNameList[i]} = IntegerField(\n' + r += f' self,\n' + r += f' bit_width={reg.bitWidthList[i]},\n' + r += f' bit_offset={reg.bitOffsetList[i]},\n' + r += f' access="{reg.access}",\n' + r += f' minimum={reg.fieldMinimumConstraintsList[i]},\n' + r += f' maximum={reg.fieldMaximumConstraintsList[i]},\n' + r += f' )' + r += "\n" + + r += "\n" + + for i in list(range(len(reg.fieldNameList))): + r += " @property\n" + r += f" def {reg.fieldNameList[i]}(self):\n" + r += f" return self._{reg.fieldNameList[i]}.get()\n" + r += "\n" + r += f" @{reg.fieldNameList[i]}.setter\n" + if reg.enumTypeList[i]: + r += f" def {reg.fieldNameList[i]}(self, value: {reg.enumTypeList[i].name}_enum):\n" + else: + r += f" def {reg.fieldNameList[i]}(self, value: int):\n" + r += f" self._{reg.fieldNameList[i]}.set(value)\n" + r += "\n" + + r += "\n" + + return r + + def returnIPClass(self): + r = '' + r += f"class {self.name}_type(IP):\n" + r += " def __init__(self, parent: IP, base_address=0, access_layer=accesLayer):\n" + r += " super().__init__(parent, base_address, access_layer)\n\n" + # Do for all registers + _width = math.ceil(self.addrWidth / 4) + 2 # +2 for the '0x' + for reg in self.registerList: + r += f" self.{reg.name} = {reg.name}_type(self, address_offset={reg.address:#0{_width}x})\n" + + return r class rstAddressBlock(addressBlockClass): @@ -1131,8 +1285,17 @@ def __init__(self, srcFile, config): self.config = config self.enumTypeClassRegistry = enumTypeClassRegistry() + def getXmlSchema(self): + tree = ETree.parse(self.srcFile) + root = tree.getroot() + namespace_uri = root.tag.split('}', 1)[0][1:] + version = namespace_uri.split('/')[-1] + schema = 'http://www.spiritconsortium.org/XMLSchema/SPIRIT/'+version + return schema + + def returnDocument(self): - spirit_ns = 'http://www.spiritconsortium.org/XMLSchema/SPIRIT/1.5' + spirit_ns = self.getXmlSchema() tree = ETree.parse(self.srcFile) ETree.register_namespace('spirit', spirit_ns) namespace = tree.getroot().tag[1:].split("}")[0] @@ -1308,3 +1471,9 @@ def generate(self, generatorClass, document): includeFileName = fileName + "h" includeString = block.returnIncludeString() self.write(includeFileName, includeString) + elif generatorClass == pyAddressBlock: + includeFileName = "acces_layer" + ".py" + includeString = block.returnIncludeString() + self.write(includeFileName, includeString) + if block.imports == "relative": + self.write("__init__.py", "") diff --git a/ipxact2systemverilog/ipxact2pyCommon.py b/ipxact2systemverilog/ipxact2pyCommon.py new file mode 100644 index 0000000..f51035f --- /dev/null +++ b/ipxact2systemverilog/ipxact2pyCommon.py @@ -0,0 +1,264 @@ +""" +Base types for the generated code are declared here, as well as exceptions and other supporting classes. +Functionality to read, write and modify registers is also provided here. Several methods are provided, all sharing the same +interface. +""" + + +class OutOfRangeReading(Exception): + """Exception thrown when an out of range value is read from the register.""" + pass + + +class OutOfRangeWriting(Exception): + """Exception thrown when an out of range value is attempted to be written to the register.""" + pass + + +class OutOfRangeSpecifying(Exception): + """Exception thrown when an a boundary is specified that is incoherent (e.g. with the number of bits in a field).""" + pass + + +class FieldNotWritable(Exception): + """Exception thrown when attempting to write to a read-only field.""" + pass + + +class accesLayer: + """This interface contains method declarations that should be used by classes that can implement any type of memory + access the registers (including simulated). """ + def read_register(self, addr, offset=0, width=32): + """ + Reads a register + :param addr: address + :param offset: bit offset + :param width: number of bits after the offset to read + :return: the requested bits from the register + """ + raise NotImplementedError() + + def modify_register(self, addr, data, offset=0, width=32): + """ + Partially writes a register + :param addr: address + :param addr: data to be written + :param offset: bit offset + :param width: number of bits after the offset to write + """ + raise NotImplementedError() + + def write_register(self, addr, data): + """ + writes a complete register + :param addr: address + :param addr: data to be written + """ + raise NotImplementedError() + + +class IP(): + def __init__(self, parent, base_address, acces_layer=accesLayer): + self._base_address = base_address + self._parent = parent + self._acces_layer = acces_layer + + def get_base_address(self): + return self._base_address + + def get_acces_layer(self): + return self._acces_layer + + +class Register(): + def __init__(self, parent_ip, address_offset): + """ + Constructor for a register of an IP + :param parent_ip: an IP object to which this register belongs + :param address_offset: the address offset (from the IP's base address) + """ + self._parent_ip = parent_ip + self._address_offset = address_offset + self._acces_layer = parent_ip.get_acces_layer() + + def get_address_offset(self): + """ + Returns the address offset + :return: the address offset + """ + return self._address_offset + + def get_parent_ip(self): + """ + Returns the parent IP object + :return: the parent IP object + """ + return self._parent_ip + + def get_acces_layer(self): + """ + Returns the acces layer object currently used. Usually it's the parent IP's access layer + :return: the acces layer object currently used + """ + return self._acces_layer + + def get(self): + """ + returns the value of this register (as unsigned int) + :return: the value of this register + """ + self.get_acces_layer().read_register(self.get_parent_ip().get_base_address() + + self.get_address_offset()) + + def set(self, value): + """ + Sets the value of this register (as unsigned int) + :value: the value to set this register + """ + self.get_acces_layer().write_register(self.get_parent_ip().get_base_address() + + self.get_address_offset(), value) + + +class Field(): + """This base class represents a field in the register. It will work like an unsigned integer field and is the prefered + way of obtaining 'raw values' from the registers but should be derived from and not instanced. """ + def __init__(self, parent_register, bit_width, bit_offset, access): + """ + Constructor for a Field of a register + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + """ + self._parent_register = parent_register + self._bit_width = bit_width + self._bit_offset = bit_offset + self._access = access + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + return self._parent_register.get_acces_layer().read_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + self._bit_offset, + self._bit_width) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if self._access == "read-only": + raise FieldNotWritable() + + self._parent_register.get_acces_layer().modify_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + value, + self._bit_offset, + self._bit_width) + + +class EnumField(Field): + """Represents an enumerated type.""" + def __init__(self, parent_register, bit_width, bit_offset, access, enum_type): + """ + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param enum_type: a Python type derived from IntEnum which we want to represent + """ + super().__init__(parent_register, bit_width, bit_offset, access) + self._enum_type = enum_type + self._int_values = list(map(int, enum_type)) + + def get(self): + """ + Returns the value of the field + :return: the current enumeration represented by the field + """ + val = super().get() + if val not in self._int_values: + return OutOfRangeReading() + return self._enum_type(val) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set. Either an integer or an enumeration of 'our' enumerated type + """ + if value in self._int_values: + super().set(value) + else: + raise OutOfRangeWriting() + + +class IntegerField(Field): + """This class represents an (unsigned) integer. It derives from Field and relies on it for abstracting reads and + writes. Therefore, this class is basically concerned with boundary checking.""" + def __init__(self, parent_register, bit_width, bit_offset, access, minimum, maximum): + """ + Constructor for a Field of a register + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param minimum: minimum value that this field can have (None to assume the minimum representable) + :param maximum: maximum value that this field can have (None to assume the maximum representable) + """ + super().__init__(parent_register, bit_width, bit_offset, access) + type_minimum = 0 + type_maximum = (2 ** bit_width) - 1 + if minimum is not None: + if minimum < type_minimum: + raise OutOfRangeSpecifying() + else: + self._minimum = minimum + else: + self._minimum = type_minimum + + if maximum is not None: + if maximum > type_maximum: + raise OutOfRangeSpecifying() + else: + self._maximum = maximum + else: + self._maximum = type_maximum + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + val = super().get() + if val < self._minimum or val > self._maximum: + raise OutOfRangeReading() + return val + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if value < self._minimum or value > self._maximum: + raise OutOfRangeWriting() + else: + super().set(value) + + def get_minimum(self): + """ + Gets the minimum value that can be defined for the field + :return: minimum + """ + return self._minimum + + def get_maximum(self): + """ + Gets the maximum value that can be defined for the field + :return: maximum + """ + return self._maximum diff --git a/pyproject.toml b/pyproject.toml index 481470f..d2e1010 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ name = "ipxact2systemverilog" authors = [ {name = "oddball"}, ] -keywords = ["ipxact2systemverilog", "ipxact2vhdl", "VHDL", "SystemVerilog", "html", "rst", "md", "pdf", "IPXACT"] +keywords = ["ipxact2systemverilog", "ipxact2vhdl", "VHDL", "SystemVerilog", "html", "rst", "md", "pdf", "IPXACT", "python"] requires-python = ">= 3" dependencies = [ "docutils", @@ -39,6 +39,7 @@ ipxact2md = "ipxact2systemverilog.cli:main_md" ipxact2rst = "ipxact2systemverilog.cli:main_rst" ipxact2systemverilog = "ipxact2systemverilog.cli:main_systemverilog" ipxact2vhdl = "ipxact2systemverilog.cli:main_vhdl" +ipxact2py = "ipxact2systemverilog.cli:main_py" [project.urls] From dee02b64251a8195c4a265f5e58ac59614f6d0e1 Mon Sep 17 00:00:00 2001 From: Thomas Vreys Date: Wed, 28 Jan 2026 10:39:39 +0100 Subject: [PATCH 2/3] Changed example input and output files This work was sponsored by OIP Sensor Systems Signed-off-by: Bruce Benedictus Signed-off-by: Thomas Vreys --- example/input/default.ini | 11 + example/input/no_default.ini | 3 + example/output/acces_layer.py | 264 +++++++++ example/output/example.html | 4 - example/output/example.pdf | Bin 111553 -> 112344 bytes example/output/example.py | 650 +++++++++++++++++++++++ example/output_default/acces_layer.py | 264 +++++++++ example/output_default/example.py | 650 +++++++++++++++++++++++ example/output_no_default/__init__.py | 0 example/output_no_default/acces_layer.py | 264 +++++++++ example/output_no_default/example.py | 552 +++++++++++++++++++ example/output_sphinx/example.pdf | Bin 184251 -> 186680 bytes 12 files changed, 2658 insertions(+), 4 deletions(-) create mode 100644 example/output/acces_layer.py create mode 100644 example/output/example.py create mode 100644 example/output_default/acces_layer.py create mode 100644 example/output_default/example.py create mode 100644 example/output_no_default/__init__.py create mode 100644 example/output_no_default/acces_layer.py create mode 100644 example/output_no_default/example.py diff --git a/example/input/default.ini b/example/input/default.ini index 52cca29..8ad3e7e 100644 --- a/example/input/default.ini +++ b/example/input/default.ini @@ -43,3 +43,14 @@ std = unresolved # - https://github.com/bavovanachte/sphinx-wavedrom # - https://github.com/wavedrom/bitfield wavedrom = no + +# Python +[py] +# Defines how Python modules generated by this tool will import other modules. +# This setting directly influences the generated 'from ... import ...' statements +# and the necessity of '__init__.py' files for package recognition. +# +# Options: +# - 'absolute': default option +# - 'relative' +imports = absolute \ No newline at end of file diff --git a/example/input/no_default.ini b/example/input/no_default.ini index ba1cc71..86c09ed 100644 --- a/example/input/no_default.ini +++ b/example/input/no_default.ini @@ -5,3 +5,6 @@ OneBitEnum = yes [vhdl] PublicConvFunct = yes std = resolved + +[py] +imports = relative diff --git a/example/output/acces_layer.py b/example/output/acces_layer.py new file mode 100644 index 0000000..f51035f --- /dev/null +++ b/example/output/acces_layer.py @@ -0,0 +1,264 @@ +""" +Base types for the generated code are declared here, as well as exceptions and other supporting classes. +Functionality to read, write and modify registers is also provided here. Several methods are provided, all sharing the same +interface. +""" + + +class OutOfRangeReading(Exception): + """Exception thrown when an out of range value is read from the register.""" + pass + + +class OutOfRangeWriting(Exception): + """Exception thrown when an out of range value is attempted to be written to the register.""" + pass + + +class OutOfRangeSpecifying(Exception): + """Exception thrown when an a boundary is specified that is incoherent (e.g. with the number of bits in a field).""" + pass + + +class FieldNotWritable(Exception): + """Exception thrown when attempting to write to a read-only field.""" + pass + + +class accesLayer: + """This interface contains method declarations that should be used by classes that can implement any type of memory + access the registers (including simulated). """ + def read_register(self, addr, offset=0, width=32): + """ + Reads a register + :param addr: address + :param offset: bit offset + :param width: number of bits after the offset to read + :return: the requested bits from the register + """ + raise NotImplementedError() + + def modify_register(self, addr, data, offset=0, width=32): + """ + Partially writes a register + :param addr: address + :param addr: data to be written + :param offset: bit offset + :param width: number of bits after the offset to write + """ + raise NotImplementedError() + + def write_register(self, addr, data): + """ + writes a complete register + :param addr: address + :param addr: data to be written + """ + raise NotImplementedError() + + +class IP(): + def __init__(self, parent, base_address, acces_layer=accesLayer): + self._base_address = base_address + self._parent = parent + self._acces_layer = acces_layer + + def get_base_address(self): + return self._base_address + + def get_acces_layer(self): + return self._acces_layer + + +class Register(): + def __init__(self, parent_ip, address_offset): + """ + Constructor for a register of an IP + :param parent_ip: an IP object to which this register belongs + :param address_offset: the address offset (from the IP's base address) + """ + self._parent_ip = parent_ip + self._address_offset = address_offset + self._acces_layer = parent_ip.get_acces_layer() + + def get_address_offset(self): + """ + Returns the address offset + :return: the address offset + """ + return self._address_offset + + def get_parent_ip(self): + """ + Returns the parent IP object + :return: the parent IP object + """ + return self._parent_ip + + def get_acces_layer(self): + """ + Returns the acces layer object currently used. Usually it's the parent IP's access layer + :return: the acces layer object currently used + """ + return self._acces_layer + + def get(self): + """ + returns the value of this register (as unsigned int) + :return: the value of this register + """ + self.get_acces_layer().read_register(self.get_parent_ip().get_base_address() + + self.get_address_offset()) + + def set(self, value): + """ + Sets the value of this register (as unsigned int) + :value: the value to set this register + """ + self.get_acces_layer().write_register(self.get_parent_ip().get_base_address() + + self.get_address_offset(), value) + + +class Field(): + """This base class represents a field in the register. It will work like an unsigned integer field and is the prefered + way of obtaining 'raw values' from the registers but should be derived from and not instanced. """ + def __init__(self, parent_register, bit_width, bit_offset, access): + """ + Constructor for a Field of a register + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + """ + self._parent_register = parent_register + self._bit_width = bit_width + self._bit_offset = bit_offset + self._access = access + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + return self._parent_register.get_acces_layer().read_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + self._bit_offset, + self._bit_width) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if self._access == "read-only": + raise FieldNotWritable() + + self._parent_register.get_acces_layer().modify_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + value, + self._bit_offset, + self._bit_width) + + +class EnumField(Field): + """Represents an enumerated type.""" + def __init__(self, parent_register, bit_width, bit_offset, access, enum_type): + """ + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param enum_type: a Python type derived from IntEnum which we want to represent + """ + super().__init__(parent_register, bit_width, bit_offset, access) + self._enum_type = enum_type + self._int_values = list(map(int, enum_type)) + + def get(self): + """ + Returns the value of the field + :return: the current enumeration represented by the field + """ + val = super().get() + if val not in self._int_values: + return OutOfRangeReading() + return self._enum_type(val) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set. Either an integer or an enumeration of 'our' enumerated type + """ + if value in self._int_values: + super().set(value) + else: + raise OutOfRangeWriting() + + +class IntegerField(Field): + """This class represents an (unsigned) integer. It derives from Field and relies on it for abstracting reads and + writes. Therefore, this class is basically concerned with boundary checking.""" + def __init__(self, parent_register, bit_width, bit_offset, access, minimum, maximum): + """ + Constructor for a Field of a register + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param minimum: minimum value that this field can have (None to assume the minimum representable) + :param maximum: maximum value that this field can have (None to assume the maximum representable) + """ + super().__init__(parent_register, bit_width, bit_offset, access) + type_minimum = 0 + type_maximum = (2 ** bit_width) - 1 + if minimum is not None: + if minimum < type_minimum: + raise OutOfRangeSpecifying() + else: + self._minimum = minimum + else: + self._minimum = type_minimum + + if maximum is not None: + if maximum > type_maximum: + raise OutOfRangeSpecifying() + else: + self._maximum = maximum + else: + self._maximum = type_maximum + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + val = super().get() + if val < self._minimum or val > self._maximum: + raise OutOfRangeReading() + return val + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if value < self._minimum or value > self._maximum: + raise OutOfRangeWriting() + else: + super().set(value) + + def get_minimum(self): + """ + Gets the minimum value that can be defined for the field + :return: minimum + """ + return self._minimum + + def get_maximum(self): + """ + Gets the maximum value that can be defined for the field + :return: maximum + """ + return self._maximum diff --git a/example/output/example.html b/example/output/example.html index 57d60af..a715d82 100644 --- a/example/output/example.html +++ b/example/output/example.html @@ -60,10 +60,6 @@ img { max-width: 100%; } - svg { - height: auto; - max-width: 100%; - } h1, h2, h3, h4, h5, h6 { margin-top: 1.4em; } diff --git a/example/output/example.pdf b/example/output/example.pdf index f729f588900222bca1cc6a7f69c1a5a31f984d75..865a16f2e6c2b813952804f52c2f6ed142731ad8 100644 GIT binary patch delta 4829 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 F`Y(5j;q3qb delta 3987 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 SE;C5W%U~fen5woK type_maximum: + raise OutOfRangeSpecifying() + else: + self._maximum = maximum + else: + self._maximum = type_maximum + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + val = super().get() + if val < self._minimum or val > self._maximum: + raise OutOfRangeReading() + return val + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if value < self._minimum or value > self._maximum: + raise OutOfRangeWriting() + else: + super().set(value) + + def get_minimum(self): + """ + Gets the minimum value that can be defined for the field + :return: minimum + """ + return self._minimum + + def get_maximum(self): + """ + Gets the maximum value that can be defined for the field + :return: maximum + """ + return self._maximum diff --git a/example/output_default/example.py b/example/output_default/example.py new file mode 100644 index 0000000..fe102e4 --- /dev/null +++ b/example/output_default/example.py @@ -0,0 +1,650 @@ +# Automatically generated +# with the command '/home/labgrid/Thomas_vreys/ipxact2systemverilog/.venv/bin/ipxact2py --srcFile example/input/test.xml --destDir example/output_default -- config example/input/default.ini' +# +# Do not manually edit! +# + +from enum import IntEnum + +from acces_layer import * + + +class reg0_type(Register): + """ + write something useful for reg0 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [7:0] + # write something useful for field0 + self._byte0 = IntegerField( + self, + bit_width=8, + bit_offset=0, + access="read-write", + minimum=0, + maximum=7, + ) + # [15:8] + # write something useful for field1 + self._byte1 = IntegerField( + self, + bit_width=8, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + # [23:16] + # write something useful for field2 + self._byte2 = IntegerField( + self, + bit_width=8, + bit_offset=16, + access="read-write", + minimum=None, + maximum=None, + ) + # [31:24] + # write something useful for field3 + self._byte3 = IntegerField( + self, + bit_width=8, + bit_offset=24, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def byte0(self): + return self._byte0.get() + + @byte0.setter + def byte0(self, value: int): + self._byte0.set(value) + + @property + def byte1(self): + return self._byte1.get() + + @byte1.setter + def byte1(self, value: int): + self._byte1.set(value) + + @property + def byte2(self): + return self._byte2.get() + + @byte2.setter + def byte2(self, value: int): + self._byte2.set(value) + + @property + def byte3(self): + return self._byte3.get() + + @byte3.setter + def byte3(self, value: int): + self._byte3.set(value) + + +class reg1_type(Register): + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + # write something useful for field0 + self._field0 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=4, + maximum=20, + ) + + @property + def field0(self): + return self._field0.get() + + @field0.setter + def field0(self, value: int): + self._field0.set(value) + + +# which monkey +class monkey_enum(IntEnum): + chimp = 0x0 # a monkey + gorilla = 0x1 + phb = 0x2 # and another monkey + + +# which monkey +class monkey2_enum(IntEnum): + chimp = 0 + gorilla = 1 + phb = 2 + + +# which monkey +class monkey3_enum(IntEnum): + phb = 0 + gorilla = 1 + chimp = 2 + + +# which monkey +class monkey4_enum(IntEnum): + chimp = 0 + gorilla = 1 + bonobo = 2 + + +class reg2_type(Register): + """ + write something useful for reg2 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [0] + # write something useful for field power + self._power = IntegerField( + self, + bit_width=1, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + # [1] + # write something useful for field power2 + self._power2 = IntegerField( + self, + bit_width=1, + bit_offset=1, + access="read-write", + minimum=None, + maximum=None, + ) + # [3:2] + # which monkey + self._monkey = EnumField( + self, + bit_width=2, + bit_offset=2, + access="read-write", + enum_type=monkey_enum, + ) + # [5:4] + # which monkey + self._monkey2 = EnumField( + self, + bit_width=2, + bit_offset=4, + access="read-write", + enum_type=monkey2_enum, + ) + # [7:6] + # which monkey + self._monkey3 = EnumField( + self, + bit_width=2, + bit_offset=6, + access="read-write", + enum_type=monkey3_enum, + ) + # [9:8] + # which monkey + self._monkey4 = EnumField( + self, + bit_width=2, + bit_offset=8, + access="read-write", + enum_type=monkey4_enum, + ) + # [31:10] + # unused + self._unused0 = IntegerField( + self, + bit_width=22, + bit_offset=10, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def power(self): + return self._power.get() + + @power.setter + def power(self, value: int): + self._power.set(value) + + @property + def power2(self): + return self._power2.get() + + @power2.setter + def power2(self, value: int): + self._power2.set(value) + + @property + def monkey(self): + return self._monkey.get() + + @monkey.setter + def monkey(self, value: monkey_enum): + self._monkey.set(value) + + @property + def monkey2(self): + return self._monkey2.get() + + @monkey2.setter + def monkey2(self, value: monkey2_enum): + self._monkey2.set(value) + + @property + def monkey3(self): + return self._monkey3.get() + + @monkey3.setter + def monkey3(self, value: monkey3_enum): + self._monkey3.set(value) + + @property + def monkey4(self): + return self._monkey4.get() + + @monkey4.setter + def monkey4(self, value: monkey4_enum): + self._monkey4.set(value) + + @property + def unused0(self): + return self._unused0.get() + + @unused0.setter + def unused0(self, value: int): + self._unused0.set(value) + + +class reg3_type(Register): + """ + write something useful for reg3 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + # write something useful for field0 + self._field0 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def field0(self): + return self._field0.get() + + @field0.setter + def field0(self, value: int): + self._field0.set(value) + + +class reg4_type(Register): + """ + reg4 is a very useful register. It can take down the moon when configured correctly. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg4 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def reg4(self): + return self._reg4.get() + + @reg4.setter + def reg4(self, value: int): + self._reg4.set(value) + + +class reg5_type(Register): + """ + reg5 is as useful as reg4 but without a reset value defined. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg5 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def reg5(self): + return self._reg5.get() + + @reg5.setter + def reg5(self, value: int): + self._reg5.set(value) + + +class reg6_type(Register): + """ + reg6 is a read only register. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg6 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-only", + minimum=None, + maximum=None, + ) + + @property + def reg6(self): + return self._reg6.get() + + @reg6.setter + def reg6(self, value: int): + self._reg6.set(value) + + +class reg7_type(Register): + """ + write something useful for reg7 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [3:0] + # write something useful for nibble0 + self._nibble0 = IntegerField( + self, + bit_width=4, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + # [7:4] + # unused + self._unused0 = IntegerField( + self, + bit_width=4, + bit_offset=4, + access="read-write", + minimum=None, + maximum=None, + ) + # [11:8] + self._nibble1 = IntegerField( + self, + bit_width=4, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + # [15:12] + # unused + self._unused1 = IntegerField( + self, + bit_width=4, + bit_offset=12, + access="read-write", + minimum=None, + maximum=None, + ) + # [19:16] + # write something useful for nibble2 + self._nibble2 = IntegerField( + self, + bit_width=4, + bit_offset=16, + access="read-write", + minimum=None, + maximum=None, + ) + # [31:20] + # unused + self._unused2 = IntegerField( + self, + bit_width=12, + bit_offset=20, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def nibble0(self): + return self._nibble0.get() + + @nibble0.setter + def nibble0(self, value: int): + self._nibble0.set(value) + + @property + def unused0(self): + return self._unused0.get() + + @unused0.setter + def unused0(self, value: int): + self._unused0.set(value) + + @property + def nibble1(self): + return self._nibble1.get() + + @nibble1.setter + def nibble1(self, value: int): + self._nibble1.set(value) + + @property + def unused1(self): + return self._unused1.get() + + @unused1.setter + def unused1(self, value: int): + self._unused1.set(value) + + @property + def nibble2(self): + return self._nibble2.get() + + @nibble2.setter + def nibble2(self, value: int): + self._nibble2.set(value) + + @property + def unused2(self): + return self._unused2.get() + + @unused2.setter + def unused2(self, value: int): + self._unused2.set(value) + + +class reg8_type(Register): + """ + register with empty and no descriptions of the fields + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [3:0] + self._nibble0 = IntegerField( + self, + bit_width=4, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + # [7:4] + # unused + self._unused0 = IntegerField( + self, + bit_width=4, + bit_offset=4, + access="read-write", + minimum=None, + maximum=None, + ) + # [11:8] + self._nibble1 = IntegerField( + self, + bit_width=4, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + # [31:12] + # unused + self._unused1 = IntegerField( + self, + bit_width=20, + bit_offset=12, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def nibble0(self): + return self._nibble0.get() + + @nibble0.setter + def nibble0(self, value: int): + self._nibble0.set(value) + + @property + def unused0(self): + return self._unused0.get() + + @unused0.setter + def unused0(self, value: int): + self._unused0.set(value) + + @property + def nibble1(self): + return self._nibble1.get() + + @nibble1.setter + def nibble1(self, value: int): + self._nibble1.set(value) + + @property + def unused1(self): + return self._unused1.get() + + @unused1.setter + def unused1(self, value: int): + self._unused1.set(value) + + +class example_type(IP): + def __init__(self, parent: IP, base_address=0, access_layer=accesLayer): + super().__init__(parent, base_address, access_layer) + + self.reg0 = reg0_type(self, address_offset=0x0) + self.reg1 = reg1_type(self, address_offset=0x1) + self.reg2 = reg2_type(self, address_offset=0x2) + self.reg3 = reg3_type(self, address_offset=0x3) + self.reg4 = reg4_type(self, address_offset=0x4) + self.reg5 = reg5_type(self, address_offset=0x5) + self.reg6 = reg6_type(self, address_offset=0x6) + self.reg7 = reg7_type(self, address_offset=0x7) + self.reg8 = reg8_type(self, address_offset=0x8) diff --git a/example/output_no_default/__init__.py b/example/output_no_default/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/example/output_no_default/acces_layer.py b/example/output_no_default/acces_layer.py new file mode 100644 index 0000000..f51035f --- /dev/null +++ b/example/output_no_default/acces_layer.py @@ -0,0 +1,264 @@ +""" +Base types for the generated code are declared here, as well as exceptions and other supporting classes. +Functionality to read, write and modify registers is also provided here. Several methods are provided, all sharing the same +interface. +""" + + +class OutOfRangeReading(Exception): + """Exception thrown when an out of range value is read from the register.""" + pass + + +class OutOfRangeWriting(Exception): + """Exception thrown when an out of range value is attempted to be written to the register.""" + pass + + +class OutOfRangeSpecifying(Exception): + """Exception thrown when an a boundary is specified that is incoherent (e.g. with the number of bits in a field).""" + pass + + +class FieldNotWritable(Exception): + """Exception thrown when attempting to write to a read-only field.""" + pass + + +class accesLayer: + """This interface contains method declarations that should be used by classes that can implement any type of memory + access the registers (including simulated). """ + def read_register(self, addr, offset=0, width=32): + """ + Reads a register + :param addr: address + :param offset: bit offset + :param width: number of bits after the offset to read + :return: the requested bits from the register + """ + raise NotImplementedError() + + def modify_register(self, addr, data, offset=0, width=32): + """ + Partially writes a register + :param addr: address + :param addr: data to be written + :param offset: bit offset + :param width: number of bits after the offset to write + """ + raise NotImplementedError() + + def write_register(self, addr, data): + """ + writes a complete register + :param addr: address + :param addr: data to be written + """ + raise NotImplementedError() + + +class IP(): + def __init__(self, parent, base_address, acces_layer=accesLayer): + self._base_address = base_address + self._parent = parent + self._acces_layer = acces_layer + + def get_base_address(self): + return self._base_address + + def get_acces_layer(self): + return self._acces_layer + + +class Register(): + def __init__(self, parent_ip, address_offset): + """ + Constructor for a register of an IP + :param parent_ip: an IP object to which this register belongs + :param address_offset: the address offset (from the IP's base address) + """ + self._parent_ip = parent_ip + self._address_offset = address_offset + self._acces_layer = parent_ip.get_acces_layer() + + def get_address_offset(self): + """ + Returns the address offset + :return: the address offset + """ + return self._address_offset + + def get_parent_ip(self): + """ + Returns the parent IP object + :return: the parent IP object + """ + return self._parent_ip + + def get_acces_layer(self): + """ + Returns the acces layer object currently used. Usually it's the parent IP's access layer + :return: the acces layer object currently used + """ + return self._acces_layer + + def get(self): + """ + returns the value of this register (as unsigned int) + :return: the value of this register + """ + self.get_acces_layer().read_register(self.get_parent_ip().get_base_address() + + self.get_address_offset()) + + def set(self, value): + """ + Sets the value of this register (as unsigned int) + :value: the value to set this register + """ + self.get_acces_layer().write_register(self.get_parent_ip().get_base_address() + + self.get_address_offset(), value) + + +class Field(): + """This base class represents a field in the register. It will work like an unsigned integer field and is the prefered + way of obtaining 'raw values' from the registers but should be derived from and not instanced. """ + def __init__(self, parent_register, bit_width, bit_offset, access): + """ + Constructor for a Field of a register + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + """ + self._parent_register = parent_register + self._bit_width = bit_width + self._bit_offset = bit_offset + self._access = access + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + return self._parent_register.get_acces_layer().read_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + self._bit_offset, + self._bit_width) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if self._access == "read-only": + raise FieldNotWritable() + + self._parent_register.get_acces_layer().modify_register(self._parent_register.get_parent_ip().get_base_address() + + self._parent_register.get_address_offset(), + value, + self._bit_offset, + self._bit_width) + + +class EnumField(Field): + """Represents an enumerated type.""" + def __init__(self, parent_register, bit_width, bit_offset, access, enum_type): + """ + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param enum_type: a Python type derived from IntEnum which we want to represent + """ + super().__init__(parent_register, bit_width, bit_offset, access) + self._enum_type = enum_type + self._int_values = list(map(int, enum_type)) + + def get(self): + """ + Returns the value of the field + :return: the current enumeration represented by the field + """ + val = super().get() + if val not in self._int_values: + return OutOfRangeReading() + return self._enum_type(val) + + def set(self, value): + """ + Sets the value of the field + :value: value to be set. Either an integer or an enumeration of 'our' enumerated type + """ + if value in self._int_values: + super().set(value) + else: + raise OutOfRangeWriting() + + +class IntegerField(Field): + """This class represents an (unsigned) integer. It derives from Field and relies on it for abstracting reads and + writes. Therefore, this class is basically concerned with boundary checking.""" + def __init__(self, parent_register, bit_width, bit_offset, access, minimum, maximum): + """ + Constructor for a Field of a register + :param name: name + :param parent_register: parent register + :param bit_width: number of bits used by the field + :param bit_offset: bit offset from the beginning of the register + :param acces: a string for accessibility ('read-write' / 'read-only') + :param minimum: minimum value that this field can have (None to assume the minimum representable) + :param maximum: maximum value that this field can have (None to assume the maximum representable) + """ + super().__init__(parent_register, bit_width, bit_offset, access) + type_minimum = 0 + type_maximum = (2 ** bit_width) - 1 + if minimum is not None: + if minimum < type_minimum: + raise OutOfRangeSpecifying() + else: + self._minimum = minimum + else: + self._minimum = type_minimum + + if maximum is not None: + if maximum > type_maximum: + raise OutOfRangeSpecifying() + else: + self._maximum = maximum + else: + self._maximum = type_maximum + + def get(self): + """ + Returns the value of the field + :return: value of the field + """ + val = super().get() + if val < self._minimum or val > self._maximum: + raise OutOfRangeReading() + return val + + def set(self, value): + """ + Sets the value of the field + :value: value to be set + """ + if value < self._minimum or value > self._maximum: + raise OutOfRangeWriting() + else: + super().set(value) + + def get_minimum(self): + """ + Gets the minimum value that can be defined for the field + :return: minimum + """ + return self._minimum + + def get_maximum(self): + """ + Gets the maximum value that can be defined for the field + :return: maximum + """ + return self._maximum diff --git a/example/output_no_default/example.py b/example/output_no_default/example.py new file mode 100644 index 0000000..9df5fc3 --- /dev/null +++ b/example/output_no_default/example.py @@ -0,0 +1,552 @@ +# Automatically generated +# with the command '/home/labgrid/Thomas_vreys/ipxact2systemverilog/.venv/bin/ipxact2py --srcFile example/input/test.xml --destDir example/output_no_default --config example/input/no_default.ini' +# +# Do not manually edit! +# + +from enum import IntEnum + +from .acces_layer import * + + +class reg0_type(Register): + """ + write something useful for reg0 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [7:0] + # write something useful for field0 + self._byte0 = IntegerField( + self, + bit_width=8, + bit_offset=0, + access="read-write", + minimum=0, + maximum=7, + ) + # [15:8] + # write something useful for field1 + self._byte1 = IntegerField( + self, + bit_width=8, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + # [23:16] + # write something useful for field2 + self._byte2 = IntegerField( + self, + bit_width=8, + bit_offset=16, + access="read-write", + minimum=None, + maximum=None, + ) + # [31:24] + # write something useful for field3 + self._byte3 = IntegerField( + self, + bit_width=8, + bit_offset=24, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def byte0(self): + return self._byte0.get() + + @byte0.setter + def byte0(self, value: int): + self._byte0.set(value) + + @property + def byte1(self): + return self._byte1.get() + + @byte1.setter + def byte1(self, value: int): + self._byte1.set(value) + + @property + def byte2(self): + return self._byte2.get() + + @byte2.setter + def byte2(self, value: int): + self._byte2.set(value) + + @property + def byte3(self): + return self._byte3.get() + + @byte3.setter + def byte3(self, value: int): + self._byte3.set(value) + + +class reg1_type(Register): + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + # write something useful for field0 + self._field0 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=4, + maximum=20, + ) + + @property + def field0(self): + return self._field0.get() + + @field0.setter + def field0(self, value: int): + self._field0.set(value) + + +# write something useful for field power +class power_enum(IntEnum): + false = 0 # disable + true = 1 # enable + + +# write something useful for field power2 +class power2_enum(IntEnum): + false = 0 + true = 1 + + +# which monkey +class monkey_enum(IntEnum): + chimp = 0x0 # a monkey + gorilla = 0x1 + phb = 0x2 # and another monkey + + +# which monkey +class monkey2_enum(IntEnum): + chimp = 0 + gorilla = 1 + phb = 2 + + +# which monkey +class monkey3_enum(IntEnum): + phb = 0 + gorilla = 1 + chimp = 2 + + +# which monkey +class monkey4_enum(IntEnum): + chimp = 0 + gorilla = 1 + bonobo = 2 + + +class reg2_type(Register): + """ + write something useful for reg2 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [0] + # write something useful for field power + self._power = EnumField( + self, + bit_width=1, + bit_offset=0, + access="read-write", + enum_type=power_enum, + ) + # [1] + # write something useful for field power2 + self._power2 = EnumField( + self, + bit_width=1, + bit_offset=1, + access="read-write", + enum_type=power2_enum, + ) + # [3:2] + # which monkey + self._monkey = EnumField( + self, + bit_width=2, + bit_offset=2, + access="read-write", + enum_type=monkey_enum, + ) + # [5:4] + # which monkey + self._monkey2 = EnumField( + self, + bit_width=2, + bit_offset=4, + access="read-write", + enum_type=monkey2_enum, + ) + # [7:6] + # which monkey + self._monkey3 = EnumField( + self, + bit_width=2, + bit_offset=6, + access="read-write", + enum_type=monkey3_enum, + ) + # [9:8] + # which monkey + self._monkey4 = EnumField( + self, + bit_width=2, + bit_offset=8, + access="read-write", + enum_type=monkey4_enum, + ) + + @property + def power(self): + return self._power.get() + + @power.setter + def power(self, value: power_enum): + self._power.set(value) + + @property + def power2(self): + return self._power2.get() + + @power2.setter + def power2(self, value: power2_enum): + self._power2.set(value) + + @property + def monkey(self): + return self._monkey.get() + + @monkey.setter + def monkey(self, value: monkey_enum): + self._monkey.set(value) + + @property + def monkey2(self): + return self._monkey2.get() + + @monkey2.setter + def monkey2(self, value: monkey2_enum): + self._monkey2.set(value) + + @property + def monkey3(self): + return self._monkey3.get() + + @monkey3.setter + def monkey3(self, value: monkey3_enum): + self._monkey3.set(value) + + @property + def monkey4(self): + return self._monkey4.get() + + @monkey4.setter + def monkey4(self, value: monkey4_enum): + self._monkey4.set(value) + + +class reg3_type(Register): + """ + write something useful for reg3 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + # write something useful for field0 + self._field0 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def field0(self): + return self._field0.get() + + @field0.setter + def field0(self, value: int): + self._field0.set(value) + + +class reg4_type(Register): + """ + reg4 is a very useful register. It can take down the moon when configured correctly. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg4 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def reg4(self): + return self._reg4.get() + + @reg4.setter + def reg4(self, value: int): + self._reg4.set(value) + + +class reg5_type(Register): + """ + reg5 is as useful as reg4 but without a reset value defined. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg5 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def reg5(self): + return self._reg5.get() + + @reg5.setter + def reg5(self, value: int): + self._reg5.set(value) + + +class reg6_type(Register): + """ + reg6 is a read only register. + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [31:0] + self._reg6 = IntegerField( + self, + bit_width=32, + bit_offset=0, + access="read-only", + minimum=None, + maximum=None, + ) + + @property + def reg6(self): + return self._reg6.get() + + @reg6.setter + def reg6(self, value: int): + self._reg6.set(value) + + +class reg7_type(Register): + """ + write something useful for reg7 + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [3:0] + # write something useful for nibble0 + self._nibble0 = IntegerField( + self, + bit_width=4, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + # [11:8] + self._nibble1 = IntegerField( + self, + bit_width=4, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + # [19:16] + # write something useful for nibble2 + self._nibble2 = IntegerField( + self, + bit_width=4, + bit_offset=16, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def nibble0(self): + return self._nibble0.get() + + @nibble0.setter + def nibble0(self, value: int): + self._nibble0.set(value) + + @property + def nibble1(self): + return self._nibble1.get() + + @nibble1.setter + def nibble1(self, value: int): + self._nibble1.set(value) + + @property + def nibble2(self): + return self._nibble2.get() + + @nibble2.setter + def nibble2(self, value: int): + self._nibble2.set(value) + + +class reg8_type(Register): + """ + register with empty and no descriptions of the fields + """ + + def __init__( + self, + parent_ip: IP, + address_offset: int, + ): + super().__init__( + parent_ip, + address_offset, + ) + # [3:0] + self._nibble0 = IntegerField( + self, + bit_width=4, + bit_offset=0, + access="read-write", + minimum=None, + maximum=None, + ) + # [11:8] + self._nibble1 = IntegerField( + self, + bit_width=4, + bit_offset=8, + access="read-write", + minimum=None, + maximum=None, + ) + + @property + def nibble0(self): + return self._nibble0.get() + + @nibble0.setter + def nibble0(self, value: int): + self._nibble0.set(value) + + @property + def nibble1(self): + return self._nibble1.get() + + @nibble1.setter + def nibble1(self, value: int): + self._nibble1.set(value) + + +class example_type(IP): + def __init__(self, parent: IP, base_address=0, access_layer=accesLayer): + super().__init__(parent, base_address, access_layer) + + self.reg0 = reg0_type(self, address_offset=0x0) + self.reg1 = reg1_type(self, address_offset=0x1) + self.reg2 = reg2_type(self, address_offset=0x2) + self.reg3 = reg3_type(self, address_offset=0x3) + self.reg4 = reg4_type(self, address_offset=0x4) + self.reg5 = reg5_type(self, address_offset=0x5) + self.reg6 = reg6_type(self, address_offset=0x6) + self.reg7 = reg7_type(self, address_offset=0x7) + self.reg8 = reg8_type(self, address_offset=0x8) diff --git a/example/output_sphinx/example.pdf b/example/output_sphinx/example.pdf index 481c9cce5897908eb60991d83759d72f9fddfede..28e0201cd702f3a03c4b1af319565436835ff8e1 100644 GIT binary patch delta 73178 zcmZU(V{m5A8?_r76Wg|J+t$Rkott$ieqQn{Sz z${FlOZGN5`(qCAnt&8;U&ri8(1*$5}=(mEDVN7r;F&~Fwu1XLT2;`uL#^8q{Y=!=k zDgUHNzMb<w1FiRzSRE z)!$aUB=Z4%R<35bsItzuD^uBQF6B=Rw4BY`3}0jlD=sTuR&!1+ zCQEi!QzlMJODiTbb5?dHPAfJpZc|Qkb2A>$ENK%22M@>;h743jMhx_z!%dPo7Tj;^ zJl0fC#xYD6%+&2{64}1V2krDhoSz?qJ%olBCOqE#^kolX?g8vsMEv|e2cB&Y(!u?; zB8ev^s~@J;S*TaMA4mHIUwx`C56Y$@(2uWVvfu8;cwYOyW^cCa1Cmnn?B$l1O*d5K z1QaM$^;$8I8;+7t>A-cTD-D}u_k#8*HS@f_S>=7c?UBDjs?#2OHC2neh}w=#YEa>^ zKP8b2CZXC08nn!UD^wqv2ceh?6p>7bnv9z0hJ_F3;FJHWALovdps&RX7RE2KZ!87U zyBi$BS>qkwL=@TfbK9?Lhhg2}hEh|?i`Mvq*l>I+$lK8+Ab&T}c%BC*K8Y&h*8NmIQ5Rmtfsu}n`CT4!js0yX>3;vB8)Bg+VoD_qbiH@( zZc5L6J3jO+iqt1k*Q-m)nly^tuAn`BrhgNm`H80$dity8LG4-J#IPqXbfImEQ{KXz zDE-+b9+`uO!eK@cTFW$PR7ITJ6!f&EkFvk7suR`k&E zTj5Z8yLv;vNv7VkebsSz=Zm9**je|GW~Knk`S;`S+ZW&1Qg)uNBF>B1IQ{FsIhmKv zOeY@4;eWhtc_W*DfO2sf&X38CBk6-^p9>O5T!Mb=!G@BY0MD)g^nMUq)E#+8X0CKd zAu!pkOt7|rUE?7q7JNmZ!zB6Wn+>p;klHCaAo5XS2%LmTI$< zQoZa|_h#Z27 zHt=H@dZ*rY-jEoAk&?pU0!OxWSAA*4`tDzj0>}eV8pbjgY?AR8 zdBopp)jPNWuwsLE7*L2mMq>(PF*v}(&cTi#ER5jp;bv*-h~SfRsTb&AuU5;wd@>BA|hMK1Ol1uKGellgv z5r@+N2WnMBLcnm$=-7$&$V?QCvbRBG<9*&i0T$_;ghlm^u#p9tGX*8zww zyy5%64hp(%0mW8?K053vlFRTjsFyE0HQ6i@yedXYnrqZn?QCFkDwqS)1xC4^hiA(~ zh~Vn(iTK{@4%%?q^yz4%Gv*W1?gzNnV76$AE;z11=HNRRct12RCV&*d*lBlOmw3czbp3 z@7UVfGXElGPtVQl2A=Q7MSJ+usJFv>A9ounegPA)gNGg^{26ZgGt_|LS8g!uFFTEI zs0(KW_ z#v@U}Y~@nh0q)B`w3PK3@^FQEU-+A1S&F!~*1N_hfDqgxuze;~)XAi{k;-})yNtoV zP`bgchyvzZ7gg0wbl7Fq58O~gk3L<*D!m@+ctq5J zfw5-DO)U*3e%;pl=Yr{{!W;D*7}?MLAs=@G66V@R7T-E8O?<142dgTb8m9Q3#hLxN zxcIrUfUG`!F1zZKZAg(O3Do=Hjt;Iwtu)?j(nK*a>0k!XA-ZIu(Ci>7x|1DH*wq5_ zHc^|g!&;1K&%whH8$8r;H7`&?GZ|s>``q#u=|Bd~j_~eBO@#=4xyiF2zot6@xe6PK?6E&#Ub!>MreX9<{NC zeQtF(!t2fXi-sQ%9RA=UbaeB{{r0{MLD3U2qk{ft8L9j^q{NRoq!s<%Z75558-rx@Q#Q3dBgM3t`a&+uhDbd9QAI?L2rp$rx&B{@sWL*!#L={uIdY1 z-l}Jt%Z0^!na)$=Ji+II#~*VMAFJI}d#7bI=Yi+l-5YrYjO?)h(pBOkBjn*mJb^Wn z&g}>+)sXgMiw0UCI+-N_pv9WBUWlxwo(pW zAF@|A)hy=R{RDT3hQ{|E0%zn8r=@-YDe59bBEC1_#S0v;K|&t1xm#QtODSd@G(EnS znk{h*^43=6#_NHmwugRa_Qsi6a+Yf_3)hNB?;GLLD{%pX>w{kh>L1LI-4SwU0m(SS zFg=ba#{#dPxlj;7^P%EM=*p_*C*8LT@&578|0#W(P(xLELP?6l2AnMF(K{VouR{OgAgy(-5Vb;}q z>nLhcG;Z7wpdtHIBh}|6mqCmB0N0ElzC*RO!2W#a&gVu#Omt3 z%j4j6Z}+KJ*F*ow82hrc^@W?Imqp#o`Mt9F8^-9z&9~Q|{s#E4Sr5=LJ+M7%e~tGs z!U+0ryaYg06Uv$9eB(Jg1L*wMgaty=C|tbfIm)o$$hO4QG&2LgayK1y0d#yn6@=@@ z;>>svt4s_9k(5k_JFR!7Z>`%w{yFaf60g1FE zb)yM&5C)byt4bdj9|da_UgfU~S1|hAJg1ouTW0f&iMK4N2h88EHd91ChOXmKS6f%F z8n1RI&87LX>yWQ6|4s?@B2`&-FzSCBup;5nHKRVbSGw zT!&(L#nwz+9IviPLPnUBOX zsYyXb6V?8BJSg8i$-={FGK=rRcrqF3o)@9DHYVZPAD;aLD& zR(sO4q^Q4D@!G`-7rwahHQU%x6na^tT2-8o`{LMcOP0S30C}3;OHcfypxi-tpGEPwL7zEEL+VWy+cM}@0bX8G*HbMSsn+}_N2k+3 zdD;xCQIn+Db^CniB*hog%cv*>BdR7ZPK5}*RIe{L0STJ7bdZk4-Cs>3E%;~AR^)T& z-)AK&xV=qH!;&QD@9g}P7*th}t-s|%kZX#BGX5N#0qnxR`$|rlr^S-iKzvHfx3Dyv zM~JoBSBS~)(*-dlo%d4KEXL-P4vCXtp`j3IX=yD`qt3y|nuLXYvzq61$GvgelSUb! zqkl0WR>7XK_-Zs>*&po`8^s^^X468;QsgG4)>u|89i~8%KbAnkmiYm8YXq}hjZ?tP z2Vz=U1gM}HD8o1usUpi$X_w~GA$y?i%ovMQsSPNf3c8}X;#i5#PvC6YsuW+9_?Y_S zsg+Tf@WkFIeg|^uCc>Md^%fWOq(Hzd-=vqKF(sl%T{z1$7Ah;0*_w{rSI)8?qT78; z2R#2AglCqeL_YxM8PhE|X$c=t^=d3*oG%ZB z;ltEjWi!uVUz_Gus&E`R|IEZ%9uq0J|)CFQ-;J~}e1eelv>QCzf=HTeCO=%7t(wV)&hnTBIHgypw&ddwTv0gasF7hjP zY0jU%OBgmW*pBhmcl@+5&GW#{Cf8f-niNW$k3O?Y4C#dR=J1@$7seQW~u>grnThbW{lfe5w&P{2ZN=4bsbDtZ5|QjxK8SJsUq0kxI1R-T}$AiA7T zT^(;ju_Dpnb7Q(ZL{Of{mPjDfiRz!Ov+y%3?vm4@46BlitRiK1s99M_3wFt6`a@=M zLD^lTz$Ut(h5mLyV^3psy}?fHz4cIA!JJtvw*@`B#j0v1;!a#HsKM|KSh$=pkW)Uw z;WX`2z#4LE*pcB^$^8SeM}R|q?ct7NTe=Q2{Z&s78m4R8wk9mh6w>OW4(+Qm>DLo( zX80pZDh?&yf2B?n=z~q&FS?3D@5WS3Wo!d^Qu1y z57VUKu^ZE5%6@2FdHNSZ_y?8ZJe?R9W4>~gp!=t3mu|GTlJDpzz+Nm9q@kzCtwusH zQ>W!Po-SGw<_<-0-R-i<@RRo(6}BnGSboW&-2};Khi#lVU%IZ}D7O%&@@>cbdB2Uw zy+ab|6yE4!$TX!hL)yD?z~?5d%Tu;A3>zd%ytE7+k^GyqFDhehIkPWQx_^g|EEkP3 zAq54Eqex-wv46@Bk}}R zb^pnd9nz0-HEVq8N`vCu3-ndCjq6-4il#$+>;!t_ljN^n?QJ@J#bA)Cqu$eM{n`md zQ)&VfLGU9byhb=Kwpe8Ek9_|oFTQ1tsLw#JP`I3WJ{Hper!tD?n{lPlk1cT^O9+(N zMe~dh?00wMb$EIcc~@R(4;DaFsICNyM*(L_{UmeS!RkY#9cg# zH~bK#4`+UHPC{1JMzD0U_#bfq#rPvMN^`G6Qu1-LaamY#m^1NOaIrCQa+_K*@p4-7 zFmbY*a#`?NSaNgo@PLTRX+e(sao}A4Q8*xHGF`}?knKx^|2smea{cYZ$@v0|cyChw zsMoMmR3P=R4lmv9)6dO^n!U_eFC@DDzQDNqEr!bh0alxWZkQ@(%+B%IAc0J4NcX>Y zGX8(DE(TN}=f_ySJytLaWn~*6qFm&{KY{{Vc(1;0Rc;6vdz(k!9gkA`82L6BUo?xZ zrZV+JV-|X9+^r?wP?U!!qbRP>50PCWM9)yYXteF)l8e|?dJru;PS$I^Omp4|w8$^J zZY~iT6kpN0G|6v+$_0smJj*tZC=%4icbhMU0jCu6tr@?G*u~)&W2`29*waVABSx(R zvk-lFgtN#nb>ttZv`&4jnQt|zjAPL>>L4c<_n%%%JM=_H!N2%cC@@xwvyFmRZ-cx0rd_q>;mlMF8rd@l8M+5~)^e||e3j+CR2@2_M5_GQ!&Te**=_U|f& zBcpk`iAJg?eP^Fv64qM=3AVR5Cf^dO3+)2_ZNVdcI(E2qAMP#T>qs(`%$zG_U$O_G znv3NBC5&n&3u>5OQjv~_Chop(ll!$}+mNG@w+G@0BL9#OjlH=1qlA!*~(W=SM1tat}kzg8tMFQ zKqOK3ct%STYyP-1=n7(4Vde!}w5)A62;)wL)mcxsv&ryD;)W)UOVeb_^TXYpZ+LAU z$UrsSYRoYBik|QLfpteU@lbqxls@-!QDo??a;BEOPub+n`v$zqvoS%JpvW+^U74e= z-6spa&l-y~2#(pN0)j1FXYq`Db1R95@HRsE+PS7{$bUJAOt@`+ndw%SWo7DNJI3us zL34~$Bf5Ca4Tba4poIQln>^Q|Kd0CfTp+l;s}$^fME@LV2EMQWMIi65 zCXZhipZ%mZOg%4rs(!^V)Y!GEV#RYTaeoa)f+-@*x-_w(=(rK5=>l&bcRb74O z0X6Zv@@;?%1hjS8uJ_lwdCM~a1RM6MIim$6QHgqdj6s2hX?=D4C#HPRe$y%y8;ANu z83PYHZB=cFUH7B{FGY)NB53WgHylrM9GQw$Erp?tF=sJn74ofPW4`U$cu@;~5S{~v zI+yy!SzcNk@1V1?9`*M2cb23(TVOuVrf3ScYSM!i5OF4>yfG98&9KUVR{1~ZW})SA zh^hHr?oy_Fl)*-nlU@fbZ7AFe?n}5;&UQAp+Ucn_^p*RbR5MfF&=5fYt!VSYRqOdU zbKNhiNg_MPL#Fcft>)Tj#b2+gBaa@RgU3(Ec?7EhM@L_U8M7j>NBj~emzETld?Jk} zbahf*OCM>h%b2f+wlG?Oca3`{t-_ttk8)cfC-#B2~*;0bSmTO-HXtQ9WCyRuM}1 zrM1t(E79}cqSFPyr2s!R=&wTV{JZh7^>EOfw?&1$i%P7p%|*^MQcligM-6Mo)Z4Qi z4iNw6!aP}5AlG3~5)Ff1#{^kt1tN~uK(G>dD{D^-nIPyV&%$^|*QTRT;CocmIu`mR zB8NRNHa~(LROnJ%)cvND({(o`u>ZEtwZETNuUf6w^~eJ#i$s%OF+Xqhnbiw1Z4~$V z>TnU(k{4r`)?B+{rixDHiGXT*=?~eSR9Q$B6T0l=rHKAY8z`;{JNNuS6Y-?#O|1oh`!hS}v(crIun?vs@zgI^4ik6$P)O!YH96z)7^w&n` z$0puucPVUF13U|z-OAoL{@E&bjL*ijxAuL29SHb*#-Yy*9PH`q8S44=v_AASeG`=5 z^EsGGa6YaFZ&&i2PwT$t!R_aIyMskKLruje@NV3buq!k?ta=sqr^GYy`HOX{?|bWc zUWcHnQ>f6TdLF2o4j(A1} z5T7}nO`K(|&Qd0I%j0Siw=J|Z_SFU6;;8&X8-zeY#kCW<>S698^kTcylXx`W3X&}F zM$x6+u#U-+<7KFLit~i9Qu{f@rD^GnN`Snc-P^xe%u5saK_|c;X2UODH9ma z8~VXy4{p`vSZWc->f(_mc_N~I=^q~7NE6LO)h^xYUn7mqEd^L{^@dlgvK2Fszr)Ag zkBXA3VZxpH8g0od6hCAxdVS55oh&X&YY?Bqno=ZbBqcPg_sCTKhWV|Dkd!lN^aOyG z!N+d?rkQiv5c_OI>C51F8Z|7hTpC%)NXvgS2KRt=HV)J11BXDa-$2erv)V+J`A&)5 zPq^%bQBZQTp@f=E5uHshkU4tbjyFn?sW|&BE-z9{?D(9QZAIY^8CkkeT zI9~Q(s@1ZE3l|D>zwRAjyya-QKQI8%-KjyEm4>_eC0t16jLtpQ3B5O~DaXh186oVaTI%X-2!a2vWIY|qw_^AXx_!8+2(RSRM984M&Ibm3dq7Djr1*P1o z>QDm&f%172_O!_)S#Dbc1FM=e?RrW2EwnYp9Jjj<@d_8OU9^m(;B!5pW;5V`w%n^u zFA1Iefi!NT4!xYqO-@GY&^&D%yUMJuqh_R3=-l!RV^bpls#G@^1G$0)6*#0=!^LvbZ@F9I_(8o?3p@R^<_Nf7O7@~hKllNJL zF@TZ0Czn-mAm$AF4Q3C+H0~6-#_FlsAZ0N2KC(;y^6slvXsS z_)s4wpNrU{``hTDUpUtpiML|$)g@!rKchN(;+U|+iCvG#w<_P|3^t+i;JE7}d?z2J zBWsr=9_H<5J@m&cZUg{uw)BhOukVn=UtT8;|0k4Z8S~O|)K%z?fv~lgs)Uk}MtFf@ z-mqNFMx&Aqv}6GnV(&fLxU1#$K;kTxzOFt+oPkV=09czfcFD?l09%(Vn-1a1t(Ja z*U7101!aWKwUTNp?q2`|I51yP$3ZEfjzwfirKI3&NAor=Jx-i0N7c>Huk zm&6ps1d!Lw!V$3352Js-$(I(KOE9dsUk9;u&9AE1Ne4*ir|X^3)zh6v6ju6ON6b|? zjSiO2rxn-|0FMaflnl*--$u9;HmBNCze{pE%VMR|ugH_*KuxKa`nxEhloWgtQ2ee3 zN2c&FPo;8TTDd}#M=C9~vmuv_hzZpoS;G=YK{I9V55F>_>8eBwXKg}5B+_hd#zi!T zGhJ&OO|j$#263s1zYpzBeo5g_E}{}J^E{Jin;Cr}2h?afV#<^BaU1LX^Nn&Sg)7!# zSJ}%Bp0>>8%qWcX{Ca(74&yOLW<>buVkjDzO^d&^X*?7tS{KB=x;Q;;j^v`0TLY{0g zTnV_hsrr$5IAtHl(u)B)k!#!+-j@At{Z&*!)3H)kMRiOKxK`oNSZ@k_SS5NJK6szs zhL#Rcq{zMSikX!gC5n(M-v=l;5M076;3krgfRLY*5<9kcFn*>GzajRx$1-@@B>Z81 z7Z6eKDWC9;uAbCeud>q}tXQJpmF{x4^wY*7C z+W-2snU#l+pz4Lt${3eo;QA-LBP&MY?-butJ2@6-!zH!XTDDO8+Rg6guGO;wz}yMv z-8m$%=;QLMKO?Yzb!BMmUw^?t)qhfp-v3n$z%iBgxLl4)UEXdFI-YEpj=ArsMKG<$ zcz)=>AORUvWg&X0-q!`iaqMxP!*(H(hzP3%un&34T>FwB1U$b1xWj?bZ0XU{zBY!v z#~Q;6f{L@J0Oe2*bztwAuh8AVuhtcyZn^%JK?^I68T_p`5Wr6ye?xUm7g+9B4{6`8 zzdf%tw3t?|7n)UHGSvvsQAkt3mRFAXxdzTub3t$Gnx2NGXT11zDXq!Z%TSJi!mJfr z%`uIpyS9^W33DAluk1PO(Q+SmuiVqNjZ1BCVq?9uBdgcv{#6DLUi=sd6-PF-1SryxM`8wy}pLtN8inr5;Tmy02;)?%tYYa3ne zVN6}VF$8rM9C4*7l1qNV6ElIu{lARH@xM2auOc4=J2$8gk`|cMb97(lM*o;HuHT-@ zR2Bt`T~;pPa1BtN8+}k;Up~(Tp~g&rJX5KVrM8DYyQkF~81-ssX<|w#2uQ&%_WByf zje?ts=)Ty;U_#=>_ec&W!6zVnu;UBq5sXqc%w@3Y{|wJ?G|l8?<^L^bPI(+> zu(A@UeuI(bK|<5T#d&gdA>9Ag24X;Rfb9^4K?+;>8nsx>%Q-RGkC#Ip$|-Bv4))|y z3MXztzA$5XD2#}WieqZr=_7VXms(3>jX|Gy@&f=?v$?gZCpcbqBlmV7M}j|}#q5pb zZuDaEFm==wi*cK~rnx;PD}p$3;!=HO*GJV4MPmvuIq0%1Wj0$J=k0kOmd^biAorH@ zwK)aDEdcE^pSOip>Xq3o+u(q09w(+ai0LO7diHJ_Qgx=^F&- z*8t=tNI_$!=J?`g$MV|}jcot8mQApik%|N5)ZKdeP446C+^N3xL5b4mrB(CNwr%P> z{-FWxn+-bRRv5NTx_s_~>0}qKTvcB|2jQ6KSR5%|FOKT6fNcUzslRsYP8F^k6bB?o zjAI}>?)IA3MMXFF_1o4nvlW4yfD-pvEFdY|tc3)Twu~%VNm9U}z~6Gr`18S8+%5h$ z{r>sv$^K=MxuRU?9d1YZ_qDzg`t4=Vhwb7FUmX#VhOc&@lMUSi>50SDx2YFI(d}&C z*BohQR;u*~nF;-F!bF-G59SU6y+E(KvFS?I+P%&!jPC}sUIrYslZ7p@el@4W_kdSn zpV?FwI{Wid+{-z}0H<4ru$XS!WdR{JszORf=#r zjn_<-Yz>9b^pjVxl2YK)fUvLJ#tb&04Io6J6=Pxht!5o?Y~*Hiu-k zL{Koa9vK2wic+rj%#$Cl<|+x}uWlIgku6a-6NafyOWC3#u=xFy4%!t=Qy6a3$ALVQeCq5o&S3ro-%j9C2U!Q zaZ}T9;J=RA6GVoQ49r_LQ6cSXy^g{1a<+NcsH}+?$s0h-^1|2dh>odzoU*SmAx-&Q z-yxtBy?uY5FK(hr$^cSRyCT5kw70y=C;pzgt)a_CjZyPFY5Fjth|<$MdB{1!5Bd*z zO+`hHyTQq?zj^5WE7b4tT2nqFnJAy0g^=d+aaa$MSJgL;WxSnq4htM{{rPQg z%sWiru_QQ$+*SNL73~&}TWXXuX|oxh`1dKR<2?lu$qH3^ZEzYUv2E-Ko`TF)3s+TU7q@sNO>QLh>ygl)gF3Gd-#0=+whSHuds`j zhRH%2fkEkIzJy$jsY`4_ZHeC`Quxs{JsM5~Up@b5sasvB2|rRUABSXn=o zL*u7`HIuvX+4K3Q$V519en*(>-fixcjh1ugdyp!HX~aL;sGIL}{@{YXVctJV;{Hm5 zLes}GAlC#vV)2Nk9I(QaQx)HM3$C{de}zAcA;++EN+6B#_uj!Pin<5#HxrTF|2TD` zCLb&%m$@kiC%Y9VlNl%Pf9{DH2NN$Z8y^!pn-!NCCkLCk87J5Od=yN>Vh9e7|HnvC zQrTer5^?nxOV|n(KJR8^Wm#T}s)*R;DT4P0c9Kmirl08hQ!|J+o2V9}@)A7c`C5R5 zy=gX@~i1{ru^s8FDMXPMxu4Um@t`&n&$L!5x zr(l%#D~yG6i2ydhj_of)+J#c>a(#h1ITT3Kv0?>m8@9U1EQum^WWQSi^C5p`=`LB{ z;@_7^_Y>fLXd$lBxyUW4l`Jt@)TYWcAUAk0AvYwj6{RbC;2u66&!2COJAJNrEZ8T> zs~E|E!%`i%tUYt8`un`xT>g2YJ>9aA7|xf?Xi9?IkyKZkGmV@gI32+3BAYoG(IcCX z7rvm7Qdp!qR%xBF!krMe!}K}xcOV#O3?inX~9-(Al{LQl5&q;kMC z!3oWhQn->*@a&fy9e&suLm*m4=|54`sKR8$`wYHJKG_e9+?D?d_1?^B|X-rcPgF~dX35Y@W0&+?tLOU2D-rxBky6Du{e2v>2s+ zN4J%0c}rsYXA~Wq3dn)@$5NWSI4q3xee@#1jarDt6w!-ZxmBbv6=wy&Xmm4-cwJx?%h{ULR0PN1z}0*Zn`n(!#x=see+tB<=JI6)oEHvH8&_mc5Ud7mgQ;`^uHFf9p)Z7o1`|9!9S zWtkah5!r0-+THLr)9>b1_cmQn+xvlTdcfQCIl2Yos8qx^2d54}(NEV;YZ(b=?x778 zqx{7zg$ivDDw5J)A~zwJ0@np9VSan8N3r8>+uV8k{M6!(H9z_B!I%~C6}&!0UY($v zI#jeVZ0?XvH!(Q$fE*8~twpUUY^IkqYN%S`^6-AR_we$eOfPNxS=v!4Rt?H5cD&h1 zRS>|o)+U}Zj#r|_h(550%j>-FDDQdxHf}6(pDWVod8c69?R!VfC@Y5_bkv)`zL)qc zuRsaTO&ESWfm=77aziiB_#zIzIJ=0EW(g{1+mJg(VYjMvi*EsftTR3g$|~3XxZYoV zAQ#py!$f4Pb_^z#tyC$3eF4KaOtI`kVU_;!yQ<#D{9lZ47z$!@H^{2Y*=~W!t;2=K zJ2>-B30Q0FG5yhMZ}ysSRQ&vQxKw_vaDRW@>R&>$?sZkJ<5hWyc)EqrDAXz`5sBTa z21b-6N7+!Chd>U{l70UM!7X3Li(f=e1fIxBUpFs_SaTwX2$8_5z|$>g9nVoM)8viPlUJYe9XaF+Fs9Ld?F`L38^Rn>HadyZVsOrg^7jD z(`J}Dtpw(^Q3z%Fd#M{G{<=^Dpt3ymtD+m+4-j>=8pE~4ziFik>x5TNP$uK+n>YB0Yd-C0|NcT}-Aly!aIbp&mnOdle+uSI zc zCr_{wx78UV3~|}!4$~Q9hY_*Liil5O-==M?%?)*e*DKVj02bfl%+J`HyVsy@Z^7gh zwi#WV(o1s|BRuqCG(9IJW^v80hKAk5pAXj5)_bGF!c?3XFgaYT{Sdt4l(^-fvOLG& z&#FAY?MvweBS9p1=5LfpxXfia$W3sbF0pTa?eFt%Ma&W@_n(N_>N50N8@aV%*?y)p zI%|Gsl`Hy5(aD|}NJOUdv%E=j?BhkHQpqy^Dog9ILoQo%gpi{BH7{WNO%yr8IL z?WdnsWY-4Fl&40kZ>+nPEOP7F$vuSE*XvpXpjIM^FgLHm&9WPqW8h%p(xiSFUN1Fs zFs=x6z9g+Q2>i2(4MWuuUWu?o~rBdfV{(|rKI8Q=Zd0j51UXL4m zfY1k17y`An+?gz?x`r0>iKl8XX{mxa`C?`2&xWyGP}Rp5N3e0WKFxyp(;FXwSG^Tm zRUsi!c=~sWN)7ZO1Ouy&rQ~<)blMo~Y+G*kg}n$LkMwxLpi|7v`oRAEOq;1srn|#! z)Z!LC{(j=Mtk3LU2Q6co4At#VV&I4ffUXbOzgvtf-rz5+Gi*%FXjST24TAtUJOj8# zc@nC{AY&!V_@A8%j0%GaUC`Sh|H3os5u0vkf}8#!5it7s8Rt_#bTKFwV{#p|J3D>3 z9_VFqRR_;rmB0AFgzQa{>8Ty3#rr~{R9Z6}NgcVz5k>OR3FgN?Dn|jq1VLE<7(qd; zmXY|2*Qaws(cd#-Novo$F%B2YBr4=m%)Q2W6y>D2Wj9YSV$gWXN05Eh_?BFdAPzSd z?Y3xFzqHnZ8m=x;Y_^D5i4i6z=8$;ZK zkJ^vQR~9kwnedu*+q}QB0G4gsf({>*>QBPv; z!a5b(;aRdgr_ml>6;2>HSIEfrKU6U?n)RK1a=)tanOO?XN*t9A0qwogAm5)WVD5V^{aLT);ZymsCrW0a#< zT8f_UI9p@M!{=*dxY^*)n2&}R3@g2X7ERPHyPiqw+eAR!0PxKs(Foe5mrlX6iW%0p-b6ck0>i=*GB-)1l?Z_|1(F=6;dP4xmFrR%Syb7cK_YC(~FI>-C%mF=! z+pQ-C`FxGMBu*xhPyv=c$E+ZP-;KtTr4AU5kt5P$yTbYq-#yJYAQJa=nm#{)gkJ9q zqyeF1QDh1iVA>zYt;Xpc=ltYb;d1{PFHXX(+L`y|mi^!koAq0pZ%dflMAVUY<&Lzp}`a#3c@o3Fp#J>B5 zWK6hM9SsB(YExQ>xlWw&Ef4)sytyB07)V%t2+k5g1oB%-C77b-T$R^z7W9x52)FXd zXJQpJ`_o19wjw`<#?9Pw6pMNB#CE~%-zhp_fby*5i)=6UNOWiU14(|Nd?j~$`BFse zqEz2HnfMZewj#P8A-EHvN+r7NLrQkvvlnT7z)CFi+o}eTWohsD=A+9(6*-rk%MyD! zDM1h53}Y?fMj;azTy>R-NODO#p{Txjwamq6Nv%b*kmAIlgbR5ZDOh84^TxM=PHtO}Ggn1&%T?6#PrgPx8G&CTcp(Nu+# zA@RNSHU^O86T0CMqT#q1d1~mDcG$TU-;~}?zSKO6jTWZu=yMV9wA2Zk@YhD_4FcOu zlOTsIrx_x9JT&yWSYza(Y_h2FW(>b7XWL){#p>PSn9SHAZRpQjd&)H=xs*8CP=%4CZM`)mQFqksps< zd1=lGb8Jon)o+#@Dy}Tq@Nu*N&H6P^>q#ZpH^*);N!qE}%88~eO)icY^Ns)VkE{mV zYy{jHsCbG}6rFX>7UmB z)w2J|fU8&qb%hAu;e4D{_1=cMqysah4$HhnX=~_^>L_y=1=VXT|mjw0As1TW>h!zeZO`gco z^np*$TK0LNQ&ThSH5jC@5g?o9;EafBU%l0hz4a;*Ep9R$@~rHFb_12FZTUq3LR6sh z7k?RwIINAdo5TtZ-5|w2nZGnAFbn{H# zR0WqZ2!lAwcTwxQxxfHrY|U>kwJ5=fS}UetDphkpMmJ*B6J2(hv{Gt8R4@l69PcSc zWq(YWGdhFfA!_9X!QpGLte2}MH|n_}KT!5cPKG{^;bw6mZIw$j zs^v)tPs##KRmHjxYIfYd_zh%VF-KsCFs&hOsk8kb_TD14l4W7HtTL6^WoBk(W@cul zZDwX~yUfgtWh^tZU1nxxW@e`LxwrNA)9W7es3&~}A??VJQaMPacCP$leS43#GbC!x z>JaoC`0Oo5JCJiRY9bDPUdF(Z0{jV;Li+V|t9-hlRUhqU<&Qly+dJh$--XE30k6b7K(*RR#52uodqWaDZ1K(L{)-wo48RFV46|Nm;HbS7zFm%76?s< zL-uCWm;N-HpMKYf8quwpJg|3v2Hb?0gDJ?q*_wQV-yqW3#e!hL2Xz$ECI);9CHaXG zCTSCOLaZ!sMEpa+^k=9=qM#9kNi0VwlLXGpg#c~j_au<;6BVsC;i#Hk0Ze0Yg=iud zlzrzDjFICxhs4e( z{Q??*4x41eTQ21{cv^_zO?H$jQ1 z0$2MQ*|Q5YFXPFhAFOduQ0^ALm{OyIn?3wt?uV0h4A=8MS%Vdy-_iA72dq6dfj<+j zzT>rBN&+`G%bJqWKd(0`-tr6ik%hrN1$*u=pWG0M8ux$_q5W=`3mx<+ALR_bpSwns zjyM~>tJ{*jvk>wyJhtu+J;=dd$&MjdZm}LA@S18mq#}J%=AO&$B}{i7K=1(+ZTYmK zh8q^%8<3?PeO6uI8HHz)Ttwr0l;`#{58;fWJJ3KzkE9O}aySXes83$d2R>;dBz3y| zO!_gYwYVa>LB^*s3AfN8<13jRl9bbsgvcYZ1^!$?*=#$DzC~w%Lp{oA6fQ>7l-(*4 zEgR2EOIo0b@378Lm5M%2z9i_;iG#{Lc3%`f19BR14u!)Y?&JHP)=X7GQNFVvdeHCTcY8rW|GxOaQ{uKkBmUBlme ztlaF>ug65O0wV0~@rgSgrCzV#Va>JmKoi;TCJJ(aIP-P2($A~vJ|1@W+fB8%BlzGi zr8K-HtK2qG^9UoSR`2D8%N>8wTbL`)f^m{3^P?YZ_ESD8?SLxkjUQqtp^dWhWyJa7 zNHCz$A{x}o-&})24TwHy&p2KLVzj7b2W_-n%99?LW$&UJW}Md=RR^^!xS4PoW?bv< zqU8nFvSgU1P9^_6BPkJCz*7(`$h$U*(e&waz20$G@^7y|M9;X z+j(ixCpQk&y+CVb-cp!X3s0qhNwUK|N1B;qLEVCu@C^Z+!OVL<>HGb|ZhDyRNRF4x zkzY_yJO>`{jc=M#KSu`FoeLqZAO<}=-e(bXKbYnxo~l0fHCCPC8xJ=cc|(yD0eUu= zyzv^%?3{xu*~ksNq4no3IFDq98mm^^7pp`zUL9uXM?hRF(Yc3Ga9u{#JGj_=BM-C8CV_X7i1|x81L$ zXZSlL z#EdA{!ZKz9@U9h?aoQR~O?+{yYf9nsBes}xt`lf(pF4WO0Fd3BDM_I_*G<>%XuYCI+=Zu(?qRh-^Fnyw1SSy@Up%Q|^t z$iLpW@(7E2d1f0;J=Aj%E&u#Ejz2>3f->0_fsCfdcj0Jl9vmXa0%M(9oPU9}M3T*J zRggJDXmD>^vLME&26?A_7Z%=e4^UNCZYuMg+}60TZ}@Ah=4!qYSu|)C%;rm?eRvKw z=!sDSM5}HHTA@smm?Khm5lV1O=OHN&&%A}!EzYYk@ly*_MQ<>+srcm@ti8Ir0tz?J z*DFk$*MFFf1Pwti`B>dz}|BL*f2|vZD_{bf25U1SRmO8D(r$$ZZT_% z!tLF&`#bNd)sO|YL!#C9nt~=-bm;>`yaDFBF5iiiXFoCcZ5W$VN^a$ZE+cbe{=B}v zGC29FsFy0~#(VF(ziD%m*Ayk^6Nj}b72;or4C*<$X%>#fixS+JY4p~rhJ#CR;6L^P<(&}h1%w}D#Imlv1DmZ4Yd<>po_V2f zk1MMZIG{nqy|Fwq6)NnfLZjLR23^J5-n}V^rZ4Utu4ssnE1|lzPt)GrZ z5{pkmUDv!`UdgjCDPCqFK<&(&w}q+Uw7&r%T;l-?fBWBt-qL<&v|0({u$FcMgYl$D z;9ZE08HB9-zTclcIjbBQL1&5P*-jG2WD|MtP+xRAWQf)?&tRT!+vn=K2M`Wo?LoJ! zo}e#mx$geap!s0U;B&d@k~R~AcJ(f)VsQJAG39ad^uFt|Zd!M_z8a~mho783oo@-N z*-;>1!M4nhDuS28u3LaK9m~lNf== z;zUnfZ2Ky5kro2QZ=Elj$oo47AzWXC{c8d`h4;ijxedxiFIos267Ul}J)_wAp%hWd zc2pgNeZ_qZT+@6GzTck4MUTr~tlu@JqJm%Xt8cUWe=f0oPUC;a#Sg6lhHs(+{Z7wE z?s0W4!yfru_7`5Lc(A?AvusH}cldPZvO^r}^>Y_KKi6I}2UsN&{V9R{qG?`GUO|>KL<-B_9oD*x9{g zU6*Neif)p+@)``vQzcgeD|1wwar;aXXg%5V`^)-cGJPKG^uS#oORx6b`d4p+HT$CN zh7kI-yADOLJAMzbp^on}dCX?E%HA_8k8oV8$iW4wy8X3Z(8(C3#H96|4XLG1Du1>o z$)l*EFezMgz*7nW=s;*2We|L#l}<4Co;hRg8-Ur#qs-pl9iZT z9OqRU&;&}GbMMYhS`(30{|xO+Kq@bu1`xH(g4M^Lx>J9fR7xDDJy;YL;(~V3wqQh+ z+1JQ{E>uGGuWm6Y<<=~8<89cWJyA+i62nZ>5wVzlJ3Gb+?6u-lHmM^ZC8!X?h}yd~ zT}}!XT_;dAEjlp<`r=D(3?Imd7+08=o>*6Y3mF+@t>s2nzQhZgpZp@LQaaa|;eSQ;StP-KgsdA5HN8gG`8XHU+WHa=~qwOKLqsma$ zqb~7QL&EHe7t+C$Yes}}`hAuqpFRd~>#cl#t0;v|i@&)8igd}OSsh?GC%y70ikOqB z4+TfmJ!dAx?8zo^#DUU}Ih3R#sq1O078;$JJIl@aq-sgR>>H6rNKNFZer--jY$C5L zwN9w02+`&m&u9;jLb;()lHguYTRm01PaGlfB3cbnHs;rmXt#J`1n4F+ z<)eikH{Y!OWR;zdNmrPGBK|c zKxH|7!EIKl?X*@@8JU+Q8M{jlX)tjvJLjEgn@m&*utle(hOtnDu>^#X&yk`6(Bj|u z_M}7$=>#E7xXy^(5`OJZjvg`*7VnN~eB} zQCCs%M4j&^p>0})G}tcT@0?a7TT1vK!M{DnuA{y@`T8Ew z#gFXj(#4NQ`!r}w{0w)H!;qzC zQxs$-?)-dk9Di80w39jS_gD+bXE5X=%20FY+Zp&MK{9;s{ZtDdy%!6nmODSC^b%o6 z5LO1zzh1&j<^v$Cou+EMf3~$SrOBW4)%g6Ol_{Re;hfyNOJ!BU`ziR~0(tERiqHha z4=Ln8Qtx%O8#UL7dXvwiI78~g7Y?UDVf7k^vW0>?-&XiV zdiDLTGS<>RHQE)+rEjDmQH8Z+X-BKdBt741>2@o?$h4|0hpBuoxxNH?O&N)~MZ5Kw zvA5}tZZg_Cp4)~sy>Y+1dH`lb!siXxjMlu`B2UVzs!^Tz13|U=UWE}>XG`w!npHG4 z_`@!Wco2;x@)o&_Yu~)v7eUdeg?C;6S&)f`f@6~0wLjWgBr$60O82Dip-P@a4Vt zOFCO5e6{l=YfYV-m`yWDOKM$k-|pw;QEf`OT;QD}%Al$=RSMj0nq~BX*Qie(=HWxw zkLJ4VGtjj?;YHt-@WcxEK0aB)6}2D6R@G5fUy=l+FG+%`k4Bt>&cVx>Be8xTjMj`x z7R+4F^>P2O(<6S<=)C)aHSIG{Kl!fjQx&yNer-^Uw!ZZBgfzZtiPIm#o1hUjsW%n3 zFJ@Lshibz*!~ls9vUL#8j+kRxw!;##_-%;zNO?()g}uaZ%R-wsc$-3;F~B}!*Zs;? z^fYxGydoL|uW2!C;Ct=2U)_-%bT}h4e!`sHOvvBJHG{ixMj1HznP9Vl^>)9}i~Jk~ zdIUXQlkF|!zqi!S(vV~DjyuA82JhqC(Ts8)!JdwNL(w1)AUXvwOmbl+Y8)_hfs8U} z05BoUzRtxtSjjRKZ;YOQ8?76e?Q~}3++7nf{m&#Bw++K*;A;XCdVS;yqMn&1^-a%t z8`+QEaVkp_sZQD*xS$50Yl}6hj!z6ZJ zh0V1HfH$dc{NEivJFoZ}!quRA(wmMtkEAuOgI=_Diem8VFUNQ8HM}t=Z66t{mB{Rv z6rFDGrSHaIal_RWV}vdKUTELbJ|FB;?uN$AJ-%{vsLrD<*kLY4q8i6#FVwv>^BDB; zz>ns5=M@o8XD`K>cObXVx(@=2ALLYjmHvSk(`RF#ybg;<+uZBiE*Q<)d4XM7zQ>tF zpV_y~-h7CYCU_&DxHO&7f2xd|LSB?6Z^C$!WU0cW$DYK5Au5(Xwcs>x_9#8^vW*y@ zq<)unkCEKGp}|O$BNq9DTgIKu|9a6xuCpzO1S4TGVqs+EVEHPH;b1WR!X_LXw44m4 z476;_rbZklY{o21O#e75>%X)7cbjEWioDg=Hp~9Y7Zk3dAJpk_)|!h#lqjAOr`pHA zS%!s<@Z#}a?oaux%F>pl=xN;D20eKs`8T>^?{ACqpSu~G=T>vfZmr+6K5nKrKCT|_ zR-g9A@r55|-%f_TUu`>XA2vi@m-)1{)a@oU@pMwvl`j@A>u}#rN9bSYH-KqH)~}PW zp%0?{WrPXZzk+yUgfys@5!r*r_8>mgm+T`u)+|d@a34+jYgA6$()Tc>3s0KqsiO;( z+*CNE3NMcKF+m67P{jv0YIlY(#FcQMb|u1z4RKJ#BJ+N^Cv7hf>d8I41BTi@X2g^A z-@9yO_M9>++~;M?oL-lnZGkmuc;it(cHT5P(-bFYkJQ51juuJjr2Kq`Wast;Jv_O0 zr4NRrqPxxoM3q4(i9x6;Zg{v*a|Jz@v^69eo)>8aTyg>25Qt?5tY~o{RO#*`i1Lh)d><29?I(*Krn{4j$vK|6ZjU4(5NaQWEGu5}Dr=RePbjfbARK ztJoEPp*nNwOY_Xw7lX<_@D#Tv{*zzn4RV+KTJR2qCw9G2g7kIOb*RDxwrGAHi`n(^{05%#O8*vp_AbNjd0 zsi&U*ElQHzPXlcGd z!1vi@9jNa#l;KhI+>YnV3pR>WJ&ts^{iovPd7ZV&s0+pTVug9K-TehU$nJyC^oeZ% zEai)baPKww1#nJ5Bn$lMIBxg;_KDHN_a8By zMR?8bFIu%y2CzKx^XY!>dV$JLP+(R(cLX;zmAD!B;g_+WSf02xyG0E;?#^3|Mw+W9 zT8Ku;BUrzw0KpE&!Ja*Te(Cxe!WwE+h!i6<<{d;sDGv;EIG!-c)m7Ez8c`I&r%rx3 z)^iSNT2U-5tQ}NTxmv(4^kwKYQho2_$I0b@eW_T|=(ez2%-l9lbOT7eW9uV7TVK{x z>MnPejD|eq;PY~9@9FUot%RhIzsQfXvf)@Y(G zL7)(F5>P~irXEQ=?{`Ia)Cs)ugKWw$8nDdf(li^{zJ3Js_ALA67koS*DQRUIT0#SLF75 z-bW{k0s7E6$=JIXm>l2iN0js;=g)=|i+CMY*0k~ebuaO0wepP8_dIrfolFU5#S9A-)sM36)ajWu9+)7b+&h@3y(qY z({U8=+Vk<6-^+EoMcq4U5Oh3YP>j3`x5At2Rk+{eG^~|CXU7LE&vL60d5H_BRaOvn zw1IjLASRY&ChjK2#akcNyZzCPSW_6#knlU}!1<-Or(yaz1vDf-U)X2R_54Chj$Y>^ z8;JR4rI*-7Qm$hT3DC$F#eB|t;>K~%QxW7eJ zzfGn63+d3@D(g@@qXSN_O1#V}N))zp8vo+3V`C#rjf1rq2`x*y4jb54SDgH}*l`}U z{Ml<_!{abZ@*@Fmm)r+=TddA^H>C000Z1)&Sx1*Ffpa9_*yCP^7u;qsT>`28OhT30 z^}!WEz!?s?7~au+o`-e}=_b-Dfttu#%x~ba-A#b`{wO+ngYqfL=5y2c7yU38+SI$G zn8C}Hjyav1m8;#ZXf{$0LthhZ;Hg}@Vj?OEIB=t_x^D`!;Ci$`Wsc>Abs@9aD=-*8~K;Bow&A}YX!`~9ph&1 z-`^(HpQ5(-8^?inF~(5{Pm9l&w?Mlc&o;-7h*S8^+ce^)0rg$jG9x+^kC8n6^_ZEt zYlY|=YMuK};G=J`y=*nq9yhY!fPG_oOvmcq=jo!ue?W|Atoe?3mmBpPxr1!2Bx7XF z7l^sM4+B}Lmay}Mec`A?Wa~*;nq=GDxYIaaWb}>r8*u3^5R;?M^1HzosHbVgPnVF^ zZgmS?`Yd1J@nHM+oAspXb_D)aQ-4TaDCXu*{F^4f$t%-`U_cSwvNc`8;{CAp7%wkn z!>;@uKwrZ30H*l9VL1~eZpTem;zemV6(OiMexFnt^VsDqM1>GDWi8Qj+gS&C77}~A zSw+TYyJ+XO4j{!=bSFdz)I|HMQj4Rgq*NeRep0*eO#&6YAYE4%UC00nQ_mU>*=7Cw za99m@N}_W29GpkE*4mb_6K|_WOM$fzDd9sUdLhAIrIhIB47#%iH}(7x@@ZB(T@s~9 zLGo}=A=2<<=7=Ciee$dc8;lajjAQ7O0$){%jfMFflu}{wDBjK^Fm~_US}ufrA-uJG z;s84LsIQESMZi4wC)M8V^UrotD`nDQQ^$DOczcZZsRC=_IX2DqeM8dt=6!?zkQjQ8 zFA}2>yNGTO6E`+k*gN;zAB(bw%#11{L5`SGR}2ZUD^^IyGP!LV%IEi4=GSX6iIZ^S z%Uz;skc=c(YY)(%=#JF~&ML_Z2hrV}>x;yMGe2j>Aso7-ab$zii};rOK}wNRR{J6` z6wb+ux<^=&pvOie5lUk@$?agG1$ESPWinayF1<8K~><3z0{uNQ)UJgiMaVQ=_G0pcHje?n`=EzJDVk;hoD6oHXtq zjR@mOR(5{M4NNLzSDjjfZoTWVaacBx%N|Oa4|4u1yg-Xp=CEuoCwE8|v)ZSCaVHjW z!8}?{$O_D$W@jlNp(iV37t@9>NupVt?F|Uo``#xM25>TQ#6Od*B<#^xm_=n{u!ae- z=7Z~&Ba^~QjuiZ4RKSN_AQsXvEuZ%5REm!(cbcd$f0k7f^Wlz5fD==ilwhB!nh+Qv zz3<8SaeZ^ye<;h8MuPCvwcB4iiJDN=FLZ9N{td|XV(hRCNak!1e9Blctt(epHA+^s z6gFKJv?7iPv+OUOrsUhF(5PxFvC$A7}Y&Ag_O-diX5ez6Q4; z5Wk_#0KY-EI%dUI8NU(9wJFRb0325|23<)_q6Vss(#%Vyg`3RHnE#?%4PzD`Q8u3g zpkVkZ6ZTWH(~Y{%q$&A#WP(@g2>iw5o&w77$j0m1Ekzoi@?{gt<)C$=%)zXc(JG$` zdR|?ZTRAf)uMuq0Yjch@t{=ZaSMU8G(3BFse?ND5odqXF_%ne5sSWIU@Fx*k=+XKM zMiN-FtC5Y(7=|$1@b;GQe18~AU(4nXgiGOb=pnMu5{hC(>2jUX_*yblZJkp#XCHSs zrwgEh%w^+YLVDa<{DO(UrIZnuoANxa=TQ-sOZ{Ggiba`XJ)Bh_qgJfeNy2IaP+)$7 zFKJH2usaqWr_`XV#0aukAn78(I9vhleiK7960V#`{-v4-?4jf;jwN zre*bTl4MJC*aDeV@h99;yqXbSAErRp(i9%P+ur;(=C=|VNqjZRX)stxd^NV3`f3*u z`vNiF&y#sE;%a1y-Xd4B>36_sEi&YwEDc_rjSrV^W7796Gg-BTKT;@xybr*negN`( zjUi~^$zN}%Lu$|H-`_4HY&=YGI^Lf+DxM0B#v5VCwm>>N&ac^i;chI^{-_>B;Qz%J zcHCU02oEBkcEiXbJ`{o3tc~B_-L_wmPexkL1L8iWV`hy)0P|(5%s5@k8~dh_xJ$we zVgKvPRv8cLpYSECbhsr0S{g!A{OF@iWVdt7cmRu)`dGH_#@puP3<^f3qUx&#d`QEd<+J| z+rVpKQj^!JuN2OrFM^HaI)y=Abjt)gzN>0A7K{&JIqv+qQiE6e4HY~7N%d=>Gt?4Y ziGHn@v61+1`ki&3KmP^X(_C-X6NY^z!%4njiK&78wH8Lws3U}GH?3UMuxnI;sVEZ~ z-pYqEVaSP;1TN;OaMhM+hq$c0SVeBFXrE5F9iD`I25=_jOxL{n?_R=d*^FaU@43zn>Byl8uZ2O(;9 zHJ?UR#&ap_4UyseeAbs^TdZk7aI4p-jN-jQGy> z{{&>X)8lCVUjiAI{{WfpM~iCy$%EzQhPVCvj`!`e<0gmE4F2G=;^+B<=ZE#yjb$(7 zGqYD~3*8Q0vzE*E_Vk---y9p~D(cQNbuXYY$IN15HwEevcxRi#Yk@5o2^Y2h)G4O#F_-f2qtL z1|t;IzB1S*_-n`7OLE~#d^#V%GpoqOpa@;aa=7}qGh0(k)+rDz<9K?l*=;uASm?q@ zj&D$tYds^QUWN0H#WAwmwOvggPtL*P+K|fT7&zWrmc1L7y{rF-6CO%IRn_{>_2S_U zd>#FrEv)#E8N54f*nYz4GH9%s$Xo1EESX)SlAEoJBMpAasdt|loS$HJhavtCjTs6j zHpY?sf-yj1%IH7`6%593Xrdu|pEN-BjJ8OMF(=859BC6BGWIVQFPQ{b@1C0rm5ozh zFNuUmul38JMr8{-9W$guZfK2#tP#&%c}EUtjhQSd&-EBm{@|yYok0x#_&3NM@o;>@ zHxj|Z}>SJ6tqIz;Q=;rvJ>a#|(MAd+xv=7g=l;x7qyb=|myN`63+tP2LWImAe2 zR=^@iGzLVv_R4}#1c1h$5d`SE{fEZTv@rgc#>DN3{bUb=%Om@(Ypj-m61+x!z#$^N z_yZjNwSeIu(<29kM^_A-AD#|YT`Y+E7F`!YTjW3Ysc28qKS<{PmQJy<)){okPJ3P2 z_e$BLOVLVd9UUd5ywD9t%0Z*FY(U@>QPNV%YqwfnpuwmuC+-^e(itcoBBA_ zTjSo$bTU0?KN#yE*^R7mY#cx_9iu-~|2R0@^bTNr2Oa2RzD=RW>a}F((OCXwyvEhx zXzF1r-+zix-KF8OpN3wQ>1%hM?~}T%8+ojyHAa6HzX<|g?zhkcCbUnxD0>I|@t$0` zA5rFyR}=h^lW*7YbmN`PcuNO-d7Qe`ny9J_1>U?-8%LcVVN+MpR2GO^eW1KEmRB)$ zXN$jH?)aFW8sXNkNl^ZxG)vvm;TaFyDpn!zO=L`|EcvP2p1$$(_#wD`JC^;9=QC=& z$^G)+vG4WqwH3U)E7PmVmyD_pK?Bta&}PJ)mUqRo>umyk%SbUaQAZ4dU&|Ice%W^y8pQF@#)~LFs-AbYE72YX{k1|aJ|1dXy|k1N|KT%e>#Tg%zCcd zYE}J4eo1Os}8f%}rg-?gFi4%#2W>56AL*u#K1`cnjx7 zxj-5;g7;BX8C?C#`;59%@q_8*mvNH#4FJZhne!^@s;w?+gQxXWz`)B}_GYbN^Yug4 zj&-e2c`nBc7=A$baYfT_2?;c_kPcN>`NH?)n#=HC>tj<6|GfRmHV?d} z96c`A)C9~USy`JR>$&AWSsArx3R<3@4zh!o_Qcd zetQRYPdA9_Hx;w3#CkTe=N`c^*Bt7#v?h8VPx0gP#7muHT3E^5bSUe0Fcn!Mw{E2A zVX-`B>uYIBf2~$-8y(7gsy{DZKfXlE zyTRd^Gv*E(xf)!kY|74G|3-*$y+;32c~666RdrDMt6iZ3}@7%+Z16*O*1(4(Heq%hBns{(y z{~IRR8fs!xQF0Y-9*}tkfaf+wxQsTCJ%^t#&`kUtaOgJh+$rMe>iM>@-Cf0a;10^1 zTM@WflFP=3Krw&D+Sng+&7;4+_yl*Yd+k4M>5Tar;pgFdKtG#$- zc^Ah!`L|-UYeGl#?-L$S+neGh^;-6t@T*b;)(&7NWr`U;ZmOi&o7y~HT1;NxdzKb? z1~u|veNkV-mk~#l`Pqmq$$0WM59TpLgN^?B(*mB`nI-7<=0dYM7^-rk? zxYM#V8>HRvNMAdE8FQFSf+Nt^UWg6RGJRjdlnNrg|{a zEMKV();u@(wt6^8!mMC4Qo0FK9E^bkJ*o8^XzSjiLD77$1Hm}FmYdJVYobZVO5YIu zGZo5sU1Lxyh>jK(LDtOi*ua-8gR$;+Iic|&(-!zJy{Ky5jLC4V2mmx_;-M8=m)Vv` zcg$Tcyk$0iQW)|0By@ynl)$FUFnQzvHeGPQQ4?vH)W&ACBC6IhS)!j?=nK^t@}^4w zlO||*Kv0nwc+CnH#(BW!UBBR!KmlT4JSi=r7IThs@*mG0`{iGXG*4aiAwN{L8wHz6 zsnX(ms05i4&jpYcHNXj#90_wGrDDJpdt+I{{#R5p_z$XSREB*rz@wJ7BQh&Lggp*g z&8uBV=g6k~12b$LQ4Z8%QO~cPNKc)R!Ep-h{(0oW*0DiVz0zl0q@bM<%Y&b?0cpco zpw_M+jDUa_|B47hnmK_oQL5ClxZ~Kk8_dE}*zSdJgZkdnS(p0^TJ0 z$vWb5kVG}+#Z9l6J_!|eIY=?vH=y#WIVy^!n+AB&O0MeEpLGjVXG>r=Rr4R4T4-BK zH_ad>OX6hBo6b3>t9lD(sSlj<kaY`*x6>yr4n?SC0g<1AC~S>U>{;j+Ml z!1QiQAg+>ikKD*Io%BW65bsiqR}HFI6uHRk7(%Mb62B^u#KI+YP_sfsF~#oQM)a=% zpAy*cuP)g4Sg&l7S!2wO#)FR3uUZiwM_KFDLEwpy^T8+RtBf3c251o81+n()76QhV z`+JS%4XEO>oeLYR=zbTFEW9r} zbp(V<@$;Keh<{j(p?0~#@J=leqNdIz3!Jezt`j^Tm8mn=t>k)SN&#G2emYXd#F`Qu za2#?&NxK1enL~BO5yfT}&oFwgAp7abbzHH*Nsg2?PMe`HSQyosH4Xvf@XwcBMh36+ z_eTbCXiXTZ*ij#q{8E|0-$5E9E>=}>L_r1?lFWxNO-5o$L^4too`|HoZY_zx-|_UY z3JnW+^kan0$6ajF$*XUOPKjuR6!3O!z}QF!9@^z=nPSF3(5!lTB)FL}4Cs=OX>8!r zdOy_8Zfyq!ZGzIrmT)?W)b_|U%*3E9T@Xj`%e15(P8?jA3|A=gJjRGCTB|$n!})LV zX6EiY;?5e{$Mqlyu4)Bj^h@G5f3Jc9*`qz+`1V z@d~&Bv2QcqGP~*+4sz@lXx{J0$2|H{v;n%2b9n{E(B0-|CEc= z#o}&cU#73u_3JwkgjI3I_5q=YBS1RO1d!a<{YkE4fGvmh4qZc2T>6-FwjJ5uzJwOHWXt(hx^(-H8 z_oEX!&Tw+~)Q#RY0+=u!j<-NRv4vNANw>zgrnt5Y+)3SSzBIb=Tyx7^LNbQ7ZNPnO zi?pC^<}diPSt?Vle$@2)k&2+z(eFF)H&ijFsuG~`c5Ue822nNqCe6{CwQEq=rE{&( zKfXv`eOR>YZ;p9dO?kh#UUotHn91=Qe_{88&n=>?ynX1!#Ya|u8hyFWQVSRH^*+?J zj^|n!h&o* zsea$9%uRA*ZXE!L?ge4DEsGZAIjj7t|oZWsKzBekc- zVv)u){E_R@X3kk(van_&Jg6GU(2wE8DhWXZYXz>q4?p>*6b99NfHoUgyn&tGO6r^S zo-gZ1e7D8lU2v5r$Ir87veXcw6m#Y?e*J#A!`z=!EDtsaxm4f3GuadM`Kii2UUYVc zUn9hVMp^}zrjuYdiwZ2EtUcjKCLKi4%%L2`QwGdC&`3v9)?TFA{Ft}-VY=$?q8wyh zs=%IU%@%>1Juz8T?CzV(&+nLZEz9`%Cwf`Rl#(tyJpR_>-QHZl?ZLbGRe!m;uAgTxK;D zVzD*x0c$98hW2rheROy0$C9A^isP6|a<>78uKMF*!!@;TlYC6$ zC&T-7th;(1k_kgTR_ZkASl4{0&OrlRf^;dG+)*B^sR}r=J(4MQG;%9Nz;f%Z$^pq( zqv=TPAWF$EO-Gw;BxTKy7R8q5+OF#KiG0?8U64P4EaoBHz??$qQekl-cxiV z$%Y5wshlumxZZwQTQ~b?v*N6cGihEjKwNNU zF$dY+_V^Um`Eu8OlxL6+c?hlR>}jC2Q8PwHK#nrzE8_%2Uz?!tNWk3NB<*bZ3R z^K4U|@o;S#?R@L=%i!=c>)K}8(kfu?taqD$@!fV7H!Z)tOxKT{{v9lu^2UUUMC`L5 zYQ)-53&jbH*FCKb!$A_n&Z@D;2E}Gt##X%#u4OMjfdkkn%x75JlrTeqGQKZEp@C-S zc+gq&rJ7>Wya-GeTPufF35Dz?WJR&dMofiWF_^V3IZI(e8RkVqfNwMm)funx)5(E< z==?kYXM3vgbEcV^LxKel=3?Lqe0nnbz_+$d?|cBoTaNe-TtZ&>^Bu^}%E9ozZGEz` z*B*4)SbzQY1QCi(sW1mlFQC*1-cK$OfdaMN9U>q_AS&gj2PUCFbYD#=?Lf&L2jF%< z;i^PlwOGGn#9Mry4daHPlG|@gqnec)XyA4Ma=arqHN2)?JI`Rsr<<d=p(x zUKs=KnK>L9O=df}K61zKwh=&)1|}w)iV&^z1g(w4G;I2yVg^?6ma4 zpH;sv^;_*d<{yjhCZ|3zUgBGu|!sBDLd=qLtyW^u5JJE#Rc@^1Iwu_RoRgSm*f6ScH#2;AY0`?ky4n5C6$=G z{!74}e!K5;Lq7jgKDz$Xfi!*l6^M+4B;-Qkl2<{L2+`}CN<8UE0hXVhEL0LXh)R*9 zz~rC4tB^GA^74L5pTx`4(ALJWTK@CS(g=7_%(&X<{_*s0ou!Lx*G2OD8vi|iA6^93 za|~;in73)fu)i<76BM-wXTQ>u^Xcy)arR!ROZd~t^P$QhX)WMbiHaeRS!r`_#{kt}6opS_3dNnYEmvpRj^w{;$ zL%fQLUjpUxwr%vYw^i;&892GICf-Np)3O8r1W! zzcA_ax{9Bf6O71~;5Mk2NbvpHV z@V1hw#lt*ybAw&1_d#G3&>*IG#|@9&m<`5hzK(2%poHDJnVCGkoi8bxqi-V~Rcwef zRT&V@zT@Al%g}^d?xh|dwnSM{Qdvq<*Hz@I5TX^Cqucc82U>mp;OBHSefBmzFT=yD zRd~kHoi0ab^Tx;f0{EC4=&WhIZd@nggZzMdAS@wZ-D@GC{{iH{Lxjg%;NdS(kVGQr zlCg_d-yqg|uIISRokm1wDiJxlarGrj2;-olrYtEh0V^XQr8Wmo-=pY9JBj#V?K#q7 zl`^}&)XYE5cXwg!Hz{|izy2IL55;XtILWm{UXAYqIQL=;qjVhZ(CC|p7(yMm z8AfFAyP_lN=>F-q`2?&9eGhL#j{TZB_+p?FTPr^=+emN*#F^~*WMzd@VnV4!%guhmd~#cxlXDX_vqi8(3vzHDBJWV8MPLNkVkq zYUVEyI4Qswbxxg45Jf0WXi_7vfr^$Zzn=2+l)~a_fpvj>#cHIYRETHJm=$^I-0@lD z`p7Blgc=?KK?PCYiTR!!&6EA_FjL8euuYq?53>Fezr8KMeGMeZAe0qO595-T@9@A(oFq^`Dn>S{zgt8yQ+!{6zr7&oF5bSNP1{Wq0QC?p)L)6{p}|!|0L_iPB>=@% ze_>rwLZo-1+EkihX#vp2M7>z;2?6g#9=IV)impyZQ!V6{uYd>!8PNDY*n6k%FdDdR zx3O*8wi=_cZQJ&QjcqixZQHh*q-ktBU*C7{Z~qhfIk?y8WaePj%v@`J*L}UwE@QAo z;BbO-HH-Kda~k}aGoRprBpa(BKWg_+70u+wjeX+U26+GAjbmUUyuv>#x66)sq|o`{ z(+R5AG0l&DdAeP)6s*^11+$Hfx$+uq3%sHdJDC#J;+y=qGqT`b zp|V61IG}Ck8Sv)Y?I(JkqoVXYzJJSdCUKVg6Nx?U{t17hyYxcjJJ9aeai!zx_5QY( zQ63xU=Z`>pXj}sLGrkwtuDmjar##qKwODisSI=(s~Sz}V0`AFb*Y|#G59N; zl{aQ)lqz|wA`kw#xfCDVCN+jk7*OP3tMs@Z2gEIEyNg{8JlkT+F9+WgbbXIqNk1JA zN=3tr$p{M8zA!O;#HG}miL`e%m%MIdZ{K%@8fRr^$q|j}b5E#-?#abKH>9}->p3}5 z@f<70IU1yp7V-6pHBR8p!_NJxwa(@qt$*Ke*xB!YM0bglT45d-&`uB#1C}!WUr3=G zz)tD!l3q~&DMur67HQ8bs^_8aA5K&YK$7<%4USV2(!T?+A13`KhCIaUsbbxo7+T&Z zG+w`Eg9S$SaH#$$azW?#WN|(cp0}4w=Q?a$P6XV+REiS5q0D(i-lAQTOC=%<~ve_=CQ)c>Wwi)*~gd>uIn8&@Nhyd?R|JE<2z`6(S`at8>v;aRWw)A?-H1 zVBKDFhra7&#evw(s3kXg9MheHr3T~VS`f{p1qz6sjo)Qs<5D%Ah)FCawn{#zCRT>U z6??^{wVF4SHaD-cTLf-psY?!rLip{R-8m)hk(Z3F8VL?H%p;dVt~Qj4X5(}K3QwVJ zrj{>RiHqU|ESKR{>$XjO+4Ytr#KYWC(^b}8%21@KlP)~X9W&U$R&5UT{b5@V)>tu| zmO`iVZf!1svPa}8`cqY%G-z-WkZD0%7&3pnw+NyzFuJt$|Fo*;+6%PoNLLz1go10J zSrMgyW}N)7Qhcl_=E#u-p#$9jx`@g@WhLm+Hv-BqG>3CW_!M^nGh0=x5W4D97q9nI zA!2_vI2R2_hBofd>(+JcGU(&z?3(gUN3{KY$wTtUl_7@}a{&cslhTE^wEYHfJm^Z&vDsV`+eMc7wu z21Xt9Q|0I#i>ILm(pyTZ`?W(6DZUYAN?WMxY`IcaTlnI{{6H)fJ{0do&kt!E-ZiV= z_M{JCt96^bRMYeu+TOF^9 zb)7RO$Z?B<5z+TeY!Oac+i1mX_S=!@+mKrjj7uvc+|%Oi{NXx?%5>Ug{Y-eiPNzRLB?DDE0xrRP3T=>$G*?y*7mYL{ z9y6WsLHTfaaOzCauj4?Ub_}|5bU=G+4ujNs{bu@ z{u!%1{_SfC{1?29JjpeFNP3;L<-Fs0TiFnFP9wfU+pzv8@E5|hxLJL~F-WpoKY3&Pdi9b9HVT)p9|HHfc5*JXbVS*(WGy|rt` z0}5NeF)W;YC9jz76|pvOA%Osp+&CgmnHs^Nw`liS!|Dga`aNtZ>36){cN+oLy1x49hbd(^}^k;)T zRajjd`sywhQrN{<)R%~rEO430%>!Lrf6dK)P)4S-;77JFN*t4E)r<&q>osa#OsPo4 zn%(hg>?%Uk<4<}8&KMWJ-KXOV{WDj`2}QeU8i6ZR-KJ|o9KL0XyEc|oD2fqd!;)v; zW@s5nfTIW@qxxdeooqJ~qd>~^%mq}kWBKJH1!XNy#~l~8QA;>kP6DBp(I-~& z<_i}a#Q4YIJ!4DA8Z79#2tp3NZ`;H0`$uLzEZV#!@7J8<^~!Axp8YRPd~eJmxqtlo4-6r-ixsjPX%0V_HfPWP}SY!mw2@dqE$Afuookw0ol zp*++TnD@Xgk}z9@zHC5eGYYq-%nq-mp~#&SF%r&MNc6V^&>&J4vnoKPKLb+45wUQF z8kwyuc!>U#*a_S%p4)mWL>n8776BbYb)-#7ZigjLcE@R{Q1X`$zwj@ye-Ysqp5DuZ zA#P}+MCH*%i}3mvh$S2_(l}m8`T|7MQYEMeHc$=xGKxUBa+%t@Q^GUU zcgug;>Ileow*;BbCF_$q#E9Mz=87B*iIGEV$gd>LqPXidKZBP|qj~l3Ur!$TTb>2) zCOneYNH?<4eZ5i0JWV$yBDANMU7kn9w{cPLokVytNh;T8t!O*QU5uV#dl$j0h8E-W zW(ULoAK8Z13fXg6R$wdGPR;&zw(A}UIDecSgKulA&R+MA zles9y5IGNc&wxnagv1V|TT^V?w~xsKtOK6(6Px7}a3q*#koOgK-O`iVK`jSDJUR&D z2nkw!-&a%~9`VP}3CXNoZU;?`YMB);cQJk-PvS3Qh7)M00j`C$ z*-^OawcdXPGQoXF;UaJipF`fi6nUIYj7rG+6o%SM1Zr~B?${X=#++6PIqA%n?OKm9 z4mH}|@wa^Txl+2M_jko^1%Hr5QT#6+(KynEAU9<;ykfVRnDqyVP{z_CY z%#QI_pO4kQ$UJ|zFN6mbW48twC3&#ev9z%My^N<}-HCRRz{S+3B*$keVLDbt>oT2e zlOXCWujQ<7pSRAgLQxiD;4fJG5oiQF^DHtIzX$u$%Qr~ARFu*3T%C>T z2dF=GZ4DZ%WTb-%MYav1Y zIcfLytdVngX&3djej{4UeVyvWO(_e&Y3_?=G=i)VKZw-d{GZDO_M#bS4JG85!A6Z* z7M&!pFqk(lxzl(M8@n^SFIj$M8m96cO5#n058D0+A9gd`RLxJPZ9*tbpRO3Bohn0Y zWc^!NP+ zYVYK+ZK8d2RnKbMg>nDuE@4`M2P}&>l>QC@$Q>Di<^F$i37= zm%*h_{W1f5`$4Q#Job)-&XD{fZ5GO4Mk7NO%wR&}pQ%QB6~iAR-AYMZ2Rn7+c#aNp z2QfN2F6zMuszxg2Yw#L|D(3&+xyY?~;;#|sgW|DAfHS&U-lckzhu~mX;2On9c$T1y zn4t#77}4gj#X#?%*wzdSawJSF{_p*Cas3}|{0}$&ha3OHjsM}s|8V1fxbZ*S_#bZk z4>$gY8~?+N|KY~}aN~ct@ju-7|7YBo#sUh0Ma#ww%Oq=NZ{cdmO3cc_$;tA6H`$1p z|L-a>D;oKY9UF@j5+>Oy*y+xsC1vl~?A22bz;?-wGiEK)otdrOOlOG^tl_D06HqLaVJAh(b9#Q78f z3p%kOmGGvRY`p{c*6>LxOhbs zrDBM&%AgQ{y;myG|69?yEIk6yIT=w7TW(Dg$-?q}2|xzG?7~i1y=0wy(H?=7VfX#E z7OF9qe{2Czzfm&;2tnCHLUM6&dAnd)5O;Sc@pK0xEMI|FV5a8bp8u)>$#bAm!CMq$ zaIa?rL4bs&Jx~bv4F)-;jT`K3^;$};vM4CcL*hl_#Dby5tJr$%&z1d8s&Eo`*(X>` z9R(9H0YrR2T{w8Ba+b^hB@cXwFqT89oHO@%s$ZyUL5B$YVA3$}xtYQyAfF{RcTAMu zEL2n!^S*TPgK@$e*#?0OUbgp|V0m3({SvkHUq2cip4=d-dYUkJ7 z(@!7lfyX>&SKBUM`0dZ94cv`(Zl6z+jV}R7lerEZUa((Z81whNymnxyfs{5@PhY(4 zzaM+aU?V1+!MNA3L8kJM$d2Ko)-%G_HaCJi`N-b&VU%R%0sr0~xQ|R}hyMJwuVK?NduvCa@0oqRj5@x4wvh*>5d1y!-vdEue zX$@?RP>vrm@W!{lE50@aCIq=~FphEAfcnf6q*YP8`@}Mv1Bd}M zNanJ#F_{Ugh4FaCX^kwr@jEzq}Ev~-7 z-@88w#l!XWLmc1vR6zH71ph+lBfi(UXBq-AM1F~C`v!0P70jIu0-p$=&;_d(8xT z68%Z4DDdY?*p~QLeK&$7^%sMY*#|>?^T*lj5HzXTEz%gcA@c_wi0Vl$$BRuLytI+| z%WBYHF4vDRxH5V+AFNU!1Uw`C3oM9R^BpWm!uSOVx?<*)2w62~T9B9;XumKR1Krj9B(U86%!k4-`D*oyZ~W*j7gihzN69!#&c|gf-fnfQ--fFTu5THGienQ-bF}+F3 zfk6#xc{BU2Xv#!4UVWB@YN$~lg%WLdXH(75?)^FX|n7Xi*2Q!^`MD-IAdsuM%Ia4BXIPM8Etz z?W<3)omd^(_+2JEyIA2yyVXg3pA+1l^5>3(F`03|*GVX>x{Soc!EHAu15HFUsZqnq zS+t^F%ws$C$)`LhT`9eOUKNuxWJN^C zQa&|KfhYQOWD>!LG#xuyqlHxv9R6lA>P`J!=x-x9omC#XZkCBcB&5hsNoRu7wUF^+ zA|t_}=$hd*1E{q(KjUB)(vH+C{90;m%_{AapU!*v;P1M+@LsBiMVmXoifD0vcpTVo zzGv)gnmDym+B^Af_7~qEliO4-XEK~lV5sZQ_bI~jj^%n&aXWbo+p3C#g@VSBCa{#1 z9}h$zHfGjop&0s+ux=4vWvptseq$U=GTm`tVRoB`6!C zE!)U>lLiDDRjX&~KLR2&kofB%CSbe#*VMlE7;OYsYCJk*Rpib~`pf?`((Lz3qPEG*rA3*(CwrXrV`!w(HT$X!QEiN-R3yGaK%o2+PY*w18>|Y&rSu~k>=X2CZ z`WwAO`#A*Z?7v!(%o~LS@JG+2aK`6f^$QqZ5dcbjRG<0O&SB&3>piT9tQhq8J~U!k z<3=fI*`{05-f-t@9b7g^i3J=>8&2r0I>j@{ow$Y&BBQov>ZbzUINfmE=j%FyF-bi} zo?tF!VQ?IC1@HNnJnDj`wiUjwS6i=-^6z^r2QO6K=T7Q+qleNiJ3c{?*F*T@OhO|Y z*8@-#=GzRDevBB^$sN+_Cq6NbJ_7sKHNXS)@&?b-U(uS3c62x=FtvikvWX2*lFEGq zJO?eXp)=|*6azT}FuCxn5~9s+9(I~$GH@bRxA*4Kbz zhkPR%j8Qf}&xfmIWz3#&_bo#UMy1XjWG#`O5GS^nheX!I^XO0B&PkEt?6ntKheF8x2e>+9EV4>>XI^B=N~l44oxS%5$a^eAe9;9EsmTEYsy{7pzUI0n&50N-q zDAJJX#;RFF9jme3zs7b|x;|<%-`~);_gfA`1YjxF?0VTb{$MR1y}E#F1s|C`e~(W{ zSTRfFsoP11H!6m*&b2)@T0luf##o>rhdNm-fDzD|={AdVMTnTKx6LjT0iCSG6F8LR zv&->Bw~rfebaI=_?xnDjnE|fjZGA42NEL0h5K%C2381&--l*R4%=A8VzhH8K@$$2tZ58T{K;MdZ%4avjyLns6`^ z-TJ5!YrGlr+d8mE}d_V;2+)5VIe*;f!eM^u_VTb45dMY1tzqO4mM4Bgk*MG z*FsQ)!YFQjAyyA+9Kc?+=De)&@NkZ(Y1>L|ug(5dY_fjms%i3@IvT;R$9J3ZbnY*z zj>qOM9Q3oA<0{k&is(QVlKNU$Y2V-&D-Ali(~Q_hZjsFA5Xc#Gia`rLhWR2a^$w7K+=al?0|aEJGayfJ4;N)e(Y6p z@D>o^EAm9#g?_zTAw&CwJ>;!gyQ#e#1Lv*zEUs*a;J|C&lEoV^Tf@~~Xi}EUA%as6 z9A3#4r{x#S%OM59|FnaC5v-5L2;y<3a#z&LHWXn3aYHa?Ju*hejOy#EWvPKwN_iR5 zq4UZ~eJC8YjR3xw)34k5n-e(f=41^~}-HOxN{?ZD8lv<6%XyO#2D z);_(mi(xpWjzsj5xfiz~ss@_yr4rAqI`rf(R1aL_hvu%g2^C2ezAZUTJ@W$L7(M=Y z!OZNbsGA>##0?ALNC~I!K!M-dc=t4k0nQN{h6P9axPQgt(noopV z{PdXGEMR>>urK21d=;a-yUulWOZKoP+{>xzZZqhji{|yEm#d^_Pcclb=bgbG6c86| z?u#61$U-xK6;3}8bemO5fvu%oJ|-9!Wr8nSv{^-W)|4MPlyPL`?q3y$#*ChQ9Vcl& z2tb18lSOsO7fazALrux$bFycLQ{<7#MjmOw0~Ux9MT2Ft*~zCpZLo>ulcW4470A?U zlNose(qyC}&(g4_t_5LKi;M|F+=I}EEYnvyfU+$)5M}>*ND`t;aHP|F7b-qb?W^`dZgIkhDuI*0c2}Ir5hp%dS^9Kca|uZq&Yo{Bz`T&NN||>dRAm zziTNMv^j4etx!5{UIOV_f~v^{g2ZdN)9Hh_%bKM7XP-9UXIefBg=zK@ZDQ0rJ>sb< zWvIj^%dR}%OZtr@dr*CjY*lNBB-jfjfbIE5wbW#W#e&Z7Z=}pqp=P9hBYAT=>;NhJ zpY8)CE}AXVrm)6*g@jKxV*HqAgkRrdRluq)3JT*F{TwNE=c&ax`zS@Zsb8G80n+EB zyIrM(LxJT@fn{pN3G3kU!{P@zg1?DhB|UinPpsv*71S+rMQDHF?GDFQ89Di1CFU%) z_lDp_R}_fPoa*qc2ieW`{PIX{RZLh;k3l!ts+=U^T?^DXOqQgVA|aZPYsv#+O}C5s z>zn%AB~RDrQJYvf9gDZh{jGmF;SywY;b~@!*tYTyrE?-vWt9%igM` z^DnP-5@xEi7gxZ0`1DTsh?!tAUDYD$Sg@J6?WQUy$SFrDP@Olc9n@n~T_mCY&CG!l zirPDEibNzp;Xx_giErDn&Bj3RJ-gyAR+aerXMk4a)QYMlI-XO4FUZ~l03APR7QgtD z`;9J0wnom|3UAO3(FMZu9ox3nqhm`)xLRpxts?66PK}^bQOj(-pmH_Boi0~T77pc- zz%T9C+&d45dwf08z;`<{=fj2ga^?CRP`T7l*Yk ziiLX_jR*YCJt8%EqQGG&L-edTJ`4*HE>7nkbh>J=FprOui1Y7Ivo?L z^z+;ZUf>a1o@Bki5R^TXP2{8{11I zZJiR1Y}@Ze6#&P3@zeUv6n{g6%8~momk>N1HWz;HRKwp9yWvWj3Z>ebUg57jF~d=u z44)#Srj<_G!@1d+ySkkWyK^T2RoF{=i>${jD?NpeQrjYcL{Ok1@*4y`qpj-c(}%>! z&pjsBg{+-HND=DiaO>9($@%W9;!6kcG8-98s@`?o_U znVzB;%T8+ENogdk-UAYYFbb|g9MJJRaiy+mJbgtMtA6w< z(V6{@4bagYaC|}37HF!UUhdn>-MsRfhg0-6%Xq|vqp;)r99PivdJuizH8nO5~7 zB+wHVims+duGTf_rMSAxrD3C)b<;XVw2iA=2oTR28Sh-+n^?$oF}Xi!Zd6?_btprJ zfwZuz+1hdtcl@q0`njmb!rO#FPn{O2TG!bujO7FkbWUxJLs)mV(QA#=Wh3UmQ0mtJ?NfdR2oJr66$ z12zLfji6a_D$BhDv1DZQBxrgqm1;}Cl$Hrw^n{{sVEG3Zwh((F(`|VoS9Cjee#1m; zTDza;2&M31G9FQ%NT-7KJRiJ1Le#YVYt?g|6Zs>e0sTwZ^Sj=vAYC zVW8FSlXLW>*A>(4`mMLdp4K!^%wHw^jQ_oVk%}G$*W0f zPN!`U!p|RR?*;m@{kZB!kW>M=tjMLmv!bAHNHS%C;^1((8sX}q=TM9)SO(P0GXPU) zNhFNIHoooe3@Uu2X&CURI;XUB$gB(I#L$VlLdM{5lb} zdvrwllXS8l$ExRyy}z}DO$?kU4AkKf&T~`xO7y#>c(Q$*qfWy0ZjJ%%*_=F>Qw6T*0%hEp1_}E3L zQdt;#L?YU<-3^SX6~1y6U2)lgA0!Nepii-TA~FUpysYTI*lUXo!H0%C-kw$(8 zkC_`%eI8#GaG2>ZG$k%`G6WZ|wI;R9@Hd(i&3S2LM<?OP?iPhqc($FQM)*_wpj!KgIU|eM|k%W$z`bKs) zN$F^=Xfwx>;%@M1BLv*mHZ~i9c()vBMb9o>q%R_iZ@vdO99iXYm=R-YlukB=1j?Mk zInL&{!y^9+7lmu2Dojx-0f4;hM0?nuQ*K^?TNp9rlSd~oMU}fIw(#A>mv>nYp_6@r zOaVknkB;n7H4eG_E<5&A?M>&^+pj({&!o)P+S7z7#owfF6LOUGr<>dl-MJqK1?Fby z`;#7Z`kiJV_`+m@3T`{UcBJK4DrEQV6(7HM$p{@Y%yXt!bGvn#a|40UJ+aDuo36@z zLF=ZVacNoZH@|+PtiHVadX}08VCT3>*lg4cqm59o->PxF1?jr;9NgzfWziG9kEIXE ze=K&c%;ZnKHQ9()GcR7suc*F-)k;;&Fo5-ec!09}&K2Q2@{s$3;}RDd3w084`l1+G z>RifNH!9jS`V-3RjGu#eesx|DOOd%Cpkn|pE_L)$QE6_ive75>^!OhL$!|{Rfct4 zS29=W5$?WHE<8U%_c+=ca8tN1LEU&B+XPLguC_Cnue>n%e*%9s9ztOtN@U02NvIx+ z-Pe23&a1EIZm)8ZB3;WAJT(6Jf7bK9zFfOfX6EOdbkNGr24#Dkn6dkg%8cuUg7sBnr)dkk6KPq z+dn-qA1YS$|Iiaolf?OwEXw$7K>O{Hs1R@Z74E9#CCA_1Lu_`=($@VllgAIzCSfaF z7435p6m2}a6zlJ1W0BZR-C1AQ@u=-GRkS|IdC^CY!32Jxhjs{pL7ADldNi(3X;}-h z*lDUk)h8-9SyP_+|Ni3C?iYCGQHJ>FwJkI{ZFt>sVXBkQEm z*JiACgbe5)Ugo1^T5De&Wzb+mPW3+e!6#UYztKScf?1zp_?p-XF9`Ve?W~ZWDSWc| zHuh}xWXUrU?_0Z8 z{a|(KwhldVQ{=`4uMI}^M406Vx@wUHvq-DwdT5~RsyddC^;Xxp0-3D~pL&16Yp~{L zGnQ5Ic4=@cZTTCTuC7%tWVmk~)kSRJNE^{3UF_(2svn-!k16nmpZ4gH^dXQnjP|4l zoZto#%uYticnM@Jh~Q@DVcp7-uWRj`mFV{|EjTwI0M$k3Z#LL?xDW5 z^X!MzXi~gJYM6@8XU;wvKF-J8`+Il610DOoa9mcyi4bkw-GyluYix(XeYu>M*7;xP z9mc=X**J6}PIXLmaFZQ{qusjA zcbZKrPIR-=BSrDzZcnoGmn{*<^S2^0AiD6SG9nY^7cfsp!(mP^C01|OH6YX3s09IE zMxml{iA6nD58iI4SzTT6ki~dmoq0dXIg)k8V@%JB-9Ya+9zY6=(X}LIV+ zoK^9X5#AqjDk&-uZKZmH!dFiD7`_QoG@lCPne~8<=WONyVs?!3m8gUl zg%tbH6fE8xV{O!C1P!YEqi7m{VFZSm3VLoy8SG$_2O zQiof-0@wS*opJPFp5`&8Jpq!krD3ca1v&_x7g?9U6G^#-Z}>?LjlO_=O`Y&y5(Fd1 z5qr}rZ{5`8nicJ499RwSfUYki34QqGX$G}Gx;jzBYQ?}u=h|>!l-eBFXiZ~ zJx7HQtyYG!N+uf?Bg#Jw-ybI~*%$YUMw9gU!onH7R@_`zDsh=H)cw$=cIVJZjrtAp zUo!q@RDYa9Yy`~Vs1&;J`@;?jOQD<;c&k0A<^-N}c{ZVZt zlSx61sS-OF5N}q(ZY8f5eN3*V3b-xEPmhh2d~tr`bYAvTx%*FJkf`v`V2!Q@7gR%S zzk^Oeoxsav9~c4A4h4%=D^I5RtA`V~YEzJ}u^(6E3#Flrf4ycZ)j}pXZ`tC0@lq0? zPLC7tj8TkRr{s+wsf9p_=xJHO_#q^W3jC$X&Z$iT9-!i8?}J<^+JnS}sQ#GFM4F=F@MHdHf&_cT+XgerquvVA6M~eV)w&p1(9zFj&8sJ zI=BXPL#)#D3*IPdPSRkT6>?^#P=~1VqF@YsdiG_dbxyYm*@A^#FR-IQ@Cd}Zj5LJG zlo1pP7|2)q3zp3oy?w6tKY~FB$Ytk2Ad+>i_M0zpYw)gXa!BEj7n5A^@lA1~BpZeW ziOc?mp9CVkb1VtOc)1hyCz^?wIPiyqp{3RKB3FWJ&)wO?5eFdQi$`(;eS8Gz>XWN1 z&BADfN|dFFj2wxHqL6=RgF|vgpfyGvI+W49*pKz*%>7Z zutm}9zLOjfI4mAsC8);Up;VE9$<2RyQ2#bLtUl%!%%!#;|hmhYpfS-Cx<-H5T%^D5tbC4U5B}KECDij zwQ?bkr+>&}M#j9!1)DC9H?uWIJ^wvlj%yPTxBQ^dvn&#cQ*gb0EfjY%q7$C{=61qj z8W1eVr%zY>SV;N^G%I->rT9C;`L-ih+~(2}>hGpfs3zw>=Z~lmo{Hxx+xbHMc4Prm9;5# za(|PLO>S_tW2;{XB3~JaM!{AuZ(MYLgmLL{9z7AU^kcQp2}X|k;>BPD)d7z8)46xs zfg|j;`BXxt*G?e}u6!PPR3r@|rRmw6T8DcSPZx?UMs*R=yroa2+_i;YA;aV!B%HxF zn#cZY^Ay;2z@uKI7uuY#aXWELLc`dIG|H6Wz}_GShezjip3C2vW#a~DC^ zGTatUR$&3N?fWg|ISt#gZp_h(JLLA&0))2_ zS;e_bm;PK~ME7+nc=n$IY&XRFK<;v_-?Bxf?TM=aY#tEJ_F4_^2#JfK?J$j*6(Ta% zj1ZORWxv)mgSdi|jA2E0T7ufN<$A0seC)9}1Wq@~yP85T^Z~ot9?*HKcJVA~FKB|F zy2=vrNeBWfr))n`U@O+U*)*x}wY8s{Gs)PQRbuMtTSji=R|6PZFcQlu)qj-H>i&GRejqvzfA((e0G1#`M;K#lW{w4B4 zm)$zpO|3oFD#pz{y91b2a)9^#d#g2C`X)RqZS>G(rwXUS(DEPpWP5>$t)gaCQ{grm zljE4jro=>_3HIcZ*TMU&7`qDZk8LC@(c}#x0ocL{tZ{%-HzmUTa5qIYr8@q#Z(~A! z`gsQVdv(-TJoSSlo>At6N2q41{D*TzXbvV%ecvJa+@ml!X`&M0-}i}m&zG$r9-UIk zqhT|MPF-n%Ddf{MU8nOv@t)+DKS;D6Xd!26`Z6Ib9eeJHLQ-L@DTXvF6e!P;vG2yH z8f|gIuus6oQhUUbG7X-v1pB#-Ll(vIC;Kgb4=k5pW)xicDvb{uZiEDxOcz}9Ew+UdQhuBDB5i3Ke+R=Dg< zqD+Bv!J`{d5OWJVTlr7nzH;J{hP0?a5uU40e5Ee1_8c-AaBR2nAb} zLg#QcTNe0se#g$pv`Kcy=0TQWx2w@86W&Sazfkjsym>xp8 zCkl8pA0Y3x5+q&$q+f}edhGQ`6c1Xvu^TIlx&|<)v&y8?TwfacVqmM`_I5NMXLCd+aO%`1TE%gG!smzL(gEu!UAI9to z;e%wE5R(VX=AhgRXe(nP8uqXLp*_|TtqPPiKEO^4kp5*I|BT>!^^ti7ym>DSIi_Dm zrFZ(61;-lPQ(Uz>t(8X8=Lj@uG=;qqNuuO&^6lE;RpF_Ol=YUn-(|V*b#YXPO=ZuPff$7*Bp0^1@k({|3f)}c zbUYa|yH}L?>`r9^0?gRCd!Em=EWlcKnP08AO=3U{W4%oTf23UGXPy05)EycIMe73A zvU8Dg1-R~#Y>XA|cgkK44e`3zLEs(L7kCX$V!8tjU9oIZs9K3D_;W$6pTaK!dKjn( z(njt!tdF*gf+JhkYJTkEN&EXZ?~Mt-vx)Yq3`1_zDTR~#wjUwpE5YMUcN(uTwUqO- zIuiAa&V;L9#0i^C+iK{rv4skuRalRU;ecA0^oG$d>IwfVKk%18I!E|3KcMuDzUdY< z=s;yNHMBLQ2Iea1=3;?4|FcZe_EV{O8*OtxQKC*L+}oRb;_kKd$oqJC0n8>gZ19rn zYRtw|!_thl6qk@RHXc;sUrpK7K2o@R0y4!G>+OSw^z%Z*`w_Sg`riTkG9v~}~{qpexL86P9 zrX3nv3^P~if?XSCrJTvUb6Q3w_82Aj*^ExN1thH1xRMv5r|1&3{Mey-< zM}7L-ViX!fwQIEM>1wOlv>=8Rb$5FJ7+?Pt6Ta?-DK|lDSW*!$n&*{R8 zUTm-vPL9PjS;rj=0PfM^UmaZ*K6MZ+l@wz(7904~>HPU(%KHqOjeQ}(4? zOmeKYwOz=6W#VI;i$)%&h;9y;cD4b!3d>6DH4H}v`Ap^GyfJAjEz)GOp0Ixln>Jgr zt)FxFcsLb(mS1O>2S*wT2pB64^ru+~A4F=;7;TyQ&FN!tg|;0 z=68W)ah)besThB@?nl~Sw&$f{cMBd~PwE&7f0fS{=!Ks3cucW~bku~iKPs1qyE;t) z-qfsQz!ikQccYq!)_mBM#n$l_)9S-dmFnL@YZLic`Dd z^beXv()i#LKR?DS?iEaEg=@Q{2zPUX$3uU1NHnBpRFT0b!P)6)Zz!O5`_5t72aR(| zBrzj7`mnC{5xC}PmI@yI;B&z#Nyqor#5_J>1wKWZl|iyZSKptvt+St!7Jbgnvf7*0 zD{8I?WYsxcH;stsf$%s5(mn^!I`DEJ!JTW8K@Fq$n4cMbC))hvQl5T;HWnr8rW^{b z*fqunDe(^dd_77S~9KgwOv-CMWg?0kvJQ}Xo|H?xiA zuv;`Al04z`y>2Qy!cEepntdHv`dnN$&IO7k{$uAp+#&C&PiGh6jT5p5@11}@p- zBu#Yfs3a5pFq;GQG@PHOokZ;G(zvyjJsnByjN${pwAt>1iNX9@^oBxn2KYpT3u#v_ zCG5p}jdj!lOtQ3cjBhlXIP%v7p!y<`FWd|9=;oLN0yj1Erc90cHDp*WoZ~+YVe$(4b+PC-5PR+;gzWXkV%&$Y)+6eo?=>JpLHw6dUgw4j>*iJU)#>Qr2+qP}K zv2EM7ZQI<~_D28r-<)&q&fQeaQ#Cg;HQh7)bRW()7**&Y?7KbBG;6-UeYQX>{BT`K zkdukgJDN!p3I)gZMlhX%t-1N*k)s@s4#A}^+tB54=Xvgp+e0@)DDfFK44B(yC{LNM z9=DAPabWz?W5*q1H&T=J!SE6AaMO^mlP)Pzwa3nsRn=o|c9x<(h#F(Qp3YSRrxY1H z(mAjT%fYYx_C5dEpISG1>zDB7BqAoZXslMShTFN+{#c~PU*f^RoOU8ihltv_S02w zbMFppJ{Wz<`1)hnz1zh7NJk4(l)TAgat8HE&bR23svn&WnuL>b4<`ga`*84QySA) zaZH=x9!^uN9_m*YF`#>a)l|xsme775eDo5d$8)%tOX&zdY&QJ5xl^^6vXTdAK{VF+nrn_w#n95?z!_+` zu^QUFt=ko?wR5HG)`ymX9Z_cXo_#kRDnBk=@z`cceFvq;FQA?3(|kn(Z8-+vL%UJ# zHk@7xH;0C!rGdw$U{5GcsdK+2HtL5kzSZ0VmUP1+GY+?d-J|bVa4Zt|B3tOjc!Ad8 zO|0m0qqE++P^rY`FDaDPCXf`J$F#!mzFNPx;}KWp43~3|D^vdSxujZp{fDGUgftG3 z%vH?NbXrd$EuczZIRK&SU-l&~`q17!jsQrWuHp{rdbOqrgiZ8WS$E8Gdf58}45ms7 zvMk1@##5b*!TEmZD}ErD(QQwtY`Dzwx{|fr)@0!xSBOeUX#2qwE`Mb~7sWG~hECJr z0h};Obi79Iy{$SDr{_`Q9EX~v4iYtiypP#M-WUqN1V~fvFJ1FDW)I=q(&hUHF(|;c z#4*M%(SO4HUj0e`LA60B$MLrT8nPLuTF591a$YRwrl(bO6GzibfPJ_PL9XqZRPt|o z`FkbDU3y{hdHJ#0erZRlxa6w@xEDS zNKt`I2A~YjwyQ&l9{#gdVK&k51vD1qz+jbdDlB~h85%ZrY*{gHunb#G^?2Y^SP$`J zvbIPl;@@6x$7`C%D_b%W-A=c`YN^)J+^L@ zEh`DfO0&ed*ZLft0SCA4+(kW3W!9?h<%5`vOl1idlJn}Qz z6*q?yGW)SpYD&gWK$>ei9i+j2Vj26Q_IN&Skk- z%w=67M%{_i>5}&`JNEd)SSTsUDOcH?e%&a?D+EhJj4rY;jrPy{qHkL>)e;6Ll~4uc zXy5=*9%WW!`E+ah;SV1dp^9J($LeF#<)~~-xwudO3L1q}P)>%ccB@1ky|WQ2ZA;xO z>(pm|#<;UQY5s&apHcV7(J1@&8mGLS>nJVHfg<0>0B-BAzK-*CcEGn#(^o>jOc zSp%dK0VME+6_1veU3NG*?v206c}6^MsZZ4I=2{xD2K!q2ZqUe`r%JWK#5b zQk$;9y6AoGx`i}{msb0To0R66DyO-QT^gS{OAZaa>|&}^9g6AJJtlUuMB;-3+`zJF znmz!&g5-_${m_D9|)|60S;wL3id8OToUHK^TWg4`U=XTPe0}M1ftHc&L=S| zU`YYGz>@u+cT~7=vEBh=I!DD99M&%pf1!a>3E?UB0QjMU+)$F>Y@)0qeief8c~-ks z67L&sq1?rf`3;}@KN=&N_%Z75f|^Ox+J{9vVoRt_e(BhLuQTayqBSQpz;ZuDRJ=;A zSslK`gixR?>+A_Fz6KH#5QtkVI{2dREqq0A+f+bx2=WNUAZ(UlqqkB*u~w|#q-B#& zTIfn&D%N39&jv4oP?i1_;QS6}_ErL2_mP+}lsHlw&j%Cs+s*;Jf9-nut@G;7v{xf? zh43SuVzf|V8lfKgML}Y}M7vvCs`7nnRw)xJ75pj~5PQee2ZuZ``fgWn*UAh}^~RC?boCI?;?N^V=KY_g zwz&%P7y5;_;4Mp_nxi^@=@|0H->M{7d(inLC7}w*ElXi`R2!Hs&>gm5aL!j ze_Ky)yoZi{82JfjwH(~kXB!*+P6#SEqIo=BUfyzEP1&jd@FJr)7c7Z)nh;oE#q~Uj z`08<%wV2LY+(1|m@ZJ-vXY2Hwo*gt-4diNW{>mwl@r+A3RigCLZj4?3!@z1H@}5G2 z(UmqWJ};TId$}_7LZyPG6a44ZK*;omGSTK<^j3M#bHy#~#TgtLwO&Ev%Oz?B9aIr= znT}cd{5I7S(1h!KqlZEwV3zXL;S}k8bt1B4-ruL!pa6}1SJXa-ChIn@(y1Cf7TRaI z*zm8E7X@`W`_5JT*lsmvb;IJNZu~{DCUnPpe+j<-uhG?Z@c`dwbvs9Iyy}6Egib>H zb36WyXP{$D%>}$d9)B49>+&SB=4_Fh`RAAq$%SYxun3dm;QJdK5FA#yT@+=+E0d{f zq001_fv#BuL5rVdwM4%9?K2$tp#sygCdrofF&WD%mE*X=QW@h}RG6o{p6qsP(YLS} zWG|u3HZ>ACUXk)i8Pemg_j$9n0hh~2#KogtIL)1hdc@gU9U_R-n}zvzyf*q#)ZgEl z6Ih)E@D~;mR77Zgl6VxMk57((TwFyi|A}b7VU99d8uWzSqcpIT#Hn{hbhLtj(E_bc zPatP8_X<*Xln20dtkCGotV{r(S8-yCuN4WeQ6DS`o$r-4)eR>InbuLp4`(oyb7d zqNf@wGP!^w>V0v#v1MPTuc5Dd<);iMbkzA5u%CQLC^dhOVI^EWvKj?QzELOje?M<| zLeriQdEYT{|4F9xUltG*Jf5u4J;)->Jz-AO-h}l>^p+6&_+bqn?8*5vfCjYiUqyFE zVIrb~p2)*Qgv(jXio95dSJ2-;>aK#fR?f*R@i3pC^q5k=Z9I}w6Mq9kDHoySp;@U( zKzAv$B>8=4N<&1H>bd=%IPHhX`0Kta#IN!`J;yjB4pfN-c(V0c6T{J7GKN*?kgAEL zQe3Cdh@Bqs)Tf>dJMd3e5v;IMw?^onCG!^3Z7!)kI}>Tl)>y*YLhDUoLP=I3TsrV#D$D5Ow*d6@-AvXBqVLp0M3|`15<|b|@ zKiMsMNXBK6d9Ho`0~<`h};DLS3~m({Sd1misOsg?CwUpNx-3F}gyTdIB4)V(#C zDlIlr+JaL>}Tl=CQGi;E*y0LPg76InmWr&nVZ zoGWMbX0vpOS`_w57~UlvAo*MMXra2aXcwA5kt=C>K33FT?-i`?7{wB_gg4x~{FV)} z2aXXx_9XB3v5tpZQ zRO$LZc;idQD=5>L=zU%ZCNkcMU{sWFK1U}guaBCqui5lNZP>jNPFnd}T%&)! zUqa(0Kp5yuq)U_59BO=E{nu6EDXxcCEL2#J`;w5?@p=*evWWp*&hy2j-WNVPu_h)R z#&O{}F#xU?)%I>m|aS(Cw`+C9%^vl%V zYbGhJ)Eo(C4%qML#=&+=E3aQ~M9<+~PMzXluAg78gd}Q~@+d}X7>ihqJN=8S_zi4u zPL@!C1V=9*NWqD_kxJ5SPctMaHaM3$ySWW65L0ghbxA>V*$WHg)Z2GE>2BAp@4s?b zoMr~mM4w~4L=(l5^?rYBj!Mne41V_sMX@~Pkcq2(cQUYl4E1E*j9x5rABFmpopOz` zEcX60zL6RLV__Jpl_r}gaPt3Qj!A9jpfm(U4|z^uf?>s0^L|`sDi4;EH9M<`he`<# zbAT=lI6DWtr+N@DYCdu3SB;>33WX|zl5~_}O3PRNkm@tKw}P4dw%0;#7Cu1t_3BO# zUG^X&?1AgNyOOB;g7^-&$IxG5gIaQK2xkN@w`%Vg_HuJnD=XoO0B5EG$nq7m=xd;u zBH~(RdOO5nFk3dV*~jq3`_FCXvZ&gV=G_DVjGtpjSl>-+=~O^dY(EDBNyNJRWT^|{ zRfMN;h0axuYyG?Q#9i#N!*ucR9bA}4Z5oP9dLVx_UMb5z8xaG-*<)IX9j}z^{q1a? z-H|PYPyI?oIEa&JUj~S*yu}E`!3m6^8Ih?+1PGMXsO#0E<*RAwE-8(A2KYOo5fni{ z(gptT#GKQzpSVmih zIx*aOgilf^Iim!}t9VlS(phuCZr%?7Wm3Ci&hVFU{YVt|gZF%Vy7-U~u1_$>sIo)H z!)DXGFkemElJerPxKMlC^u!8e^Q=tsz=s~hZC^2k0Uu6|lcsO31|1!npQ23Bv)v}k z#X!4$Asr7m*jx=}I{A6i^%|c6!k;5CC3s!I%fzF5yAB9qh~(Qre&?YJ1#LPX_t1t%i-@a;+R< zue0%Wc`=R4N=Vq=GZGa^;Prxkn36fb`Uzht0}TD0NYaLGafHlotsgYVy4ah@g3hSYbxXOhYa>5bQpT-Yd*u->Noviu-9Qg1ym;%0SK6?S(NHz zWlx3y+!P?QN@BM2^gXeIA~s_fi4@_Svw8A^b7CnIT-7XJH=KxCRqm9bxkTgUoz(-; zr8ko#RX*jf&kq+T0(-7LWc@pSEKLmgk7bt1m-r&#B)T({uz(b7NO4OLYN&EXx<4;?BA@R%$g#i^+cD~Q7T|dUju~3#Mu_}M(b!&xkrEz{LC}xkZ6;cZ=B`_WD8VR+wNJlonwE$v^-6&HrX>=sP*@ZE_$Zp`f_ za>f$N$q zy(BWTV=HDt?durF;169?a*86tuSsJlNH&0HNv<1-t$yN&o3o^THq#B~%zkBfed)0y z2@4}E{Djg&#{3!H5S*Ac2tf%WDSITUH@;~FT_!J$U_TM%Kp z4AJZpiDi|Cl|`bnem00|s(NZc>Bp)$f}pRvMKh&@@&&!($X~QRlDs+1Zv{2Mz#4$< z`Rsh5z@Q{-jU9(?REHIXAo~~zQBC*Xwq8dbd!=0cY(|#Sl=&UXYro#liSB}0&QB4^ z6r?aBh!*fvtkW?<=54H3UJBew2G>YoH-E>QA`2uxp;?)om8)j-!V6caU4z#&8O1(C zx+X>iWD;)Q0_-)jG8W_o9EuBC;#1%{j^lWVLPjb9q|zY2&=&Jp3MLO0;d|j#`LnOJ zFyC_&GN24uU(;s{e2t$xKKxQHsB*pTEpcQV!*&x=*{u~`d5hr3)x^)0yNtI)tGD4& z>p++U$-8|@;03@WT;h59Ii{Z*Lo)F6qvyVYUQ}|r&y=X#5jUg1;}2wnk}!~Row4%j zZ8RK7UgS<$i~X{Lt14aNY9I_Y5|6!oDUzJ{VAg49iT?BgRM~?D_XqNB;B+=Vb2P5Zyh0jZ4T_n!!57K{0L$-ZAnjr^Ugj6>!>se814Mkp?Zs&lB#f~IiRYO!`Sl!-| zTf$|_@*abxQ35XXq1s6}X(ZiSgDeg(BkXme)_(Xfy3z;n$%S)?X*UtOO@p8D=DrN_ z?*{KlXSw#Y?_(>P1>crs7yB?Wr_-{p2*i z7m}jvXoRVP?-sa?Iy3y5Cmt}f%8v0-SVfIfXXqVR6Ri-rm zpOf!D3U5UOEFFA^=(QlrKK!6;VU|sHp4Y(SkjN7e>Ggqmh2##U_!Z-?+wv$PT%|?* zl7A(GL{YX^1V{;Il^fQ1bG`tx{@_kc)dlajdUL0?NmU)lT@%gZ*n)bTSsQyvgR&!- zJ2-zC<;&oi=pyUQf@*(^>-j5PZ1{ig>Tjn@D`@?H#-p7tu^ShiS&MVXqLwg5Y5nD&g0 zFZ6!rvpc6tSNLRv3Q#vC1g~O5YOo9AvD`q+Vfc@K=}b+GOs_hueQh&M+WqW-nn3pr z)@))3iI(l8m7?C?^sg`%gx@phnCh0%Q{z&WSO0Y7q@xg*2@G}I!kyI|+P>g=^f?LG zD7+C7wnBbno^bzfS$#hOhSq^2b06x$TvvA=_Np4m-nJm#2Vd<^&JX4SBgeLYpf~jO z6(~RkDyJI0p_(zxU#3VDyfXDlHP?TCi8WqRiIZWfc*xyCXGG-<^JF)sBh1GrR2_1 z0863vUc1x&5h|RGm4o#&yXi4XhyzSBg{%<-=S5#!V%cD(zZCN6)r&nIlQvI593ZU` zVvThe#oqV?w-{tODGS>CfLO(N9=42{ZmmvN<>78FJm8?;_*8a)$eUA`+t^uC;{wR^ z$0m9U9+hlm;kz3_a61y6r{wg&_|mCm!+GelD#dSN$>8(h-*{6OQmiZ=NPhmRJ#b-j zWw088)DY`3kTX;xToV)dCfkr9vb^83_K2^#S|OPI_w+;NLoCvhYe(;$UfGRBff_Cg zzB7JEz+s0kUAsQc2LD9X*K&!m&>vWFI!fa3=^;NKT>CD342CUE|1tA?Py(9`C?Z#8 zzcvv)DmcE7vAqH?UXTv;qUc26TQARjeh0Bf!TiHvw}CIw8=d(2H^Rl#P@!RnF~Y@U zJNJ8{OKz{Sb2-FE4y@1?*8>I_{ngOBvzW9VROdA;vbNYQsK@$^2dXxQugJlCS6|l3K`HGw#L)jaba=+0V?^9 zkSVV|xNRLa?ZovYnvYk9eZ)NOijAAIDg@jAPL@W2FmA^Hdx(xaEaJ96WVluvd!hqx^QGnVsOA=_1t8|b3}5+%pF+Kf9 zdfZby@Uc)_(4Lnrjg79a!8|IclN_H3d zNJB)}qhQuUwcoq=0?7$y;z;d?Ir^)vYO-9B*J6Z+_`Xg4!<9r7TYk+Ai*DUF^|zvt zSZY`Vj3Qldt2{7{=XMge&cpSZRPBy(T+azPb>HzjPkZN{?Zkb_`fahSp3H>wUh}X< zT^PFz^&R(X;XHWQDlNo8Zx!Wi&TytSiTSc{L7Y8Ys+AF_fDw6RdMxAHZ;rG_Ue5LZ zAf#W}YynS6*LPeH^ghi}Oi^MxoeOFPDt0$oD@hJZ@HPr+c7H05_zJ0ycB6WU znk?bOSfS{oA>QeU?w~cXMo)$;?Twt1diSGvKb`T)0h|Xhb;W2?+5e1K{Q^h!lFu!f zs12kYO#gyF{M2c#-O8OV-7a-M2XoFFl-}kMWgaLI>0$#}?Y*+O-~UTbD4Sx*t$xH9X8JWHR^-M2sXFY{$EzUk*Hg4nQA zV>*W%XvnGwZ;hkwc&{V-18l0(wTdP zDx;boQGO03_Z)|8>|e<${hk}l{IK%{N>}}mzksYLiDwYl`g_6Z9&uC+<Ce8u&qNz9`d|?ZaIHD z6o6yHtyc%+uh{Hx@Cmd{xRQD+Fome zATaW8h)_0@j_=P}_BqZ_Z_uj!;Z;$;eOeBoY~_ifIg;3S9rWz)Kf*P_nOd{;*+Au^Utx5V3WD7~OkH*G z=9B5TQO@jSu94_#sN3E#{8x9~92V_q`!IbIEu0`YZq&?L4G=TIlGzE^kQILar~_^u zVDPFs?9z`0_CHA@O;hf_woW;4xWSH6z6np2NnpZ?`~y%k=PFx*s~F9z=8U9&u60|N zWMrQJ3Nw}SqHc!7*fi~l)ULKuR5X8JtJ_@Zd;-yW*V8PhdHdJMY4Zh1^99-vT*l{* zUVfen@;6|R7P*IOgxMu*!;Mu^+5pw%wNfs^3xSyN@26^`l&+=G-7ooV3d|wOBs(-J zy{Q2zgtk3w@^uH-;Xe!p06^NQW_q2I!LdK^jd z#S6C-?-+17uAA(gE%@C|py+SY9kR8sx@Ir)T83bB?MVOYn8wcH(JewTqX+haw_N)s zrDuEJ_7#TzYhlCf#E4`(9j@F?@=!#{WuH%GVD}^M@ofF^*cJKHStMahCz;6)t^M;6 zZ?a*$u#}eT)N~J9d@V+CjIq@1wCWRQXslDq?)2^7OWH@t%w>YkcF>cBeio}pc9u_` zLG%&ar*c}3TC5M7NMj$Xu39^v)rEw08?_nMVfBP2(fo4cb1{roM)sX-Fw?WXs zbW^A;Q5{t-)=Pe>^VDyAvziXkzDy13PBP`HB5U`ax^3I$QQe4{8BQm4jh6<5dsCyY z>&`~?7Tk-GUH-AMr=fFC@a(Lq_Y#RK3Z6elo4we4lqoW$r1Jx;!^Z%$&7VMQCY0V8 z=9B;>Bg>caGch_jQgAWdS+aBGq|UhX&(}f2XDAecf2BS_w4Z^L){}}bH&6)0UbC+(_fb**Fq}h z8 zvoCD=H=B~zACyf}AM`{^9A*EZ+XgXmr_eBw!W7@6AY_>Q3Hk^c;T~{V`+>ZF8Ss`m zJ`R=%-E#X%q}&$DAqAOAOh6nH@Koc;1>gO&joTgKk{^_`6XmOG#Y;J~P_6c`*YnE( zMC*;O`slTz>7H{)ZSwi_D5QWAnyKF1N?0)T{_znlT-Rf_$4^>FzoW4fLh2%T?O5zboH6 zxN}&if%wN_1Y}^QQGX_)3NjoY7gE3AE$((f^rLy9_J};7Vd>9fXGN97|P zL+T00>0p;6GyV=8!5h zWL7K&t((*esU9GrLiy%YEtsPs7};XDhk`gkqmmP*B=UJCh{fVzDU4+CQ0F#;L94ri zxYH`6c@dkmA(N&lOefj$GrhKqCfu80zd=JX9uI^IE zoa5ep32+^dNAt0bbn526mtYB<@_wtq8Yzd`#|`Ma8%B)jM=mL!f@47JJ5j)?N-fBv z@(D8ILIgm16cy58QX6wA% zGkL9CJdcu6tQPBGUACHGEuJkOip>~3zqNS*F7r1sD`E!^yEy`(h6i0dSFs^l+ZHo9 zHlHvD{p3>!$9+LWK_98evy0flBAa!^gRwONaz^*tuiT{ph`X1vjx@#}2Vb>BzT000 z04o83OK4*A;KzsO9D&=bE5MuH({&oNr@{S^YMTx+kiB-J%6}I9uC_SO*->VGU1W{Z)q??XfM0H*%-5o+wc*&ZP-wM@C6%Ox4TL5J31->9++ zv)qUlHRI=v=uN1PdKP#>71z;|^HLoKT)7xl?Uy90Yb9+Sy#Vg8l`sy#1 zlsCD0LkmBK(vMS#(y)S?(2C3CfjA?|F>hvt$T=nr7z8cShxs^l=;T^+gU22rJa$NU zCQQke``S-k-&aqT{-$C6@itgOW?%37_<82m^$xcPgj(ppMZAmn#MBF1hG(F~Gh+p} zWnuHYU#QlrZB4bi%~-dqPkNxzQ;&6xLakIt^7ZtD%3t*3_3GsNu)ARXn!GEHO$F!U z_YGC9;r?s?3cKG#ugtndCUYbIcqUiw;j$!uxk1CKTVRI@(l(8Q6#?{X!{u{N)sG9z z%}JZ5y8RUkC!ap&Tbl?IVRr!g%Yg9vQr8P?ps=)q(tFL*$GNV3Acy$lBL{iv;2M@% zk9UE{!*c@x*>Z#xQsSul>MT%acyTxC3hnu^pBzo4ggdP8P>Am{asT~!FB9qJMfGnd ztCM%BSw=70uF|EFFy{ks+eg0x{!hgnU>T81eUUtkc$sl&TCCa0{QwAFWOsK)nd=$8 z_I;`djOGe^=xDBW_em&2N?&$vld`;E3ZRd@tlb~UzLYt-TJ3y&frhu=(8N~<0uX#m zSj5{j41Z0Na_ivZG`gQ)t$k*`Ad$Evx2{M^b&wRA8!t#+wJxYHR#>Wu<|jGZ{6o1g zi%;+)6J8wYCipc*9f3NpI=A~T{}_?C(HJ_y7wIFy7?EHV{K;u50fW&35dy9MoW!>U zXiC1??(W>*k7%Z_9;Q~GZ-AOKPQ6?@_8c-Jk9QBnvt;(=Ob6eIty&J18y-iT)XM_!m*Lz_0#g>o`Q zI)kNIRQS{3HM5&_u)Loc*2`IM_J;dB=-XLne3Ay|G0DUN0s$v z!))l{OzG=LFHn^&+I>}V?xm#ns1ex5OvaK}K2Il^I9`k^F-^f*&v0+l*`T{zlOzOd zHX$b|%%VeuPRf#4K;9&=CrLpd$$2V!FpHZ;%&-YsqP(wyS<8wdx|Am-W!@mUuZ#v+ zDvU_^$411ez_yd7Y+kIxTrsdB-U5|2o;p4*OewxH31~zuUdlP7@PIwDe2&YdLcJm{ zO1wh2FZN2zO1>`6qOapQTN^48Tv_a-UxmApUc#bRp{Jq6y06#PbXZCNlAn@nZ`li$ zPQ@Y=mzONiC_Il=G%L;V4QOtrKPqIX)&8?+<7~OhuUPeiMJB%yD$1+O$eU8;D;igm z2}n5G0hB!||M|l`hY*E%_9;;qr*!z^%(@YA%!zI{rFdx~pVdg+Y&a8Poc9&npC4h| zSu{odTY1gep?2lu-q>B|`P$R*{rLCJxjQ~uIKFXgZl4kWu^5H2QdNQs>R%U?>ndR) zSD8kvq`?9cHqQMg?mr(XDliBOV#3sDI&vz^B4GLsXZP=~H`<;-;JEjeuV;4m9^7{< z_LawXs`G>8=5EKF5qJOPzF~6Kea496LyG9T_xJwW9Hek{S}7*jAUnv8b$^gRfENN>;} zo00Nhtv6~|AjNurIKT`cmXq{a>($R>=0>Zdr?VsMZ|?6*dXgM={2fC0snIaS$DmMW zS_fv*s^XE4DMrrZg$%N?LJjSpB5?f!01k4v4=p_CMmR(}-K*|hp7j1bOhwM0B0&KK zIGgI;3{Lb^R36ZZ;`zApYb*Pk`<)>EDeET=tuJ2u1c!S6*^7_5q^#%}9ZlDEM~J*= z1*}S8?n#P~Q;xn9efw~NyZcWVb|I|nYJR{dEXIxrgWGw2S^VAh#Yb(4e#vNB1|H%p zKxF0g+5R@aRP2$)jmQ|&XdlntKA11fj%j`V(sT5Tn7GTU;)Uw3(czwP42dY$9~tdA zm}8Y^GG3yz6tzT$!#E!~i{jOv8G(F6-SQZ2t%vM$ySdNRIJSh2d2PDgo8m#_F;93a?OVVI8boxb6WU=F z^+;=Ks;-e{c%lLubI#yde7<^e2C3zyE)7d|`puGbSfpgR8hT-TMA_~gXkyZ=c#wp9 zqIWj=cI=FSAhRsLv&J}YYMhH$Y07WU;E7V6+Vm6i$uP5HE?Pz=N=8OXYPerA zcE-X6&L+fE!raV^%>PeGD$f|01~MBlm9mLCv9yJ&3GsjPEU9HH8Q#unb7 ze6EGLls_pnJ0(F{BJZk?Qdyi$T@WFT$ zx^Q0LhM_7`90;Pk)({N}nZK`P&pm(u82V+jzRr>BM`g%KfR^iLWyH#XpMkcdW#kfr z50#TEJrtS*&{;~Ay`44oD_ZjF2c&^JhD+Bw>@(M8oeGVH(e_FHOuXWBz!)RN3@{q< zmj7J^A{Jih-&zG-IK-A0)&?Ghyc%G*ugfS+2U?sbP0o&2^Rt|b_)Yfrh8XbOIHA%2 z=hGZBiWuPg(=Jk_%((T{7Gn*BJ-|{PoZWv~AASwavY);0%`n+uqDrnDeA7eh7pL?V z?751gt-DlUSe6zHClWu|H)-A4479CFryt63QmD=I=_$y}I5)G}em4 zXZJ0n4bC}|xzdKh5snx?hGd}2JJzRfb_>C?PcV7kYtJc#!W|ymu$!h(iEukXFnME? z@N>W20#Ba};-f%R8TVl@sRZZdLF)J!A(Gzuao2D#Za0C|^L>J}0T)wC+N6u(QKst= z;R~Ej;piSbw#Kny;*c`df~GamCs;hCn)zXov<9akBQjl;h%Wl;#H7F%1At_m|@CFDpeUm)kBQ&!oK5$~o z3=wDmSpqBWe-L zdfLt^Wuy0|yeIn2 wTYCj(Vr%T=>}XiILrXX(X9GuPcSjRbI3`Xub}m+EIC63kIZ?R(0mT|rN&o-= delta 70689 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∋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 Date: Wed, 28 Jan 2026 22:02:46 +0100 Subject: [PATCH 3/3] pyproject.toml --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index d2e1010..a97111c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ name = "ipxact2systemverilog" authors = [ {name = "oddball"}, ] -keywords = ["ipxact2systemverilog", "ipxact2vhdl", "VHDL", "SystemVerilog", "html", "rst", "md", "pdf", "IPXACT", "python"] +keywords = ["ipxact2systemverilog", "ipxact2vhdl", "ipxact2c", "ipxact2py", "VHDL", "SystemVerilog", "html", "rst", "md", "pdf", "IPXACT", "python"] requires-python = ">= 3" dependencies = [ "docutils",