diff --git a/homeassistant/components/ozw/cover.py b/homeassistant/components/ozw/cover.py index 900debb35ac..741b0c2d988 100644 --- a/homeassistant/components/ozw/cover.py +++ b/homeassistant/components/ozw/cover.py @@ -1,8 +1,11 @@ """Support for Z-Wave cover devices.""" import logging +from openzwavemqtt.const import CommandClass + from homeassistant.components.cover import ( ATTR_POSITION, + DEVICE_CLASS_GARAGE, DOMAIN as COVER_DOMAIN, SUPPORT_CLOSE, SUPPORT_OPEN, @@ -19,6 +22,8 @@ _LOGGER = logging.getLogger(__name__) SUPPORTED_FEATURES_POSITION = SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_SET_POSITION +SUPPORT_GARAGE = SUPPORT_OPEN | SUPPORT_CLOSE +VALUE_SELECTED_ID = "Selected_id" async def async_setup_entry(hass, config_entry, async_add_entities): @@ -27,8 +32,12 @@ async def async_setup_entry(hass, config_entry, async_add_entities): @callback def async_add_cover(values): """Add Z-Wave Cover.""" + if values.primary.command_class == CommandClass.BARRIER_OPERATOR: + cover = ZwaveGarageDoorBarrier(values) + else: + cover = ZWaveCoverEntity(values) - async_add_entities([ZWaveCoverEntity(values)]) + async_add_entities([cover]) hass.data[DOMAIN][config_entry.entry_id][DATA_UNSUBSCRIBE].append( async_dispatcher_connect(hass, f"{DOMAIN}_new_{COVER_DOMAIN}", async_add_cover) @@ -74,3 +83,40 @@ class ZWaveCoverEntity(ZWaveDeviceEntity, CoverEntity): async def async_close_cover(self, **kwargs): """Close cover.""" self.values.primary.send_value(0) + + +class ZwaveGarageDoorBarrier(ZWaveDeviceEntity, CoverEntity): + """Representation of a barrier operator Zwave garage door device.""" + + @property + def supported_features(self): + """Flag supported features.""" + return SUPPORT_GARAGE + + @property + def device_class(self): + """Return the class of this device, from component DEVICE_CLASSES.""" + return DEVICE_CLASS_GARAGE + + @property + def is_opening(self): + """Return true if cover is in an opening state.""" + return self.values.primary.value[VALUE_SELECTED_ID] == 3 + + @property + def is_closing(self): + """Return true if cover is in a closing state.""" + return self.values.primary.value[VALUE_SELECTED_ID] == 1 + + @property + def is_closed(self): + """Return the current position of Zwave garage door.""" + return self.values.primary.value[VALUE_SELECTED_ID] == 0 + + def close_cover(self, **kwargs): + """Close the garage door.""" + self.values.primary.send_value(0) + + def open_cover(self, **kwargs): + """Open the garage door.""" + self.values.primary.send_value(4) diff --git a/homeassistant/components/ozw/discovery.py b/homeassistant/components/ozw/discovery.py index 3b3edf1c118..2eaaa3a2714 100644 --- a/homeassistant/components/ozw/discovery.py +++ b/homeassistant/components/ozw/discovery.py @@ -160,6 +160,19 @@ DISCOVERY_SCHEMAS = ( }, }, }, + { # Garage Door Barrier + const.DISC_COMPONENT: "cover", + const.DISC_GENERIC_DEVICE_CLASS: (const_ozw.GENERIC_TYPE_ENTRY_CONTROL,), + const.DISC_SPECIFIC_DEVICE_CLASS: ( + const_ozw.SPECIFIC_TYPE_SECURE_BARRIER_ADDON, + ), + const.DISC_VALUES: { + const.DISC_PRIMARY: { + const.DISC_COMMAND_CLASS: CommandClass.BARRIER_OPERATOR, + const.DISC_INDEX: ValueIndex.BARRIER_OPERATOR_LABEL, + }, + }, + }, { # Fan const.DISC_COMPONENT: "fan", const.DISC_GENERIC_DEVICE_CLASS: const_ozw.GENERIC_TYPE_SWITCH_MULTILEVEL, diff --git a/tests/components/ozw/conftest.py b/tests/components/ozw/conftest.py index 0d1522980d1..14253e699f6 100644 --- a/tests/components/ozw/conftest.py +++ b/tests/components/ozw/conftest.py @@ -33,6 +33,12 @@ def cover_data_fixture(): return load_fixture("ozw/cover_network_dump.csv") +@pytest.fixture(name="cover_gdo_data", scope="session") +def cover_gdo_data_fixture(): + """Load cover_gdo MQTT data and return it.""" + return load_fixture("ozw/cover_gdo_network_dump.csv") + + @pytest.fixture(name="climate_data", scope="session") def climate_data_fixture(): """Load climate MQTT data and return it.""" @@ -136,6 +142,17 @@ async def cover_msg_fixture(hass): return message +@pytest.fixture(name="cover_gdo_msg") +async def cover_gdo_msg_fixture(hass): + """Return a mock MQTT msg with a cover barrier state change message.""" + sensor_json = json.loads( + await hass.async_add_executor_job(load_fixture, "ozw/cover_gdo.json") + ) + message = MQTTMessage(topic=sensor_json["topic"], payload=sensor_json["payload"]) + message.encode() + return message + + @pytest.fixture(name="climate_msg") async def climate_msg_fixture(hass): """Return a mock MQTT msg with a climate mode change message.""" diff --git a/tests/components/ozw/test_cover.py b/tests/components/ozw/test_cover.py index fa1c709e147..07f7d76efb0 100644 --- a/tests/components/ozw/test_cover.py +++ b/tests/components/ozw/test_cover.py @@ -1,8 +1,11 @@ """Test Z-Wave Covers.""" from homeassistant.components.cover import ATTR_CURRENT_POSITION +from homeassistant.components.ozw.cover import VALUE_SELECTED_ID from .common import setup_ozw +VALUE_ID = "Value" + async def test_cover(hass, cover_data, sent_messages, cover_msg): """Test setting up config entry.""" @@ -84,3 +87,47 @@ async def test_cover(hass, cover_data, sent_messages, cover_msg): msg = sent_messages[4] assert msg["topic"] == "OpenZWave/1/command/setvalue/" assert msg["payload"] == {"Value": 0, "ValueIDKey": 625573905} + + +async def test_barrier(hass, cover_gdo_data, sent_messages, cover_gdo_msg): + """Test setting up config entry.""" + receive_message = await setup_ozw(hass, fixture=cover_gdo_data) + # Test loaded + state = hass.states.get("cover.gd00z_4_barrier_state") + assert state is not None + assert state.state == "closed" + + # Test opening + await hass.services.async_call( + "cover", + "open_cover", + {"entity_id": "cover.gd00z_4_barrier_state"}, + blocking=True, + ) + assert len(sent_messages) == 1 + msg = sent_messages[0] + assert msg["topic"] == "OpenZWave/1/command/setvalue/" + assert msg["payload"] == {"Value": 4, "ValueIDKey": 281475083239444} + + # Feedback on state + cover_gdo_msg.decode() + cover_gdo_msg.payload[VALUE_ID][VALUE_SELECTED_ID] = 4 + cover_gdo_msg.encode() + receive_message(cover_gdo_msg) + await hass.async_block_till_done() + + state = hass.states.get("cover.gd00z_4_barrier_state") + assert state is not None + assert state.state == "open" + + # Test closing + await hass.services.async_call( + "cover", + "close_cover", + {"entity_id": "cover.gd00z_4_barrier_state"}, + blocking=True, + ) + assert len(sent_messages) == 2 + msg = sent_messages[1] + assert msg["topic"] == "OpenZWave/1/command/setvalue/" + assert msg["payload"] == {"Value": 0, "ValueIDKey": 281475083239444} diff --git a/tests/fixtures/ozw/cover_gdo.json b/tests/fixtures/ozw/cover_gdo.json new file mode 100644 index 00000000000..d171c4f2071 --- /dev/null +++ b/tests/fixtures/ozw/cover_gdo.json @@ -0,0 +1,54 @@ +{ + "topic": "OpenZWave/1/node/6/instance/1/commandclass/102/value/281475083239444/", + "payload": { + "Label": "Barrier State", + "Value": { + "List": [ + { + "Value": 0, + "Label": "Closed" + }, + { + "Value": 1, + "Label": "Closing" + }, + { + "Value": 2, + "Label": "Stopped" + }, + { + "Value": 3, + "Label": "Opening" + }, + { + "Value": 4, + "Label": "Opened" + }, + { + "Value": 5, + "Label": "Unknown" + } + ], + "Selected": "Closed", + "Selected_id": 0 + }, + "Units": "", + "ValueSet": true, + "ValuePolled": false, + "ChangeVerified": false, + "Min": 0, + "Max": 0, + "Type": "List", + "Instance": 1, + "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", + "Index": 1, + "Node": 6, + "Genre": "User", + "Help": "The Current State of the Barrier", + "ValueIDKey": 281475083239444, + "ReadOnly": false, + "WriteOnly": false, + "Event": "valueChanged", + "TimeStamp": 1593634453 + } +} \ No newline at end of file diff --git a/tests/fixtures/ozw/cover_gdo_network_dump.csv b/tests/fixtures/ozw/cover_gdo_network_dump.csv new file mode 100644 index 00000000000..0fc08b4a34d --- /dev/null +++ b/tests/fixtures/ozw/cover_gdo_network_dump.csv @@ -0,0 +1,45 @@ +OpenZWave/1/status/,{ "OpenZWave_Version": "1.6.1173", "OZWDaemon_Version": "0.1.149", "QTOpenZWave_Version": "1.2.0", "QT_Version": "5.12.5", "Status": "driverAllNodesQueried", "TimeStamp": 1593370382, "ManufacturerSpecificDBReady": true, "homeID": 3716538409, "getControllerNodeId": 1, "getSUCNodeId": 1, "isPrimaryController": true, "isBridgeController": false, "hasExtendedTXStatistics": true, "getControllerLibraryVersion": "Z-Wave 4.61", "getControllerLibraryType": "Static Controller", "getControllerPath": "/dev/ttyACM0"} +OpenZWave/1/node/6/,{ "NodeID": 6, "NodeQueryStage": "Complete", "isListening": true, "isFlirs": false, "isBeaming": true, "isRouting": true, "isSecurityv1": false, "isZWavePlus": true, "isNIFRecieved": true, "isAwake": true, "isFailed": false, "MetaData": { "OZWInfoURL": "http://www.openzwave.com/device-database/014F:3530:4744", "ZWAProductURL": "", "ProductPic": "images/linear/ngd00z.png", "Description": "Garage Door Remote Controller Accessory opens or closes a sectional garage door remotely through a Z-Wave certified Gateway or Security Panel. Compatible with virtually any garage door opener connected to a sectional garage door. Audible and visual warnings prior to remotely-activated door movement, meeting UL 325 safety requirements. Included tilt sensor reports door \"open\" or \"close\" information.", "ProductManualURL": "https://Products.Z-WaveAlliance.org/ProductManual/File?folder=&filename=Manuals/1458/236956BX1 GD00Z-4 GoControl Instructions.pdf", "ProductPageURL": "", "InclusionHelp": "With the hub in \"Add\" mode, press the release the button on the side of the GD00Z.", "ExclusionHelp": "With the hub in \"Remove\" mode, press the release the button on the side of the GD00Z.", "ResetHelp": "Press and release the button in the side of the unit 5 times within 10 seconds only when the primary controller is not available.", "WakeupHelp": "n/a", "ProductSupportURL": "", "Frequency": "", "Name": "GD00Z-4", "ProductPicBase64": "iVBORw0KGgoAAAANSUhEUgAAAMgAAAC0CAIAAABe2vRzAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAgAElEQVR4nOy9W8xl6XEdtlbV953Tl5meme6eEUVKJimSFulbIMMyYusWGIpkIXoIEgQIEsCAc3kLkvcgCBwnCBIhiPQQKICRIBfkIiBBLEGKYieU5ESELrQk60JRImlxeB1SJPu/387eX9XKQ33nn2Z3T8+IGlK0wf3Qff5z9tlnn2/Xrlq1alUdSsKTtnqe5BNf/dpskv5kT+Ab21e8NextqDaSD//5yEsPP1l7PrL/4wepdz3858PvemTPp3zca53AE/d//KXrJ6///Zod6vF9XmuVrrcnLuw/WYdqj7//2hQefv6J614PHv94PLa+Dz/zyLsetrwn+qfHbf0pX/7x9z7+52vZzVfpUA+v5yOX4ZG3P/74KZfm6/xQzMwnL+SbtD3Rpb3BV/84O78pb/yqnsM/3Yd601b8G9s3toc3e60XHjG46z9f1xAf3vORdz3lvY+/9Mjbn3ioh59/5FCPvPTEj/5aHurpb3/iDm98z6/DQ30jFH6NDvVPRPx6Ew/1jVD4je2rsj0tFL6u/3/k1Ufi3ePx63WP8EZO5omf9cST+aPGr6/qoZ7y9tc6/lewaF8/h/qqh8Kvh+3rIRT+iR6qXuIjz0jKTEFuThoggG/WWX0jFP7TuUmKiKvdxeXFxcnJyfHx8dHR0cHhwdHR0YMHDx4cHR4dHR0dHV9dXY0xnrl9+73vfe8P/eAP/OXv/Cvu7U05gdc0LH05Y6mnVlf0JDL64SM8/e1v5PiPHOqRz3riybzu+X8tD/WUb/r48R9/z97dEBBEIUesZ2dnp6enh4eHx8eHR0eHBwcHh4dHB4dHhw++dHB4dHJyfH5xcXm5rsuQBtVpFgwkKEvkUDYykoYRkWb2g3/9n/sP/4P/6Jln7pi95rd+g5fyG6HwT+5QoPAEZBMRY6xXl5enZ8cnJydHR4dHx8dHRwcHB4fHx6cPHjw4Pj48Ojw5PT3b7VZJEsfYQT1ygAIbUklCEcpMujE1IJpZKiQYDUJmpHKATSFBSkjf8R1/9r/+8b9z585zf9xv941Q+OZuj62nHgY4mbnb7XZXl+fn56dnp8fHx0fHR8fHx0eHh4eHB4eHh2Uy5+fnZ+dnY0VkrgHIyISkFEEJUAqKaz8mABDhYAogpZTS6ClJCUKACQkZWWeCVGaSTIUgC67MhvHXf/iHfuQ//c/JZvaVKwC+EQofLSq/+kF43KGwYC/BuqYPrZ4IrrFeXlyen5+dnJwcnxwdHx0eHh8dHR4dPjg8PD48Oj46OTm5utxdXl0t66pgREqAFEgFJEQmCKUkDA0CFElLZSrNzM2VqfnRBgJUAyVp7wPrBUWABBjMlAB4vV6uKUEpM81s1SBpiZSgSIz/4b/7b7/zL/2zpH3FobC98dz4+vETw8Fr5dtvPE193X0eOdTr0gSvdSave9rSNTxgeYfMiIhlubq4vDw/Oz8+Pjo9O5lw+PDw8ODg8PDo9OTi+PRot+wihoR1lBuBUiRDjMxauszMTGpvx8BASkKm05RKEIDBSRITYHV3RaaUgM30DWQSHnUcAYARmQka3dcIcxoLMdFAZgZCgJQE3V1SYzMgbWBIgmT/0//6v/zl7/wrr7WAb4RxaE+3vtfavrJ3fQ0O+wYju15NvpWZ67qsy3p1dXFxeXlxcXF6enx6dnx0eHxwcHh8fHRweHB8cnxxfn52vlvXdV0jIgjLhMyMFmOYUeLIkDRGZfIioQyWVwEAhALAtAPUrV+nbFI6W2aAcDNJsjIdQvsIaEbBaZAAmpFAgiQTgmRk7RWRgNxMKVZsBM0sKcI9QwTAdSxjt4RZ32472Vpb1wWw3/rtD0dka195hthey7M9Ekoefv7psorXCotPj1xPOf5TIuwTz/nLngHWse4uL84vLi7Ozy+vLi8vLs7PTs7Ojo9PTr/04MHJ8enR0fH5+emyruuaa0Qs64iRAyNWay0ShJtbRJQrWVfFSKMiVPRPJUA0i0wVpgHAsigrdkiRACW4F3BOJ0PK+naZ7oZIWjkjEliVAFKgRFpFOUEGEgwkRTPjdG9pJCIFCmlWAVRCebwEmZiu2MxicLdcgpGIs5NjR7v/0ksAzFwRDw6Oj4+P7t27//h1eaOh8InX4ymX6pHnn+IqH4svrx+5vvzPhw/y0BHmPpGhiHW3Wy8uLi4uLo6OD09PT09OTo6Pi7Y5+NIXHxwcH5+cnOQYgAB5c4USMHOzZuYpujdAESHgahkWWkYkRFmsAwYi8moAUMDcdmOtCz8XOuXWQhoRZkSmuVf4GxFGqjI3MyMxL7WMpAhnS6aykSBpJqNSAKIsDzKzzJRkBMzKdEkarVA86IAMFBBmRkPO5RNkZgIAZ60APRWAoHVz8/ZP/59/93Nf/PznXjn+3/+3n/jA+9//7AvPkXT3HHF6dnb37r3XveivZR5fR6Fwf7pZIGes67IsV1eXu93l5dXlxcX55eXlxcX54eHhycnx4YMHDx4cHZwcnZycnZ9dRGBkTgYF5t6swa0b7cbmZrgERCpipGIdAwgoKxevj65Pj4wOF5gpJ0A6TZG9bccYyUxg601AYu9ZjEq5kTBzEzCkyeMQkszs+l9MQ5lQ24QKSYJIuPneS4lmgBqMZtOSMH0FjZQoJEmIxkyBBskJsp5H1p4FiXMfBAiQRlsU/8z7vv3s9PSLf/iZe/de/Ff/9X/lYx/+3Yvz81oKJ46Ojt/x9q/8Kr+ZoXD+j33K9DCS2f9ZiZYyri6vLi/Pz87OLq8ury7Pd1dXV1cX5+fnJ6cnx8fHDx586fjo+OTs7Ozs4urycllHSoRnytuWtM2muXtvPaPfvn03pTXXMUJSRmYKg6GQVrqjahcUxFRqJncys3zVGSoBNxeIVHcXYVLtEBGCzAjQ3CIzI5q7IkGAyFSZI1G4KZ3WjPXRADNlRp94iwRFXVt2JlwYGdeLVR5NQkaApBEppcyN5dUEQm6tjizSQKWMZo2ppKBpuDA3FeYDIIRE+qr47d/7/YbLJT7/4r379++/8PGjg03vSc+Mw6OjJ173r3UozAxpZk9jrJcXF5eXl+dnp5eX55eXVxeXp7vd1dnp2cnJ0fHx8dHR8fnFxW63Oz8/X0csS2RijNW4rZsb1m7eugnoxo3nn9ncSXJdx7os6zoyUsL51Zq56+ZS5emSYGYSe2tSyCiKshHDaCAJ0uj0EVEpvU2+R05LZTdrtKF0bwQjo9THRiRkooAYw9EIVohhc0USYLPMhGRmMQZSNNalNVpkCsUZWUJOU4QcvTUpBYq89mpFc5BMJMjee0QgRcDMUlk0CI0GAyDPlhwAgNbasg46AHTzgCKz0YFZEVzGamaELXm17Jbd7urt7/m2k6Ojj33s483c3eFNAk2HR4evAVHe7FA4gaCQyoODB5/4xD/+/OdeOT46Oj46uLy42K07M43Q1eXu7PT45OxyWdbdblnXFVIEAubu7o3u3Zt7M/PeX2CH9RFr+BhjXSMi2RS5nl2APL3YIRNCSiBoNsZwd6WcvgruzSmlmvnISECV1RMR6XSj00xKolgambkbV42KR95cmQ1uYEoQJntjjgwRY4SbZWYKEWkYdENCKU1PZiyiaB+26K6JcgDJnKYmiQZkJoFmAEwAmEBzz0xSXhmAI6FGBxmZNBpdEChLB2CE0QIZkntfEawICbibIDMHQLHV/wCFkNy8EtXe26c/8YnPfeKTlxdn73vfn3nmmZPP/+EXtjdvjQgqAR4fH/1xAM8fLRSm8h9+8AP/18/+zMc++rEYa3Nv3mgA8Mrnv3BweP7cC8/f2Nzc3rzZNjdu33x+c6OivF0to8LfbnepGCuhXKqMYO6RCZgZMkORbg5AKTojgkJzV1bGBDMzs6pB9M12jJVka22JwcrHhbq5C+Xu0T8rOLTeMkZEGkmzkRERZuZmiizjABlSMT0Utt6G0t0R6WapvDq7OHzwpRyRwHP37z9z85aZCxiZzf0Rnq8gOyS6ZwSLBSebsCicoBlViG0fR2iSasc6hCQSCrlbJX6S3FierdOHEikj9mDuWtLAfEi2EAYKBHvrR0cHn/7Ey+/79nd/8Dd+/Q8/+8nd5RWa18UHcHz8NQmFUu52ux//8R/9uff/P0wBojUzEfbg4PjiYvee9/6Zd3zb84fHR+dXV8uiy6vz07OLeq+ZgzTJzJIWEeTIQgPmmWreJqFgTFMomXL3WmxBq0bB0dYaHSn17QYjM8PdpSRpcDNAots6QiGAGaMujJuZMUETQgLNoSiagCSYEQLMLUd4wfJiFqHIJCwinRS5u1q+53v+2p/7zvf9ws/+wqc/8+kP/+ZvvvM979luzGlpDM2UzEkaR2Yl8DBkhINpYkIpmDmttxYRTgbSjAFsZLscRrMJkNhoK3K6RlqxWE5mJZkESVdZpZRoxj0HKgedNGmFBDUxYOVtb91+9h984Fd+5mf//o3N9ubNW2zTQZo4lAcHx1/dUFhHuby4+Ft/69//jQ/+w0AmrBHAAuKLXzr6pre87dve/a0HB0eXF19IYozsRjN675UnC8iIgJBBwN0zs/deSAJEjKgqia6DQmNmcX6aeXqGNx9jFLyIEZYVWuTuY0RrDdJYVwDlV0jrva/ralZ0tpJccxjNbeJq0jKjTJNWQczxEDMSWYURAJVyYnOjf+9f+653vPMt73v3t5+v+RP//f/49372p9/9nveqCi0pSJUe5v7mNjNleqUylUqaKRPlzIwQHJ6F+cp7C7I2YkxgTgNkgAkrIJZtGYiEQBaF4TRZZU8q5J4klbTJg2UkpFQKYG9deuGFFwAIEwMyckBEHB8+0L6j6+kW8sTNngLPHwLm+WM/9iO//IFfurzaLVdrLMtut4wxDg6O3/rWt9+9++IXHhyE6tqhsYKMT3qZJhZqmQkRaN56JYwDOSJgNHcRfdMTgjEhVWkCkDRGUJaZsLlmRpaDMhIJA8eyZmRrzQACbg4oR3RvNCOp/UkYkTFeTelbs+b0eh8Sojv2bIK5AzCj+0TW5j2Xy26bP/ziZ3Ocf/f3/lU3Vto431IfhyI2X+Wx6ihI0I1eSM8S89arjNlhnH6JUDpnDrA3a1shVn3YqCo5z+9r9bksrymZs9EMMEhKTNdGgs7a2SCwCHyblbpAOiHY4dHJI8T1Iw9ea6sdXmVxHtke2kn/7z/4hb/7f/zk1W53tS7LGGNEZpycnj//wv1n7jx7enZWYNl6S8nMzJyggRmzbkqy9W5mN27cqC/gzVNp4qb1ggPuvi4r96JWSe4V8tFaq3JpZrbWSDZwqK4dcs9gAcV3k2SqEnDmTPjLDc1sTkDOoohNv0iS1ry8bZmHCaLYzOvKwZjCnZvb3/zwx07PTz/7mU/HuFrXy2du3RZiWiKLcIAZrbV6xs3qCzrLnjhpjP2rRbgDU/BSWafTnDZjWVVvlDb3pD20YaIfSCLQiiBLIVMZgiWMQGaa0jivLwFzJ+nenR2q+94qmB+fHFcJ4doeHnnwWhveYChc1/W//C/+sxgriFA260Uq3L3/4rN3XhhrFENopELNvYJXQkm0TZ/QuPcxBsllWVAZyggAG/fdWGEWEVa+KNOuK2sRAMxsxDC3SAGo44Q0aW/BmmdmRPS+2RdVwszNJogsrtKAOhmSoX3FhRYR5mSKmE4nMn3Tx7qCJF2KWTYx82bHZ+fI8bGXP/kXv+M7P/KPP/J7v/vRt77tm823u3XUPgRNGpmaUoiZHkZEnRMkN6uYZPU6G5CcnACJohIyCMOkNENhzZkikKRAK/sFgjLJwJxshJw2c15ozaBZ2WLRz2aVzRRbplBkfUmJSEg0np6djbG2vrWvUij81V/51Y+//PI6IkYiuSzLGItZu3PnrrFnwGAFC1prY4xGu7q6zBhjrOuy1EHKGsaYBGDl8731ZV1AuJsXIelGt8ok3d3MzD2h1hoJqSIdy3wnKjLLlJn3vrkOOmauIkVTSmUqIq9TRaO5uWO6innvu7t7Frvtrpj5XSrL11ay1rxvbt66Oj0+fXD4q7/xWz/4fT9w+/aN06OTZm3jzSoOomoqcPfUnichSca1MKEuf9kZaeZ14StWG63AqJvBDDTSmjWCMM/6huT0OlUAp1VO661VcqjJzkqZyER55sKAAIBUClkLDqibGQg4aAa7vLxc1uVhe3jkwWtttcPrZ4V////+2VRGqrHcqWKMd73rXWfn57du3QnIvXWmpGW3y3WcXu3WddmtSxI3bz5jbu7eWmtmzmt7JYBlWfpmY8Z1WSdqBkaMRiPo5msMZbp5EYLFwZpxGWPjLTOb+zqG9x4Rknyy2NnNRaWSUGRut9t1WetCRobqwcwDzGk5oh4n5OZGVjGSpJtyjFdvRGOO+Ojvf+S93/6e44PDn/jpn/rJn/yp977rvRdXO3Ov+7Hqg733MdaJepACQzIQpDIBNHMYY8SsuijdW90P7lYrZSCaKauKDGcDUFwJpHLVmbKpE0P9uSixDkk5BsnMcqWtFtkMGUkYwYz0qaGwgomJBGDA+eXl1dXV7VvPPm5Sb8S2nhYK6/3/6B/9miCIoZIT5bKE941XicStPHyFrTvP3f9L3/MXf/79P788OPrkx//g3r173/zWtzZ3csY1kJvNphij3ntkZMq9kcyM1lpEFF4eY3jzsY4iPI1UoRCgtRYh95aZbp4R3VvVcmjkLLclyVDSWFYFIpVFrpq3TEEc6+ruZdNZml0wUka6txma3dYxaGZV8wWudvGjP/Zf3bnz7Iv37//pd7x7F5EZvObPMst6mrc1Q5NLn44rMt0tJRGWsr1Ms6wKlLsX409WXFIlrSqyFARYxQNEIFJCxKgIW5WPhKoeVP6yoq0yQAYCQzSDVhcMZGE9Z7O2jhEJQQlaxPn5xb27X2Fd+MsIUj3GfV1cXHzuc6+49fpumaoq5vnF2a3bz10bbgHtZR3f9y98/7/8wz/wPd/7Xec7/MxP/tT//N/8HQBvf/s7NLKCjVK5Duy19nU7kybJvY0xWmtZtXppjNF7ixGzUO8+HV6muee+stpaU8ZIuRdJRhg0ZDa7Jpt7RogqXJ7IVFrzjKyAq5x1EiMBVQI4rRBIyXvbB9Zsmy7Z29/+p4FIeEYyUykYG1vEAOnNplFW8BUy0wAQVl+YbESCiDTjqxxK5aZkRMCEJIgxBqShbLTMDAUyQUDpYFS1E7E3XXihqczuzuu8VJjkD5EaQP0JlKwmgCSMtzbt6mqXQUKnZ6dPdDdPNJhHjOfRUPiIl9vtLih2N8FFWoaSaDw5Pu+b23UPuXvpQ0asb3n+9sHRl175/Kfv3XvLP/8D3/frH/y1j/zOb7z0lrfcvn0bCQHbm9uIWNdRJbBiJosKnSJcthFDCHcrLUrBE5CKMFrlb9cYS8rIcHLjlkDznjlI9t4zS5bEaa9KARFJsxiD+wJiZhKWEMneNzkiMxNorZfIHEClVBTcXZHruOp9C2UqDAzAe88I0DbdlrFOdmBf/w6ot7ZbFyv3UzhayFiVFplDYTBkLiMMS1ThrKr4ks30FwMg6JK5zdvSzBXENbAzCFAUhV0J8wRthLvIFspeUi3PWWTdl54iImLcurHdrTFSp6enj5vEUwzm4cevFwqJ1np58gAoBySOs4uL+yXEzrxOet39t3/3I29/17tf/vjL283tF5595u7zz+S6nJ+d37p1S4JJY1kLcmFfLyq/EmN4MwlC9O5KKlXwvYS8ddbJ4tchBWdWZKXE3VdmKe1rGpJZl9S6kWQSQut9xNqaZwpk5r5SkeneMoJE9zbGQCaJ3lrRGb33iuABUhmZ3bvMGrCuu1QaSWSJ7Ep0VctsoJQxBqclaS0zzfKGQVoOiDKzEMyJCKeJImGkC2QJdfYmoASsgBEtJaqYM8KsAR6BZpY+syWyPGE4TEqATBn2awuDBKa7ZWbE6BvPHc7Ozq4v0x91e51QePPG7VvP3Dk/PgGjoXhhU8duzaGcmsrK4hRu3K3rJ7/wyg99//d/4jOf+dQrn900D0SnZebGGptlqQaKQY00s959GWOz2UZG7yYpU06XKTMiB83czM3XMZzOYg3o2LOPxRyYPBQiWnOaRYbBpHD30umaOzLHGEAlhJLUemdkgK0xI717JVHezMwyshK3WKtiPTthvG9HjMxA5k5pIErLLkkZCUUUko4ISFVZypwBrNOtgpaMZkC2LSQKcFVul1BappAj7SqjG50N5jA0bwaTKtX0oLXJfWbVLyLTaQk0zCeVAj2ToAw0UE4lWrMxAb5Ij4BZpyFi7d3Pzs+f6G7ehFC43d64e++5q/OT1GRpQaawXlxmREb2vhljSNla/8IXv/Tg83/46T/45OXx+Xvf8+7f/K2/d3R0YLj10ov3RZY3t+KvpYhR+CMi3D1DvW8EjQilqpBSlFjVK0aM7Wa7LCsMcFPiRt9kjogAmZED2vQmZUZW9mr7iFkaUezZa3ePGK31iNHFMLP9/mU6ksw9gaHSoKPAOKExolK/SCFCyKk2jZVAKCVlwgEwWMplYeMtIbiX/A6pZCKj5BF7HhKZcq+qfSNt0z1zgLYhbRIWZm6cEi9WKWJjzUAR4ITp3fpIEaJQVAQMqEShSrIAMPF9ay0jzb1Y1xjl+zIVu6urx03iKQbzRkMhAJL37774mU99prxCIp1s3gDGsiSxrCK9mTXg+WeePTz44nvf+afWNXZr/Lk/+xd+9G//yHMvvHDzmVtnZ+egFXHg5iOzt7YuOwARqRibtgUx1tWsycXpjq7TI2bm1bJrrQEys0DGGPJSRInAzRubdTeaWziAyu/Qml+TogVopWy0SIwxvCJNyvaVsszIYjR2O0CRGZkmxUghx7JDsXHac0IqCOhuTrMt3WgDg2TtEhKgiJWApIi1YiZJ0aQk5b6xa72N0VuDTFIzG3LCSgdIUjLSBNIJqM3KhNw9IkircoOUm9Zm56BVs2GimYRUehkXwJREyYxaMxJIYLPxMVbQM3LZXeKrEQrrzxdffLEiu5EOBwoN+BJpTkaQsNaWiFt3nv3IRz76H//t/+Rtb/uWs4xPfvRjt5555s//+b+wLGtrm4KsVWlOKaXW2hjhbjQmgEx3b+bLblGbkpEpkonYbGqtRmubkUkxNYn+kt9kZJHmdXokIwZA91YuISJGxsYL1Js0cuRF0NYIaB2D4BhDCilneM+EGVJIWQmigO7A1GJ6phEJIHKN0KK0uvCEIPcGee8NpmqU2SCrVikgopJE1GQOCc3NWxsZxb+XtzUDRrbmEaITSGMbUQ05aTYVy6yWw2K/zCs40EuVzOZeHWCBErclASEVok0K3s1GFuaDeXPlweHRo/byZoVCSS+99E1OYi/irjNwShnuWxLe2m638+7Lsrz7Xe8+Pzt/7s7db7m1fRa8cfPZdcTlxUW61R1iZIl6azn6ZpMaSPXm1UwFaHNzM0Z6LQ85InJkujJSiTSltPGqzCRAMYsNMjcpqlgUqU2zsQ4yl2WZ0gNyGecRIzKqZ2GNpdEqDyjnaAZz27RGWhJTJ1DoKSMi1nXFfm8ANGutuWbxmNeiJYMIyqqvBrCMBEUic7iZObx4EEcI5tZKA29ueJVVF+CbVm08RexL2cyqjaI0DgJagzK9DJdMISQBDp99ZilBLY3GkUiJlY1nJmXupFxGyIyBtLRf/JVf/nf/nX/v8VlXb0IoBPDSiy+W7GT2mUAAzJCxcntjjEF3az7bUVLPPP/c+cUFFDduPXt8claeyQB3X5aVDX2zYWKNtd/YRmb3bYzw3hhZ0tsxVq8ehdKTtD4/2r2oT4MVCIsMCCOiuY91JURgjTVSEBYoRpjNgm9m9u3GpHW5Wte1uW+3m77ZNDOyGNqUckRkjouLXdVBSDd6cwJwb+5sfat91005P+4VMkXkzhKmZjupwZwmwc0TSaLByzCRE4E3BcyK52OBSsndc1YAA+4kJ9EGq4vo1hKAZte9uVNe7tvdNaLqXTQqi6zHpA1R5ygDbc/VSfJCC6RGmPnH/+DlT3zqk+98+zvxRw+IbyAUvvSSoHR6Xs88gRFjXTKT5lXsa+ZDGeS6W66udle7bY6otd6tq5n11ntrMGZGb33btkVmlvh/ZIAY6wIzM4cyxhjVcFfMIS0Uua6a3XmM6uklEjkAyqpNnVOWW9IRdDcU2yAqA8zNDe9bQj7GyDV3s7mU7t57N+tt08qhRoZvtsis8pqR3tqsgmcYzd2NFkrfX3PsxZpWJYFNZ0j7C5MACEW4mShm8Tel26s2QTNgT5argajCg1V50YpYdvMRxaSym2dGIlHIS+mtMdUcIsxsZDRvUIm4kEWDJZQJY2E3B5SGEucbemtjHY72/vf/3L/9b/5bD1vMmxYK792/D6CJ+WqZW9XU1lobUego2XoDxxhuRvDq8urG9sYaA8btdpOpESFh01qOIDHWsel9KQ1OjikJzFzHoASjSZGZGQMK0OlEGlEKbqRcgoNTtkUyqYnfRlXKMlNaoFIWkOatbzZbt95bN7M1VmeTUN0GCHlrmjexMnJjTDIiu81e04jo2xuSNIJQqYzbvjJBUMop/xL7poWy9c1kueoT3a1vSa6x0lHMu7eW0iwmmmUGUPQoMyOjYkSSbK3VfIfNpkMsxYyZu7lopT/LqkzMnFS9tdIJkZgCV4i276StEkipnQlvrXiy1lsM/dzP//y/8Tf/ZqG3JxrJVx4KX7z/0mx74p6AJt19WRbOYj577/OgxhL5m9nITMjLTwM1uWBZ1425ga21NSIzz89PlTmWZVl3M94D7t7N0dxYRbQS/4WUEao2r4gIjfLnVQepaAJp0ztgbpOJFUvEwDXhJbUzGNjN68v37lXyCKG3TrNQNgchuEXKoYyCgBxKkt581uRVTJ4DqB7ATffiDkhuSs4O6+ZCSezcqt29TebFKwGoInpmTE2b1U1rRvdtxDD36oEuHR2JDLq7AVKCjPJVkJuFZO4gc4zmlkmqGiAAACAASURBVFFhMQG6eypyP0iimcVsSTOZMtNQNVYj7eWXX/7Upz75znd825sfCu8891zvm906OAVmnqmaZ5GZIM3d6FXybCU3Gil3RVTNNZblmVu3l93qdDeaWaSWZVnG7sGDB6fHR83NwWTuORemoZnD3QyNrbld7ZZ1DDNQ5q23zaa33rxvNptMtNakysKqzyB73yiztZZSNRQ0s9YtM1t3ERHR3VnggqTBWt+Qo1RTmuo8AM6SuIjWIkYv6j9SCLaWCTNjaWxKQNZmNlAXr0qhe1WhG6hMuht97gAos5mtY5i5lcAF6MVbTqENSEZEplrviXQwCKdV7BtrmLmDICKDQt0XpCHl5kjRHRFAKqIKQm6ERMrMkK8WN2kemUlj2i/+0gfe+Y5ve8Qqnv4YbyQU3rp1+9at2+vZyX50gNzYm++WFdI6VqMtuZSX3l0trW8ktIT3tlt2grbbG+uyoKq/AY1VmcfHh698+lMXFxfP3XlW4BAL2NaWUNAAY03Q6JvbN2/f2mxBu7HZts0GVXs2ArrZ2oh061W45P5blOi+945CztX6MjWTPjxAOkkwituQujVwWK1upR1mmbkbozij3rrDUkpLshWpXZrCTNm2AVgzvE1Vz/VylzOD5DS4l1SkABU5+wory1FqL57K1npGYk/IFawH1OUyWsLIiEypBG0AU2nudEZMsy7Vk/YzSCA1b1G+1iyVtpfl0SwlVdGiejf65v/7xV/8G//a33jzQyGk+/fvnpydVT5YYl9BESNUKoNqaaIFSZ/9z8S67JpZFPI1KmJkmlmsV2fnp5/97CuHB0f37j5fDQXu5vDZ8pBpRGQAAch7v/P83U3bbHpre4nLvFp0Gmm+cUB1K8vNawJUgeu60R++iuSsacCoSBpMbOYBAezW63tHJswShPl2696MKp+RrRnVij+zbpUbuqPYT7fmpYGm7SEgrk9AUa0N5iC9+sz2raqqEVc5Eb0X9LN5P3tjhnSN602OgJy9EDoFSK36w8BmGJndfQhkQm3EoHvEKOV/ZQjGyc3KkBGNHFOTZe42xvrRj3z88Ojg+ede4J5MeSPb64dCAffu3Xv5k5/CJFeUkluTbF2HNff9BXP3ZV0LHyzrYs2rsgtwWZYbm83IvLy80Fi++MUvHB0d3tj0TfNKrWZl1K2BacoaxRDRN/3ZO3e3/cat27eQ6caKesXWtNYKW1jZCtDcEAkZfA5/qup4wSY3x+yNwbz25mBC3HhbMmzeO5RkzSvkm1l1OpR0zDwnwSDVgLFybHWxUfyTAMOYVZSqtXtpFapTI6vMLBX39Wp5gBaRKqVLzmZGABQyg+4ZWTXlyGzeIkehrvqU1hoyDRoSvaRedeMIoJunwlsrI85Izg4Bvnr1s5q5Y5/x8OLi4kO/+6Hv/qvf87iR/LFCIch7L77FyIFqYBIAd6fSazRFqndX5X2lU9h0p0FMwslcVzY/Pj9zYuyuTk+PTg+OterG7W1IneRUMA6QgQE1N5BK540bt+7ceaFvO6XWN3ALyZtvW79WF5o5BUzBHM28kgzbJ+8ABPXelTL3kIzZzKc6AF7Ng90cQFSrPjJnrY2teY4slxqEsTE1E0IISjOspRKUAWjVjSi5qXqjU3KycD5JCO6dGWzNMgVY29BsxKipVsogDVWeJa3QN4h9sXWvgk+jJdOF4hgpFZ7oBRbB4sNKtJuZxmrRzsww88w0mpUMM+Xmq2VGsLvWaOCIdPcP/PIvffd3fTf28x/fnFAo6e7duw7WiKYiAmvszm4sm5LORRh9LlrktP8aZBBRuAGGuLzY7S6PT46Wda2QP8aQ1L1rXqnM4lIQEjbbW3fuPH/r5i1Wq7y1kLpba42ZpTgFkMDea9Y8O5QXKYoSpcwhQnJ34ySJSue22Wxmm3JN2iBb+R5rmL3L2ayFj4zsmz4bLhwjk4CBmVgzBRTPAsHdUnNiljIR6W41XXL24Jfv32xS6VbC0alsqzGhJXap0W3NW1aJKVmQqPJruo8RxRfQ9ktunNJ2CGYjw6wGRZaWlAaOGOUaudcsle0OKioyRjIFYkA0IvDBD34wcwo9nm4trxrW64ZCQi9+00sroqjbEgmV3EOJ5g6zWs3IMNDMS40ZERv3ZV1IDuW6u1iX5er8cl0SEaYSZYeEMdZqfyCgGGw+acCx3L37AuibzYakm0mQghDdWvMEN94qtJUqwUVvBY9oQkANZo4BOPagPJNg75vMhBsyq7bYOBXDUI2bUgKz+6q14VNpviqaNxN7b8gcwc1ms64DgJQbd3D2mBafhBKRuivCa04/AWCJMDMYDZYZtCJNkJm99YxoJSIKVdEmqggpZ07+aZaQ2EAoNIXdZJpdLbu+D9CizGeTU2TUMlajR+q6sxXdPCYirqy0jE9o7ROf+uznPv/Kt7717XgzQyF47+59V5mLDJ4IVvNaRmTcuLHJMUqcmc5mdrXuWts0cl0XAmPZidAYOcayW9ZlLTg0xijRRPGlXvJrcIxRiPLs7OylF188PD43N/dms9Gv0FWvUWlGF3J2dVqNHVNlN0a4W9GpbRoljPTKEwVvTUqaF8aH5OaRs6lalIHsxcmKIRDuDSkArc2yTD1ozVGFQCEjaLQqKgAohbu0aX1KOsnmrRo9zDjLZZjV2Na7IsDZMl6zrSTz7iOCBBojRiFIVNeY4L5XcACK3G42BCogUCC0RhTQNKPRShyvvaiNnOOWWTiHU7ubIyFC/LXf+PVveeuf2mfPb04oxIv3X0plM0saU6QlswrRANfd6rOtis29tbZcpkYsOTLDwBgx1nXEcnV5sVuWiJj1Lckw5z85La5JnfLsRGvt6uo8x7j9zK1N36413FPh7mMkaSXv9H0eN2Fyt3Vd3UxQ9xYRRbGOzFnZMBNnpGn0lMVYzbsMbrMLOTO99Zz9I0Jq200zFS3PopSs5L/VyC4gk+4V3bp5VBcraNQag0SC3jd78EDR9rM7ik+aCUdUh6pZjUKRZklhXnrqGoBP4M09P/HqNApb1yuCUw1L9tZChSw5CUizKdhQzROUTdApKAtArGN1obH98q/+6r/4w//SG2dJXz8UArp77x4gXc/upoHZeqv2pomlMt0sItflyqtcADZvy9WuqopjXXNE5grNxpVUAubzcmEvMahYlKB666985jPf9JZv3fYtiRubTWSSXRJNbrYsa++9NR9jVO8ygBix2W5HjqpeWHmvmgpihoKAoJmXzr3K27QphalJaN4bgOtpJRgBMFgkACeGKQRNGZ01dc33ZelaFneVaJ3GOcl4An6UkhgoSFGaliySRTUzR2PfdlbfK+fAyPrRG4gMzqJM+Yrcd0fYrLE2GpcxCvxmZhHFmcH9aLzSZ5c9Yc+MABgTPuZMJN0+9DsfKj9yfQPjjx0KcefOc9vtJoYqmS5VpTWLqyhMMsaw5sh0q3ue67rSELslUyNjrMu62y3LMrE8OkuCRZQYWyoIy30HvJEJ5Kc++clvfuu3bLc9xczc9l56XzM4WdgIQGt9z2yxuSfgTjeLEtrV8KNMSH27zYyy6m6tzh9uMNbchKIu50rNE1PrDZXwc6+yF42FjdzdFOnOhKxNAdkUa1aHXKq1DtUAVNIAQ8a+H6SIrUzMP6vIOeV7ItxtXdb9FZ0yisy0mq5dLGjEDGpmktxsHSrmM4pBqOF4AMAYZbthpeGmGadknFCaVfPMuh/Im9IXvvDFVz73ytve+ranGMzDjyf8e8oGoPf+/PMvXJMlNDdaNyttHaevIPbjpiGlYrcua8S67qSIzGWMyMj0MYEB8jp3nbW+FKKGFxhFVcDkxdnp2flZa7PwZ8btjRu99+bdjK2ZV6mINLPWvKp4Jfxyt+bshc3NmzsgEr01a4aKfc2tNffiNVnEWnMvMnaz2ZQ8WsSmtd5afVDVnqzNgcq1Q/XUjzEm+z/ncMxipqDijYrPqkPV0EcB5Y0oVGfQBFioTvswnyMltKfZCptO4cZ+sIWzMKUt60hoxGjmIkZGCRnqGpqFELCa3e2zWbtQ45zggIFC9qC5W4sxPvz7Hy7TeV2bYTX0Pd1dAXD35557rgAuIasl8Ib9LxfUPQoioYRSYQYpllgjRua6jh2AEZG5kJFMEIhqQ7hGD6hRHZGC9pwFcHD4YN3tzNi7bzZ9u92AdG+kbTadpHlrrW+3296bu5mxNTezwuZWsIls7m5WBkrapvVeGj2f4J1m5uZmRf9g7xhaazRrvUPVsmfuvq3yS5UZbWJ1n6NpSq3sdEtjTK6IZaoAZkkAAOc9NbFUZkbafh5JXe46l+p7Zf3yCfb0QWr+Ekp1bQAwVt9A/WZAlYbqhDOiApVSynlXo6ThJXaIZOrVCeFF3xiE+tGC/qHf/RCIJ1rI48bzZdNmHn58/Wft98K9+0rVbLIqbjk91xEjWOMba5S0FDGWZV2WEUM1e6i6mce6IsVsJobZisL+s1M057R0QiQs4SGKCMRnX3llWXbbbTcvrTd6s2Y0R2t9s9luWqs+qlrikn5XJ+qNGzfcvTXvbpjTaVH3nNHMG3zObpi2RdKt1CNTGbXP6SPCN12Em1kVfPhllmSkz34Gm8Nn915KUqaKNAdQdjCbpCdUVkKsqVqZMVIxTXbOwgKq6q9USY1UdSt+GRUcylCaIRVmnIN+hVk3rIMrE8qoYlJWbC1RwwQAZhGhCEV9Qmmt2+986EPXNvS4wTxiPG9oBqmEF+7fk7HtGdJhaSSMSUny5ldj3LTNKB16JEUT1uo7ADMyFEMZTNJ7xACFUu8CQrkwQECSlkr3VvXRFE/Pji8vLm7efAYQ/NVfvCku1EzmPSYgmM37JaqrRS8RUmv+Krzdz41qtEzlnmCsJfb91KRaI/dXZQjulbKYN+aU4JXEJcrxNPc1k+ZRvesAXu3UEDljliT6bOvj1J1WDJ1IMUZoX2+pe6bKjgRmUWhK2MR9MRQSIo1cx1oNP/uByojMPlMcpID9yF2rBqWs+uykReo0qqu25mUok8TH/+DjlxcXt27dfiM28/qhsP598e6LrLkFxiAE9tbALG2bRtxomzHClLEudSMuy85MQrXyBZVWv7SnAU1xLpREEOWlDdp3mNMlEE2CGS7Ozo4Pj3pvrUKX2ZyS1czdvDXSCoG5OwkpAAuw/FAzN9gUxwC9bzIBpDuTmTanQFkxvSVr+fLf0ZCw6dv9dDUvirOmdvkeRwuIygCtlBp1p8yeWJI1bGJd15oVtCxLzThFde/MgLaOWAMFNO06xikyxyhDryclRSY1h2KMMVIpKbK65RWRgI0RY1mgHGONiJrpCklIQjmCKaSccyBz3SeRISLmL7BWrUiHR8evfP6Vxy3kicbzBkOh7t+7Z4WoBAebwUxmXNc1iQDWDNkUDAGIGK21snfMm6Lspm7JFEbmSrdQFW1FihbVxFNYt0YNSPz85z6/2+22202Ve9seGZFz0N7EPdtNvdJaq9FI2Od37tbaFMyUE9oLj+z6mTKEa8hVO8zOqn3Rbe+l+KqfmE5lllAn1tnnuXiVLAgh6rKVydb6ZOYYAXhx997mQK+IqME4ZUmTdhJKcXttWzXWISIqUOYs39TPW6j6lCRkZEZNrdnvllljKQeUyohYFE0YYxTvpTkzVoFZGSP5e7//e69lMA97Is1Bdq+3Abh7/379EkIlFoAlSrTGzDDVII107wAzR2ZERq0BZo2EUo0WoECHK5HIKs4LkID0korusWr1RQUwDo++dH5+6k5vjn1yVGZUDwoFF0gvO2u0G9sbtkfoUPbWzGoSuJm13rcSzdqESpBB9UuUM7UxA+jWAEUOm1O0vH6Dq4bf1Ti4mg5a0lAGXDShVL+RWUWkSvYlFe1SSV+B8cyolV2ulgzFMkgrHkuaeGhkRoZYTDqigi+xn3ildR2hzIwRI5RjjMyMGDFSiRFL5lCUSRXOoiI4IosHyYecTirGWNe14mhNsqTs9z/6MTw1K7x+9cs6e54SCu/dexF0JYwuKZWkmnmM0byVXJN7PiJnuamMY5/eVYF9n23VikFeAQhA7qsTKu6pqvU56/BXl5cHB4d13m5WLqembpUwurVW8RHX2Jw21nW73doenmdm7w2vXkh59eVVtCuHsY9Z14uQ+2HuNXVyjFGUj+Zcs3nHmtmaMUcNtTYyQZZzqW9dcTCrGUZA/eDF/naf3u7VAkuSHGOUCSIz1pX7X68sZxkRY4wlRom8qztsjFFJ4/7gkMaIpR7XCcfe50VmmRSFgMb8NYsaYlDRbP5wS739ox/76ON28ri1oJj317UtAC+88IKxSu8yYyYhbrzHWBF5GUszAli1QpKqjsGslY2gkIY2OOtPUmU7msmtKWCzp5KgkxISqtmyWkc8ODg8Ojp65zvfNcawbphqIU9FZGxaW8cgZzNTa02iEE6PjGJDCvmNUYqxVnF89nZCBZ6MluQao7cWNSoK6cYEqrZG0mn1UwM5yVKByIgU6kcMlFrXteSpwvx5ymVZytvtxupFasPdZpE+M5dlqRnPM+EYcR00I3Ny8wCERI4Y13G2+hxHaqadsw8vKRQsy9lXWLP96kfLACHGaO4ZNXeSkVHi93nbRERmA3O2z4nAy594ecRo/uSfuayzrZfeYFao27dv37y5vdpdZCBFA2GEYSyroGZemqHq06rketJuwKwOr2Pde9sSDtQkJ0xLnCuXEVNyhCkWT6kRl5eXh4cHVXxd17X3BsxZbZZ7Od5eqMmSuRIwS4Wl6mcB1nWtUQUA1hFsDVU1zMqS4v+n7U2DLNuy8rDvW/vcm1mVc1bWPLyph/e6+71uupvJkohoEwQ0EkPYIX7YzSTAYBwh6YeswDahMKCw9ceAHYTkCGxZ4bDCCkAWBgEyomXAhqaDVgOtbtPje1UvK2secrzDOXuv5R9r7XNvVr1quqtf31eVrzLzDufsvfYavrXWtwCYapKgyhCRrpRgHaJ7mGae6zRrUupyicSiOFlciV4rIjvzdYmOep+TUI1jcY4TT9302tFHIaImZ6ZtS5IxvDmm9ABUOLBSSVGq4kTVi75oAGgmQDGY1zvDimYylVyalBrx6S+eoTIB1YopiipgDUi31KEBAMO9O/cODw/X19a/iNj4r45NOrQ3rCA1A7i4sHjy5MnJZESKdzEXNSbJWpzEUaGiiJKdrH65uXRu2pxA1kcnqDEFrW+iefI9OsGFAs9tx2U4Ju1lJzg42D88PFhf3xwOh4CRopqTJJfBpnb8+UHXUpIkwoZpMLI2GbwhFp6eA4cinXeIwZhSySWrktKV3KQo5SiBjYWS1/Bn4WXWDH4vrQYo4sqcs2epvLdCDSV3fdNsSskrpdScrqam53I4dl3XuQ6DIWuO5hCYG4EuZy/IwZz1YdhcTyZSHWJ2GtwSbY2OuaiqaW5S03U5rHmJ9k8I1ApNTBWwbIBa8XkeWhKZzcaT9t69u+tr619EXYVgfWmm0CSl9Y2NBw92XbSLFgEGqSll7DT8UVpUtHhTW+lIClMJJoVcstJgNNDExEnpSgwyoWehi5mE0PvhhJoRKasNxHLX3rp5a2N90/sNfdxEf0ulqEhSLRLzdjwNqqXrknllPHKJZXabmJqmMyPhjDeDxJKzKx6YqepgMBhQcs6t6zTALRo4N4abaLuORC6ZdQSAO1WlFGPvbmr1q1Qrf6TXyfTr7O62117XQC9DaaZZsxZtUjKA6sOk3ZFQF2iHSLqcRaS02TWrA/TJkDVUFgAS2UwklVw8fyRsiqoVNbMEo4iWzh1cR2FhCjVoodr2zvYLL7wVb5YpBLG+sUG+Zqy1GsYURbRIIgZ2JScAZl3XJWEl6o03CRJRFQIFCgJJi2mDZJVhB+7vV5DQvNmtCvfh4cG9u/eG715g7rpMACgopQwGg+m0deEm0bbtcDgsxXLOIn3KxIknxKpKcNfYvXiN6DVC2STJShERZygttJgkWLseAs7OxaFRd7S9AgxupEQm02mTUtDNVutG180OUHVZJJgEe3/cY8Yg8YJo9KxYUQehJKXGnWt38B2TKqVoLkKqaVuKmHVtW7Q4U8jJ1ROn1jc21k+lJF/4/Ke3r+2sr601g0UCgGs3y14ZZtaWLNWeVldEVZ073FRxfee6m4snScuXZQpB4NTWafdhAIg0peSmETPrSvFxVInMRVVtEAiWR46cVG3fv63VuUVuuiVgVs9cAJEDUWeDAhxmRM56//59s+xwQPHTWYpZpGy96H4wHLZt6wmiUoxkI6nrOmsal3jnWh4OB6XtGkldCSXny+KBlMIJ2LwCzemHnXHZa1aCytHbDy2rqjaDpm2njmrSoto952zqzCUR7XZd51Fn1pIq5y/JnIuHAg5uAcjtNNo3zVrHq1S7LlvQvIG0nLVoLqq55CbJ8tLS1umtC+cvnjl36eyFC+fOnt/c2FxeWVlYWJTUEJa79mN//JGf/9l/kHRoEk3k2eHQYnCIhOKFPKalH9qnWjJAyo2dnSdpn6cwhQCwublloU69Z827jmtlNymCYWqmRUXYta0IrbBzxTX3lgToCDwjeV+pCumqC0Akbp1nMS6DACaT8YMHD5ZXVk2taZpcymAwdHeBRErNeDrVYq6TnMuvlNI0jcHcTHTttBkOkxeMG7xsPFcZ1fpwYtWc88AsDQd+Wg3octezKRdzN8ib9ixPMskudwQDLg99zdx1bJKHb2aW89SNr6ORUdxXQrbNbDKZkNHF6oJmpWiXsxZTzaYULC+tbGyeOnfuwpnzFy5euHjm3PlTp7aWlpeHg0HtmLBECmudDdWARoZf9w3f9N/8g3M/8Xf/5uLishlKzpLELJjZIOxKZF2LKk1nBhGk4fr29cfl5HFN9CWbQmBjY929H4cTEM0LhlLQJIuAKQvhSaiu67JTanr9EaLc28SsKOEIYjYMnI+uklAVGL2fn6RCnSLbq8yK5teuvvbKK+/2xJmZqWbS2q4DRdtx06SSizNvRQW3qzznRRZhaoKDL9j3lGQuWUxQec18UoapCVNXSxSb1GgpjTQ+MyxrEZE2d+ZwlFu60J2lEukWz+4pLI/HpWQtziGjMJTizLmWW3851AqKz+ywLk/arvWiv+HCwvqpjXPnL5w9d/7ihUvnzl/YPLW1vLw6HA4dAzKzKBz0/+ABMeHMVzSPLunsNw0uP/vcd3znf/ibv/Fr4iRHjvLArGi24i6LWXFrp2a5RDKE5M7NG5ir9Xv88WWYQv+6sbHpdgwVLBHSKfkbNlm1GaRSMhPLtEhUR0nXtagQgH+uS2fkU6GJEvicI1s+hNY9D7OeiMTtyGQyvnPnzsLCwmTSFu3MrGmaruuaJD6St+Ts2qKUIpLa0nm06IrBabPpkxjg/aR0zFMqg1mGla6FmZZosii5Y5Iud1Z0OByGgTMzMx8tRkCczALQTl2ZaU3qaR07K0JTOObp2IUJxdjlrs3ddDox08UTJ9fX18+cPXPh3JVLly+dPXfu1NbZ5ZWV4XAhFtArIWRG6BU9YpS5HXTvJdLgvY/hS29ASoMPfOCbf/Vf/EozWKCwFIWQqnDqWxPrS8G8YFpoqp5juHPnjnkTyhPU1ZdhCt0SbWxsCURRQHHWMkJSEi0ZPNmImTFRStEkjZYOgCGDhcJixVgaKmltVI94+WVQmrnKLtBGKQIvKxYfsVRK0ySYaDZL+f79Bz6Qx43mdDotpURIWMwMSVKXO9UC2ECSFjWhQrQrC4sLJWfVnFJyyg13toN91DieTIbDgZVi3imvkVX0MpXUpDZ3ZlZyGaZUiiaKVSi86zonGelyKSVbTeQBLDkrrCi0nWop43ZqsMFwcWVldevMmYsXL1y6dOXipStnzpxZXdsYDhcquKVz5zzKb+jTCvsq+75x3imSGJXPBhgKIBrIj3PGAxZ0Ausbp1eWlyaTaZJBtsLiG1FqdZxVIMT67KJf1d7+6HA0Wl1eeVxXfdmm0F+zsb7h8yFckXjvx+KwyV3Xdd1wMMglIzoCpJSul0gge56wwBQFiSiFRNM0ahkwo/Pv01RBL/IMZ95BT1VQNCUCzXQ6ffDgwcrq+vxtuDtlwpwzsnpyjWTXZe/e8cPdtp33tbZth8CiCwAtqqqkkJxOpwS7kjXmfcZYXjfuFeDQtlgpRStrfO4yiOmkNbM2dwS15Gk7nbYtgMXFheXl1TNnzp45e/78hfMXLl3eOn16fXVjYXGB9InmZubFXGH0e7wXgbizP/Xss2TxmFfq8UxEjioCak8qxjcGgKlpVlZW2slU29y3gbEeNVeEhc6gaPX91czadnp4dLi2svokUfnyTCGAldVlDhprlVCtn50Gw1Kw0DSl+KTk5IEPnIFVlEVhiTRBC8KjLKlYjON8TnuoRZM4m7wZQFFD8Cw6ybkh+Phv3769eOKEWaD2pVjObd9SYYq2aBKfC0LNGtAyjMbSKYhcymDQ5NyllJz1G8Ejqgz9BDgCnLtcq2TbtnXDWnJxY1q0oLNu2k7bdjQel9ymJp1cWbl44fzpCxcuX75y8eKVM6fPrKysDodD8+YFoKoZfyiDpN0djEciaPXZ9E7yzmrXqmwde3K8XV+zD3N+VDMA3khtvXwxYX1l5f6dBy4ucKsnzm/jJ9wriBy4N6dmVS3oyt7u7sVzFx753Kc2hTh5cnlhMMxtW02750zYjqbTrhWhmHcseZuBZC0eF0X3N7wsoqadaqqLIlaKsK9NdpdWYOJpbyR4wZoWUErXjnd2dp57/vlcMJlM6DQvKU2nrQlhOSrUoGZW2jIcDrXLaorIFJkZm9RESZNXGZh1Xacu1SWbWpczHUMPvMMAlKLttJ1MRuPxpJ22oC2cGG5sbj3/wtsvXLz4zJVnLl68curUqcHCAoJozrxuMfYbqNNb4VrET/hMs7zRRvQwzPz/5r8+/uh/Hg3ZIWfxqQEQQlZWV8ycGEG9X7NeT4Szzv8Gzw77rBtK0by7u/vmRIX+EJH17Y1oaQAAIABJREFUtZXx6LAmQ2Gah40zWMYcQwuyY3OfYJBEcxAdeOrGZ12r01R7S0UxkVS0OPqe2B/DUFSqWouuzInt7t69k7s8zQpJBhTLWoo0DcyK+sHSUjqYKGzaTgnr1IZJKGynrVC8d6jfHs3FzHIJYkEGIKk5d9PJdDqZtLksLi5ubG1euHD+yuUrV5559sy5c2fPnF1aWhZJWTVrZ2aEY1cdapG1GyZGL27c1ZyYALPf1ALRGA9ef4g3lqH5n8yrsfnH/E+09+gtLMLS0lJ28CpwQxERqBfGSSnZ9UCilOI1jqCxqD14+ODNjAoBrG9s3rp5kwZ1hBOUhqW0rsBIBzq9/shAa7vs3aFGiPhUcPOLd682MmjepFtlC1AyhdMBqBYRkKJqPgLt6HA0nkx8eDKqbxmxPQmD5tK2nUQnsX+YHLUj0mnfctu2jmX78DcYRkdHk8l4NBq1OZ9cPLG8unrp0oWLly9dvHjp8jPPnD5zfnllZZAGXsUbiVtYMebShWIABQrvyQYgsYXhEFWcuXeJgOpmz29BqKhH7Ua/NXPyFNjevG570mZXGOLYm66srjnu7s9QMydAMsBKplOTRVNHJFs8v3P/wf3HP+HpTSGA9Y2tmFNd6XeTNKqZamwEsKI5pTQcLkwmUzNJzaBrp04GHIciwX2d6loy59YRfACAD+elWnEQi4Ykflegk/0BXdvdvHlrc3PTxAvPk8f/XtLUdV2S5Kk6xyQDlHfe4lLG4/F0OvWvw4Xh6urq2YsX3vXKy5euPPPss8+eOXtueXkVsFzqshtMTM263AGAVyhYtL7BjGoQeO8Eqh1xoZHYzjhJ5rFdVVpvIBN9adgXNY6+HP4P1hqHJwoVI1Kc33gSy2trRYujMCQHDJIcmBc8oqjCG9/VnTBVK8Lm4ODwzTSFZraxsWEGkWReceY0hkCBMXfO3FJKsaIpiQElWxJxQFEgiamICShaIKZaCBNJsBSGwacRaUVIzffRuX1SNGZIkgHv3bu3vLxMN4XqQJX3nHkBpTaSpm07noxHo6PxaFJyPnFyaWNj4/z5C5eeuXzh4qUrV65sbm4sra43g0HRYkH8bmY2aTuGDxTBPCNg0uoamZgLgNERSZ3JQlVZPfIeionH7eBMUAD4KPt4YZjQJ21efUn8w2pb/eNKYV7JHTc+NMHyylophTUMZe0pQrR8mvhANhCWHX8gINCjo8M32xSurx+7UAZtby5l2DQ9cV6tXKRQFCRBsaiatAYoTQPNyKCVLpecmrR0YpG0yXTStp1ZDDcMHgXSAOemKMqhJGi5c+fOs88+OzoaSUpZy3g0mkzG4/Hk8OhoOp60uZze2Dh77ty7X3732XPnXnjxxUuXLq2urEry4QumBWrFC1Tb6dRFWGpJRS8aZq7+Ub0hszqix+IYVOsdgZXbRJlTIC6AvdGb86PNZt8xxPARUZp7m5rueMKjPvOJmqv/RWgscHV5xbS430WaQgBG77PFghQzr4EuWoaDQdu2MDt88hzDpzSFm5un+qVREIokpAlVi6r3yaCCvykxq0mTrOSUGmpHsHMqWBMkJFpRKQX/yY/96F/5pm+aTkftZHJ0uLe/t7e7t3fv3t2HD3f39/cO9vYmk/FoPJ5OpjGPxHDvzu3Pfu7z46PJZDIW4dmzZ5997vkrzz333PPPX7ly5dy5c2k4aLuuy3Z0uLe2uqZqbdehRUgF6cNFlYa+6r4W4Psez0WyUZ0bRiyakKM6FLUlzmBCqUanVyjBCPHY2tosLgQAzKdUjz2zl8kn+1JvIE1eoeRCOx84VOEksLy07OffAvZRSYIyeytHYaL5rOYQQRyNjt50U7gJOIBWy7aBJjU2V3fm7Y4kzUhJKNmVAJxHNWJaJaW0RiENXZdPLi0vryyJmdml0BSmfVl5KSW33bSdTiaj0eio5LK6vL66cer0mbPrGxtLK6tGdF4VUBRm09ype1dGiaK5GArX6xn/lCpSLldWmxur8WKNcr3MPw5Vb8JCxZDsq51CD1mv1/unkXPWzX3/usWw/lfzEtXHeo8c9ujGrN+HhB6zLa57rQI7/fPdDvr9Ly0vFdVs1jg5GVFynjVuQSm0ouKtFKbhXhvb8fTNNYXc2NwE4BmlwAsINJZLPplIMSKZmXgzZ6IXAdOTM4SIWAEpJRZN1ArEHty/k2gpuTn3i69SYIaGgNmJhWVbhm2mlE6ePLm6tnZyec3YTEsed1OtDAiYX9nQMXEg3cAJorVYesAQcFbGiIiqXM07xXx0b+LJrFurcyfYAgWt9WUuOIzR9qxX+gTT1rtPs114VD3MgkkD0Ys04FMCZkLq1czBauk2ueZ/DJBmQJq40vXWDyLBSikkaBJ1G34VhJiYKBSjyfgNrvsrMIW2sbFe74Fe5FKKptR0bc45S0pNSrlkL6IqJSf3aegVC3VjwpaQVHfV9/b2gb5s1Jff/0ZhHd27dSHwpErtabbok3HG0P6arTdfQBRqsldV/WWExfMNivhvzluJL+yfV19tdYBW+OTH162+xPqX13fr9/+JC94/4Y1tzcwq+m/dbOjcB0RLTc3rzNlbm4EOZiA4aE4wipQ8LgK9xA8WsQiryy9E0Vlq6UmX93SmEMDy8rIMmtJm+AeZeSfWhJ3ngIv5gFo/oa6wYGqJ0mmpmsunwBgpFNC4t78PwJzH3CWsP/M1+YoqzoCCPkKlkyZ5I69XxWiP6IOGqiwdEGmSWz1j1TScAZcGRbTTRHoghNUVG2f7PW/j8Ih6YbjtlUfnuAygumyVz3yuUHZeR9bnPhbloReMmTRXLDkcRSuw2PxYCavdA5gHad1uDgZpYTh0fiAnP6J5T0XjJ0NhpgWEmol4tyeMlpj+QlP4pfYV+ko3zWBlebk/Bk6fP5TEYlbqzPRZwisBszYSXyntjQPA4NzBvfv3Z/qspq76Dz2mDOrF1EmnXv6sfUre4o+72oFceBmnN3Za/bVvJ2bfIsA2V3/uS7vVrAwv7mA7Q0z/Ef17uC9YSqnV7dV7Qv1jXjanM7VT787xqOMe2LGHzT8we+EjW8d556teQqji0KBWIwpLTSNNKlTUMru6huY1pSSTNETjLkqP7nq79uNXOH/lcuyCj9/AGzxb0tr6mo/tTj41ABgOm5JzLl3bTS3eQUvJfkPqs6zrB7nb7p3BsChTHx8depWLalbL86t2zDwG/utHXLVk73M0MwWLqVrxvlerfzx+UytmtJhYU50mA8yU0Mq+5J6f13ZbrZ1WqzIGFJj/0dnCqJqWGCcVT69cQP1dzOQ3sAyY60jMnhKHpA8Ijp2uOft57JjNDhGqbZ8zfFWuQq7Jw4ODj330j+7cvPXxj36UhKQ09FkoZmrFUwZeONMAKIXBVeZumvteQkrTHBObeWnpHdMvqcW+PkByc/OUKgOTEwGZmsaZxJ02XWPCZxxN3yqNnpNg8zGDFq0HyA4PDrouR5eV2vXr2+rlsHUde6BPq2ulvqGhYyoZklVCoFA5EZJBEaPhTKtuUYsGAR+JqZGItZq20JCq+Q8NkTOYegeEWf+Jld8APgAziDT6ba+RnSF+az1a1KuhcH3m1RmOR6Y258RYdBrO4QdzeZu4lvhpkI/c3Lnxu7/94VNnTr/jlVe8gq8ZNCSVlmPEoiEyUwUsZhmIs1on3nlZVHqiiNTz/+UBpAA2NjZTEgtH2AAMh4PUNOqhqKPsZq5XSsm5GC27lAGsrDhWlbJSMJ6MR6PxwsKKaplMpr//+7/3gQ984NKlS9XExIDalJKaUcLfCpoLUsw/OKzB3N/+RkAXC+KYb2BW/ZUYv133rNcHgFVPrP+NGcCZtFXrCJjSWN1n9fpQ1GXh3H/eJmvHLvIRhUTSgmVcEM4he3kyHNspkq+++oXnn3s+fHCfximcjEbXb+zcvXHr4cOHzz/3ljRIBltYXJQum6kTTZi5mqIZJLG2GSdqhhOrUryjxOvVTLmwuPjodR+XFny5phDA5uaWzhwLuPwOB847X9lR3KOpgOLMeGlxGxbl6ha/yjkfHR365QF24uSJ27duBUU2SKdJdMJcQX+RzlZgZjZzeV0Y5pNxVSuGSfG+xoCvzNxPpKn/gSl6NgaYB+PiyIJ3kIZvidllhOMcqpFWBTz8s6j3ICObKNXZegNhelTCLNyy+NxqEh2dqjqaBP704x//3d/5ndHhEcDPf/Yzv/orv/LJT37y3/xfv/0Pf+6//8wnPjkYDBeHw1/7579s8+47YnHNIBCaZxQ8h24xLk8SRXp/un/Z0tLSm2sKCWBj41Ql9qjJAXpNaPYbVzNVanGhAcmsauIsFwAGNGdsd75nb1zWhw8fAJiMx3t7D8+c3rpz505wWoSkWCX2kGoSS7BlON9R9UsM6r2VYSFhPi/RG03iF9V81dAblRCwT/VXMY29s4gmo2PoETmoT/MbriLAMEGgwNtBGNRMcVX9q8Lxmlex/cvDiHrKLjaXpBG7+w9f+9xnP/FvP3Z4eDg6Orq1vf0rv/RLV1/7wi//s3/2nve+9x3vfOcff+Qj/8Ff/+sf/O7veu/XfcNbXnxRq0AibhhWtGSfSuP7WEAT0hlcnQjWnT9HIr1xwYilk8tvpilktFSsuy+jlKBpiB551M45gxhKMEkAKpS25FIKDESpsCiBAkDJJqW9gwNVTKbT8dFocXHh5s076E2GFiVce3guzkKC1KzABP12V5Bzbuer2HjLNeLcc5aoqdFQfB+vqnvoL0fvQM0keCZerOFA/xaRdHQe+xCeiParsZi7RFbF0wtaMxiUaZtLSSml1JB8+PDh/Xt3t06fXl5d/X9+53f+6I8+ura2fu7C+Xt3b3/iz/7srW9/8cKVKz/wIz/ypx/747XV1eff8tZiBarmYEmAwjY/gspMd3cf7u3vw8vhk1gF3yIDKvBRGAUe0Hj7J0xtZXkJjz0eMYVfBkDqrzl16pQfdDGYjzkAEznNao3rQFFVMXqg53UQNAioM5c46Dd6W7K3v29mk/G4lLy5uXF4OO11bG1nVQW9qYaz3i+tR3rmA9fECwBnegO8iZ5EHe9d765P8rgMsh4Ol634AqCi6fNuTbxD/Sj0AlVN7Cw0q8/tGx9YX1G/IyC8cfX1T3/qUzdv3bp969bWmTPf94M/8JlPf/r3P/zh3b29ldWVJqWd6zf+5t/5O7/9r37rJ3/6pxZPLkH5h3/we3/+7z7lkho0LGZEUEpNp9OD/f07t2/9yR9/7NkXnmeSldVVzz5p1j/8gw875uOdeaxD8DwZr0CpfqZfdgCKxMmTJ59kvnt3/MvLFQJYW1sz917h0RkAkwbaImiggErTDS2gSdHWtBRnmlTtLAOED4LWAphQdu/fByyXzoD1jbNXnn3rrFWa6jfYjwBRpZmWUuDTzvHoTYYbz5CH8FF7392q1wcwYP3eaenvlBWGmp3C449eOHrh69kBvILMjMFm695hklS67CVBmSYmKaXcdjDThh/7w498+Dd+65s/+G1/5aWXtk5vnVxaytP8T/+Xf/If/8D3v/SOd0K4c337H/7cz0+mYzpbU2/8I+PtbxyWUsBXvuZrfuvX/+XG+sbZCxfe+fIr73j5FZBve/Glts1W7MHdm7/5m7+Rknij2nz3GAnVEio97oxksmiYs5WVlS8iNvxyc4X+q5WV1SQDzRlw+lev5RmUMs45p0FS00Saee14sPmAoHMrmhZVgZgqoxeapOzv7Vuwepor/7pjvV/uXAyiatVBnDnAbgzdi3Zr7AB773AWbziurZnzgkEyehzI3g0Jh7uP4t9g/fye+njZ3HHETCYBQLV84Qufv7mzc/vWze3t7X//m7/l3e9/X1b9+Ec+evXqqzdu3Dg6OMxd/t4f/qFP/+knnnn22a//y/+eZi81sJxzKfnU1mmFWulV6Uwfzz+c2WZ5bfUdL7+r0Iry27/zu//qdzF8TJ/b6lXbWXcf3P1Hv/DfteOJ1UnjrAIhGmBKFduqiZ25jDS11ZUv1vv1NKYQwOLiiaUTg4d700YiFW0wE5bcDQeNKLMP+tMCMy3Zj71qb7wg5rTBfdgGAvfu3Z+Op1YMVDPn4KLHwY0Jwtdmj+DXMK+QDQReTKjqZCMIH2YmRa7J6Y5ompMY9RVn9aerPKEXD7V6jvsCvh5S96fP2cdqTA2g8Ma11//nX/zFt771rVeeufKe977vg3/1O9bWVgvln/6Tf5zb9gPf8i3nzl44ub7ysz/9M7dv3ixkQvTDz/bJxV0S1Q4f7jWDQRJx2MR9pvPnL60urz3zludf/pqvUdXnnn/Ls8+9RYuYWQai/tBgKFq0nU4P9x584hMf/41f+z93Hz6M8tGiIgRJBSkqxSrXhpfAV/AlCxvX/iura2+mKfTHYLhw4uTJB7sHTmLhQV8N3ZBzCR+wohFaStSJH5PUaMZRNxep7O096LquFHUvKgQIoNBfqXiE38QsIC7/bhZgzfYe9YdyLO927N/zHpKLWvUqHn/JLD/4Bg8++p3x9//v393a2vqPfuAHnAvh4YP7n/rUJ89fuvLg1p2v+6a//Mzzz5qlUkpkSEJF0zvSDo+OhDJomt/61X9RaLsPd08unvj+H/qRpZX17/sbP9wMhgAK8czzz3lSAYE8O8pcTLXL3dHB7p07d65fv3p95/Vb16/fvnV77+F+Lq2XUkfUKjQ4Ebabr2hpxMwysv5D3SFZXvpijNxPaQqTyPLqmm3ftN7+kIMmmWkpKgIn9lAEZwYrMKFqolYMhkIvaY/MiMG4t7efS1GYSKOqxdQUQrCaO5n5QrOdjtSjiYfP4TXNO8WzPZ+/r1A3jKpi8eAimhdDzc088BpEg9XgVrdm9rZz4VT9FFo2ZUpm6CaTf/yL/xNNd65f/9Df+CELFrVGzcRiUOXiwsK1q6/+xv/xz2/cvPHg7r1BM/jQD/3w3/67P3H77u2tra2NjY2mabzS7i1vf3ugs1G9lFSLIU9H47t3b1/fvnZ9++rO9es3dnZ2d3e7nOkncAbK+xiGerVk7QsWAIxuzSh3doed0WUFsmmGsrH+JhGvzX8FsLGx6X0GqW50KVHJ4M9xLDF87vArAYa/TyOQKiWV61ru7u365E+KjEZHTZNOnDjpwcocWD7vXEckeEyCeg8nUIFYyLDXvaKeVY/4hYEI4ga1WdCN6FaYhZCVSII97oCq246d4D70q5fXNMMf/1t/a9gMfvon/0snjri5s/Opf/eJWzdvbV+7Ctq73v3ur3n/137iT/5k0Ay+9hv/0qnTW8PhsMuqqmsbG2YoZtoFQqumqrmdTnYfPLixs7P9+qs3bt54/frrd2/dztPW77vq8UgtCFn9z/A+UU+HFybFWagufE9/GjsPhfdpG06cOLGysvrmm0KDnTl7Puc2SePDIKSurNMNBAWoWvGuedOiCivmBZr0vLR6/wo1El6TydF0MqWkUvJH/vD3/uWv/6sf+/H/7P1f+z4y0JRHdpHGcPCqM1v7w+NT5izWFzNgVQx6iMH8BT580v2d/u28jhk2B4WBiBKxinaYoc5KBa2dTrtucv/hwzs3b1199dVmYeHKM5e/7Tu+8+Mf/7evfeG18+fPv+1bP3j+0gVfjPd97dcjXGabThxwgYKElW66u3v/9s2b269fu3nz+vWdm3du3jg8OqhDQ/1i/ULncDKC3qVhBqLaOD9C8M0CWKvLfAWPTSBHaDKW4lCcra6unVg8+eabQhg31k+ZsRQHS0TFmRGtlE4k+dgWVwbeexhhl8HzY6AYoaoJUgKDQu7a0Xi0tnpyMjr86Ef+0Kz8/M/97P/wC79wanMzuGHQh2muMGIVCTAwp3j0ZS2cPR94bCGqV9+bg74KlECt86yaEfWgz7tu1ZT6WvVL2v+SL7/nPb/5a7/+3/70z5w+vXX+woUrzz77rX/trw1S8/Z3vfPFl1/WIB9XLZYRkEocFtPJ6Oj2revXrl19/frrO9vbd27c2t/fNTB3nTMSVIqQ5N3jQqnJUOmBEsDnIRoJiVa5uG/xTk+FCIEUJba1gCBEzMyZK9QpFwGQ586d60cSPS48X5EpPL21paWIs8paqR6ek0f0bBbmDdoGNillL3MSNmAxC1KmSNOiwNTs4GB/deXEeHx08/ad/b3Drsu/9Eu//J/+2I+ZGaXGggbp8c2K9LP2YNVNn0EGDHOQ+qJy9kjWLHAPzz8MHEOWQkhcOKP04Jhf1QtRtchV3fmuqL77Pe973/u/AUDR4hlSenW891pb+DJaSjud3L/j7tG1nZ3tne3r9+7fLp2KJF8pj4SsJyeogK2vvCfmSc+BS4X/mSRF9SxdaMKXqj4AU3KCd89KRJViOFZmzghnpr25JHD+/PnH5eQR2cLTmEKzzc1NrR8T9cJmjTCXYMrxYu9Kc4W+LQxAZyVmd/jIScC1TyPN/v7+pYvn2rbNbZdLpvB3fvtf/+iP/rgnG5zE1IXA3GFw+XC934eEZE1Kh7DVrzL37xmG5ZnhSjHL6hi5eQyb4iagtw4zDYX6dmE2e6emDyMwdaZ1104GOM9bnty7d+/Wzvbrr7++c/3azs7Onbt3xkejRhIhpfjlpOQ9PxY1Z4TP/kY9aXwc8uhvOGx4Fb3+OTMJ80J4CtQkMercSevfsxem2vEgJMjz58/Hqj/h8bSmENzc3BQRgyZJUutFmya1XWmsv6teqF2dxilpElSLikAhiUWL76QY93b3oDocLNJIHRjw7d/6l0qeNLIQs99719mlogqTVSe5Lm6c19nPavmDARLJXNa8ogeJc88M1ROyS1aEMGKAKkpV8fVtFKoGJDPUOi7npzARGR8cbF977dq1qzdubO9c37556+b+/kFSAd1ThAgTU8QMoKfDaxhh804PCTMvRzDhTIAe2dxjMjTnm9psIpCESyHJLxIxd7LefwUaVBUx5dOKlcuXL7+hPL0JpnB1bV2aRkthSK6YGUTUOkbpks3sS71zx6Wdts3HvZlpoqgajZZkb28vDRaWVtaWVlcPj+6q2e6D+3u7u6fPngtfOdpq+gurdTnuXgY0QURde2wSEJUnwfptIVe9JwIYUFlgonWGVtHVGoACtR/aGPikza6j6irrTLUdj27e3NnevnZ9+9qNnevb2zsPHzxwFsnilEkyUwPu+pupdx2bZhDOXhHlFKj5Tqfbo1Eo5Dw+7qC/mkldcD/G/sfpK3zGlgeM0jTmxSZ0EEv8paCKJEMRJADO6+d4kVsXafjCsy88LiePyBaeyhTixIkTCwsLk/EYc46LpJhtJ1XlVghkNlcN3lzrBRgATeDEawoIDw8Om2awvLL8zLNXHtzfb9v2d//fP33H+z7xwW87Fy+vb3z8inr9gWOqJ/53rDXHj371zsOVcoSk126G2ZrZsf8zTL3OllVE2unkzu1br1999cbOjZs3tm/cuHH3zr2uGwsTyS4XmJh5u6XOmBfN6Z3iWLo0EEJ6CSrNhJVtW0RgdCzPzSMN/fwO94R81cXilLncVNMtYUbdHXa2TElejCgkgpdeLDgE2WdIJUg9xZ2cxRMLly9dAfBFxOapTaEtLZ1cXDwxnUwDGiESZZCE8LnDNWRzXGTu5cm9+IbQzGIS9TaStZhhd/ehSNrY2Pr6b/jGT33yz7uOZrK8tCxM6CNCzIJ8kn2PXhUm4jjS0COhDJ+2piBpMIlMeu8QB9gF9n02IZtmoJk1AlIe3r/76quf23792o2d6zd2rt+9e3c6mfg487btRMSMQKPeU2zBnmIARJI3kBt9RIpDZYmOz/oPXErcjWxI9CnR0NYe90EINJFRCBLadGx356Std8wcbkj94YzsvJol8bWMOhu3BVTG9qk5QHH2zLnV1Tfm8nsTTKFI2jx1avfhQ2/kmHNuaGYSId/cLHj2nRQQ74dOqdYWuMlRgx0cHABYWl5+5ZVX3v72t37+C6/t7h2+9NKLIpF7P+6EHsNaqiYzzLtXx7VXwKTe0dU7ZnFnZlWwEBlJt1Z6dLD/+rVr166+dvPmzVvb269vb49HoxMnF8DUdZ1qIcXUC05K9VR8pmFTsjIlX7koOalOt5eyUeiwWw/YJhH3aUAIPNCenXYySodN0VMAV1QzEAjMeVfVMFkQV5M9g0jshSrJ5FNsYiGMDDoj0pEjNTSmRVFeeOGFfhrIF5EtPJUpVICnTm289gVHZP3AmYhQVAmYigkDJTSNo0NDUlUhWLxin2Zi6sGOKfL9+/cgbNt2ZXX9Q9/7/f/of/yH73zXK+fPnQ7vdQZF9rLi7pT1dlKs8vTPOVnuzJupGkyMPuXDAK8Jg8JQIjjn6PDo+va1169eu3F9++aN63fu3L7/4EFKidIgF+djljSYtoXsnMWJZN9Epy7XgeGpJKlXquK+ORVAcoZxiBlStLcTkYSApORtcZVxLoVIqRP+OmDsjKw+kTrAAQBS6Uj6Q1hgDZswgEKhae2WhiGJFMsVhJ7JighohgQtShgYY83f/ra392/+pMdTm0Ig2EECbvBH4GdmYj4BxRVY6UW4PxO9Z2ahQ4IO42D/sBTNtMGwuXjx8n/xEz+5vLzpamAW29dL73M2EpO5eiqfmUqbJQ0Bg2VV1HJbwAZNgtn1nZ3PffZzN66/duf27RvXb9y7f8/MnI2iK51fp2pWFHrvASliIs5GLM6jXk8OEihkzFqmzzomnC2OQjNK43liHyZmVYv1p6Uup8FMUpo3CRIzquvy1oWvOJPfuHetWJ31ggbucbiXYgCTEJTQ2BZEJq7/KhmzAUqJuR79NZL2tre97Uny9JWbQgLYOnXata9VEolGUvLxkyKqKqlS8kXYpI5CqSlrPO5cHSjq0NPR4eH117cvXDgLw2CQVtdWUyPBukAAJtGQ4I46vYgVsIgHpc7R9nR0HzqYGphzGTa6v7d37erV177w+bu3blx9ffvmzo2c84nFE8XyeDLJXfFRmjmXevLCziSmqL8CYFbUJ5p5RuNJAAAgAElEQVTMZtyjmmGr3jTMiXgA0Nj0PjGi6Nf9iN5agcQg6mS8nDuatGsFUFio5EshjZq59ymSYALxOIkpWQgDBbCY2sAilszMR31YRMLeLy4a/CsUaZxbxpv3w7cgzMAkJ4YLb3vr2x8XksdlC08XFQK2tXUKPaWxQyuuN9RE6GPWK34buUwXpKAM7wuLDeZoBTkYpP/67/1Xa+trZ8+cOXv2zPkLFy9dvnj58pUzZ88uLi669LhHISKElz4PZ80SpVZ5ASCbJN10euPGzquvvnrz+vbnP/eZO3du7+3uDZrGKLloV+c+HE2OrCiFg0HynXav1p2uFJ6Km1tPEkbxtyfaeu+mkXnvuQ9f/XKiOQdUoZGNqtaUSw3WqpY1QJpkFjQvUt12IxIIHz0EHYhYGIwwBsCcoPsR83mdIj4eDEZP0jiAp+rz0lQC/nCJcadttnFkEqpqvnzlha1TW+jP9hMeT2kK/cuZ06cdsaxLgbocJtL0XQuYSbcPA6hl7nOk9EAUv4tARI4ODq+Nj25cv/Znf/Zn/vyFheHa2sq5s+fPnjt3+dLl5154/uLFiydPnmzbbjhcyKYZNLHBYHB47/5nP/2Za1dfu3vn9uvb27du3vLxXWo2mUxgJsRUW5fF5Gz/AhKCgRGk+vxUPx4hyQhB80VzX09qKM/otCBF5ldvPrDw13ucpxFZWJI+h5nMipBkMqg4PSLEawlIivmMAgs3SZILFgMgdNezV3s1IcjQ5WTjO0RJbmJIKARmUoc0USSRJWrmwiYG3CCoUVd618svN+nY4XlceL6iqJDkqVNbqto0EoAQkchBSm3n1zRb3yZJLrVh2dQL0krR2rzs9Zvmg74Tk0F9NA2yN8SjnU7H46MH9+9/+tOfNrXcZQrXNtaee/75t77lLWvrG/t7B/fuPbh69er+/sFgMJSUDg8Pc2mTCJm6Lnss5u38WUuqKTOyLxOHASJRB+RNZmRyxzEcqd4jrsLikpOqnXL/u4YVyeOYVGO3kACKo1VmMU2EAFNTsTMmT1M4yb3HjCRoiQpKlXutLn8EB1a7ed33j6CXxpjCGh2s7CEro4ibFzELGvmqbPwNZzEjveebfP973+9gzVfFFPpj6/QZg8LEURp3L2KUbUMr9WPgXRQGwGc/ho6GCVN0tYJ1DjxTgAipl0th4xFfl7PPQExJROTo6PDTf/6p1z732aZZGJw4MR63pRSRGN1DcjBoXJ+QRD+pTGTgA+tr0GSxGd5tXIFwADUZAoCJUiecwVyZMMSCYTIqbsS6edKE1IatMrfi1TuW5AzL8Agwwn4KgEbEzBpp4GgVWQI594iIKSXC6uyfHtMJY5ogaiqEsmpH1ujBkTwrTQrF5pHmoBmoqg9XrDFSxOBWW6Ga4eAdL72TM/l74uMpTaE/NjY2+2hFVd0QNE2yaXF6IjNnINSUGrXOTBuyAJ2RHJBZ1fmWhKZRReOqiyBTtZEGMWdwVKOaUoQeI9Cd6DIdHS2SKTV9Bt7nh0PMR29WG+WLbBSJSMpVbXL+rYplRFlTX4xLRhpEIGJVOwNIAlNNbNRZmVycvZ1CRYSNSLHqadXFqoCckJKS1sNTHSWXElKY4OlCPxVwVHMuRPQRva5o+wjR/FbiiYIgTPRWYY0CDYjEUBn1OcL+8LhSlH1HwrygEIuLC0tv1E74htKCpzaFCwsnVlfXRocj82bq0MaN6sQTnOaOpySrQ9CLixKt+IwaNxkWCsqr1SAJlgE4Ji4pqVqMmJnzW0g00khK3hlft6b+zqOvni4bJQZ0VZCn9vSqp9vCowE9wo8F6jfbzaEkGCQak0JJSNMY0bAhIjXkukkG1RxI6stA+mNJBkoT/55bVteREdGI9JCKO2nAnJiaOSbll4o+QnJsDwYwMYliiuDBc+6ufgiKzeWnARhMC2qXPXqL1l9k27aHBwdrK2uPC8njsoWnNoUkV1dXjg5GDHuuJvTJVAZGm7QTawtTkpxzBNtKuEU3TUajKNSzx5V80gsQqnDEfQlTbRVzq18rE7xXTBJrgE0Ei7xEuC7J0VpEO78rRVGDJDjvt1oUsvXGMc1wBEaUBBNJtTDQYgQagR7C9tywOboWq5qqPUX9idA9n6i4CFUau+uuXRLvZEPxd5gr0JszQ37bM8EwQtSdevcl1JAwMPF8FCs4UgLoiuFQIiyaIyJBIr1X1K02zMJrHI/GD3f3Ll64dOwaniAbcFPYq68vYgoff/HGxsbtG3eAcPvgtR9QmtLH/FV6jf50uqZOIrkUEmbFT2MlXzCLkkUjIZKKdsLkQAyOn3tQPUdZUFl1hIRErWPoud5lnnnfJE2VZDQz0Zyexzlt6i7FB7l+qv+uNQUihkISabY4vUOWUopI/rgozDBAQJyk3IR9lne2/lIbUEJJzxllmStKA+e8lPgOnikygtIkKworQnHXAn5iDAJTqotw5f9KPrgzMNOaFHf/01Ph+3v7nnObf7yhbPijecTMfRFT+Mhja+u84s9Z6zkFbIRKZCsDJB+zngS5ZNe6WopPzYwNDruh9L8wmJIG87Y/mJWGqdYaWL/KTUoOEQiTQVMiUwiEkDFDOrmB9e0UsDObo3RKDX1ys6iwMYMENlbDQyaHs+FxXI/yABAv+vOhxTOVZlpqu7WRSEygVaxcCWH43o4SQ+jXb1GLHg5+LahxJz1YhHxWamGw5JBMMUk3at1oponJu01D5tREGhhLUCbRXT+opaBjCIxKlUD2M2JkZ50JfSBFmBDa4dG4ner+0d7jUeGTzOJTmkIz21hfJ8UDQ1aLAKDk0ohJEmeoExmUkt0Bn2fRUW9YiHqXmvM0S6LsR4FFO4bH5ibSAFCaEcMEQxFKTbN4dncGV4Zygv9zQEnVyvl1UkQkSTQQ1YYI0uVGZuF3TVRKvXyrDj4BUDywSg6FR/LJwzeXRIokGCiiQRWkjSSLDrCZKPiy9GW3pAAFdIxWYiK7hKltPN8Ry+5WNZOUOl0boZ6TaologsmDb63BChmeqIRyhJp6V2O1GyKCtm339/dAOzw8rBf5F8vMU5pCAFunTwmtr6snw1OBasBrXnDtHqOZwT2mBCsGGhsxC8IQY4wf12JoDCJJYUnpaoAiCR4JiYNhCbU7KNFpghwJD25pr8ULQ2MmMgBAL9CL9oFwwhx0DjQ7gj6vAK6stqFaZxatkca5TfxMJ0meyyFrkasG3Y+F61YPORXopcR99Cg4RsWrMIPRFUjCRIAUY39UCh1G8T4J92pJogGQxPtVjIS3QQ9SygUCUpKZGYpL51xVmRJEgKUecFlvqUrJ9+49ME3GMjo6qrHEMQl5Y8F6alO4sbFp9bYc5pGURESLp+V9qoD1GTYXvuAnZj96hqQYtaDANUdKpt45CqKZuWhAAiRApWRmTIm98y4JoKSkpZDJPf+URI1JemCTAJgEbkG8xD1s2UzJ+ZVGr8/Mt/bhp05YCo+5YFE+5/ciPUeZRIIupeSJCf+JFziIJFVP8Pn9O5kgENbNA+DUx4vuq/mykGgcsEgeP/plW7yS3jHY15yRQi19Qx58oVSVHFCcyiHQ0yhP00IgpaQoZhiPD+/du6+V5m00HvMxIXnzTeH65qZW8xf4gaFpBm2J1vtSSkrSqRJIlBJEBL5hCVZ8SbQYIQKUwFCNYmQi6biVgWYaDXB0zm26x1TUJBD1kI/UNOadceEae9ay11VSTCVwieSiXqWJVScRiPBSWGuUQ1s42Kg1zASAmLgxRwBAItSARRNGpHONXqkRjqB40457dpaYVNX7yKs5DoMqIqHSKgOFOdEkZyU3ZIwKcctuFTJI0nj/+TzOpxpVJyHoZl6nldJArKjqtBs/3H14dHSEsOhqpkdHR/ZICPXkx9ObwlObp9ALcE1Cez2Za7KUEuBluKXSL3pc4uvMgOBFTL3AQSulaMzhqh2FFpOahAp4JrLWezGllKSJT2dk9kjAi7jDbaLBPDdYrVsgpxVnR33tMSzHI6mQWt89ipFBiwrAUfb6ob3aZw9MVMOhValYrQhGzW0bZjRdFa6bxQUeKFR8NbyvsCPBzhrk0OhNqgH0sVbV3eMs1tZSfIQ2SEmJEIFm1fF0Mjo6Ojza390/HB8dDgaDxRNLIjRzBBij8egRGfiqmMLNzU0/VQ74CKHEsGmm0yx1Nov1LMVmKQ1UrZSJJNHcGen5TjNTKGjUxlgQcYxPbaWZoirF8DaspJSESGJaIOI4gMwwLt/I8DNARpQXQSgDo0LtDLaI0+dVjgGe961VmiAse2lTX5np8FVTpzG6J94fUczqYQh6FrrPEAOkwhK9ZMXjAwJIKVUrJlYKQaVVehzpeQkjuyeRUg516v2BXrPnlTOAQSWgFt9KleSVDjYeH41Gh5PJZDQa+8DHUvJ73/++D/3gD959ePS//6//2yc+/tGVkyfr4vPw4NCt7FfVFOrKytpwuFByVq+UhgiQXMJqkS76VCsJE0UWSaV0XprLYhCW4jIIJi0leVMvQnNUjeL4MgXhWbt+E0lJmoZikkKsZqiP37CESk6pgTmpKWZIPd3IyrxNcW1kZpHzEQmLKaI1ReNhaPaRyYALROmbj6MxYQbguRiZ19/VQ55SYqCqM3XiVQ2e6EqDgZklRjeixfhTb3iu2XsrcTuYDzK89UIipjUKWUoeT0aHh4ejo9HRaJxzV0pOkoRSG0GTwj70vR9Slre/5dKP/+0f+3v/+fbR7n0IqULaeDT6Ug3hV2IKFxYWl04u7R/suYpXK0LxcZ2oqjqJ+MhOALBMZPcsE5CtpJh5GXGzKVKyFBBfRTNJwkqUt3iWJkq8Q84k9VJ1TLBIVozbT4L/ykseWAss+/PW32OvkBhtEN53EbQ/KSXUvqueqqrPtwC1++f4+nMevfBZ6KpqSIwiM0eyEM6ERb61IgK98pNKrOLZBatdcX6TVgGcAMeQu9zu7u7u7++PRqPxeFJK68sFJElJZBAHwF+l5fTWqYeH7cmlcvNWt3X61Jmzpz93/84gDQwAbTIeu1ig3tpXxRQOBs3y8tL+wV5kcFNyjJTh1gBkroOwTKhKyWLQ5B4PmU3hWINzZYExLsR7e0ATBQZmSirZeKBn3iFIjwNSEnqzP3tTUrfBgFqhayLiIx8lJTVEAnLmIwN1ym7gNwEmuYciVpHBHqBXVxVap9B4EkSLu28gGFPqQl68WqHfFRHx2iZHVmvgG06Rl6aT1FIwk9p6V46KREeGmUDpGRtOJ9PR0eHe/t7R0ejo6KBr21q66LNIvQg3Id5U6ykopslgzXDYlfbCxef2dvdeffVqk3wzaabwSb5ffVNopGydPnXjxg4kTLsRSCwG0ifaG0hJMKUYKdI2ZrlAGOREAhQBjAkaDZvR0MUIA5rqOVpssWHG5QKG6fVgMzDSOQCTrLoPAFIKYrEmSpGolqNUp1aHoWIilpCiVbhHinpaimgeQRSaxsscV+yXiMcuIBSnu+0zEe7DauufE/B9D4TMEcGhj1pNLaXGzLToaHRweHBweHB4cLTfTrsoH6OYqeMd9ZFEWPsmaGqJBnHOP3FLcvfevZ3XXm0noxdffOfJxcMbO9uLJxb8ZlV1aWkZFRD5Cx9PbQpJ4tzZc5/i/wcr1XNGSkMz01JSk7ygQSQpUNRITQKVVJxgDZxQGhqJxkRjsr2PBfBenlkvF0mj1iqUsFNmaCQJRaTxauGIqEkHJvs6Nb9c70BwMjiJNF9TbybpXEDuEWFMEK+IPKpSjNosmNej5ZhjoM4sbmZerePNACmJFpXqcnkJIaIfszePZr0J9SERAOBzRxB183VL1cp0Otnf298/3B8dHU6n0whRCTEmEYhoUb8GMxj6AFbqWkACaxeDUcK/J9hNpp/7zGfe/corH/nYR+9c39nf3V9YWHSPjg1eetuL8MxElayviikEsLW1BTNJFSrs/SJxRlAFfLqpJqrVpCYAZSa5oMzx/vBVLRX8RSiGItGFkgBnGXBcyt0gHQwGkYGuUiW1WF1rnQwQ2MFsUPjc7fSKBIDnN7TOyXEViMpCZoYoKDUL7knzTRLVEh5+rfyqMkMAlUK9mjMLFdpfRvyUZurj26EewcSWldF4fHh4cHh4cHR0NBqNzcAgGBPWyTa9sTbrc4896NPfK6t8RQ+THxure900zR/8wR/8m3/94YuXLo/Ho4WFBXcgizItDL7xG7/xcSF5k02hP05tngbVfc3s4ZVIIwlGNYjEDRe1JMxFBZKZKZoKiypqfSxQDDAUEVLFHEdIfV9D473VBAwtbFgr/VJKAzpqyhT0RkaNstGZ3NBpb+EOcV/4N1PSDLSwoKY0Zj1nLsRkspnoAPAcHaF0CnugIaMhNdzuwDJS1aMAakGBzVfCeODspKyO0XTT9vDoaH//4Xg8Go/HXde5Tgr333vOSXqxnjSKmKoGKObyCoFdQEwUXjhXuTdJCKWEVbCi5q7JIA3T0uDh7p55NtLHUoDPP/vcSy+99KVLy9NHhQA2NzfNzDw6g8PHGA4kqzaSzAqjSxNGigz8nGRVSWLuKIgAhWTpzIjiIaVq09BQvAkTob0QwB/VLA9loRQMBgPOGvCN0mdkjUyqVqnhTTyaA+aIJHz759AmCOnvEP5+PyWaXuJXtSBrQruY1UJUAfomY+OsKRnztOE55ySpTn/xFQaJrmsPDvaPDg9HR4fj0bjNnSeLHIeRlDxYju7euF8/dQIWhGZKFDEvEgGVYIC3BjQVe/XIx8nyLOYHMXRzvaS4/kpBLWj0+z/0fcPBwiNC8tUyhZtbp0HPNgUODtBE6MwkEukUryDLUDUVZwODUq3WHEs2d1M4EBpUkKBeRRUqp5gOJNWEtNTNcysQGkW1iKRSenHpiQVp3qcKrf436pbbzGCRlMbLwnoX3Kpik1rFOr8sBAXid9yzwfaLw9ojGOBZaC/GABYto9E4gIDRqG0npEexDWCpGRbtKA3hGClYZ4B7wODNk/SpMyiNx0NxV40X+UTboJr351QFnMzTHy5vPaJhhuhu8wqmugKAQr/+/e/77u/8rjeUh6+KKdzY3CywQdT1gqDCBoNmPOkShqrWDJpSSqDAYXH6qCcyjBQOTaZaCEFRs+KF7pxtCkhvN0gGM1ORgRGWxAXLV2IeeA9b5gsH0FQoWr3+uhzBuFKFgLU5xEN4L4voVaaR0re1+Ir2Nq/KGWAq0pjBakk/a2pIYePx6ODg4OhwdDg6aqdTCyQDIFJq4iRE6bAmSYWJVqs4YE7H7hYxMtOREZf4KDpo48kcj3LcMBPePguYBhEGAIWSoppD1HqWQOdrMvUGuGdeeO6nfurvLyycOH5w/oLHV2QK11ZWF4aLpXUyuJp4EWgplpBSyl0x726IcYWSoSnFDXt4ZWSnhRQnXm6MJBUxR9u3FabwGiZX5qAIU1qAA+UpifRZ4RCpMI7OnZgGZuaJ/fnrN8v1BNew0dfYoAwf0bcZcAJZnzLqgaqATAInWKswR0xy8crsyXhyeHhwNDoaHR1O26maCcScg1uQrAZlIRYClFhoYfAygOplUT4yCQIaEVrHJKrbAX+e1dZwIOiZGN94n4iLjdX+HLJEbsjY9x15d4ZXhaf0tV/39X//p3/myuUrb2j+vlqm8OTS0qBpSqcx41SQwEFqgKj+aZqmlOKHG+ZZ/ZRzETFS1GgGtSJMBZrEYEpLgbRbsiA4TV6gDWvCwxCaYdD0I6hdMgQAhVqDzypqs+uXILNDkL1QrPIs9IbOHTKF9VG1L3dxmoPaBuK6s0KWACAi07YdjUaT8XgyGR2NRt20ZTifkY5ROO1n70ETdABPVEPbkY4wsDFYDDgkoCk1rsgJemIHRAMpzt1Q79sdWZvjJDOLfleQ3nOvlgP8dVx4PmMhAnBx6cRLL774Pd/zPd/+bR9s0uARGfiqm8LBYLC6ujoe3yWZSC+ZbqKNojiB3czRYQnTJz5xWD1JlTwhZKXkIgSsIxcZHBVR4WkGQNUKTRJSYgLTYGGxLoVUlN1g1jhPuBgpwcRmhWzCiRbWyN8bVgOP7eNz0nPaxxABuIz6czwT6pdldnh0dHh4OB6Njo6O1CyldO7CeWYbTXYXB0MzVY2ZgAr1YEI4AGDJSQoCuqDXmdUIpTpk0YFtyIGzexQXrV3eYBK8yICYBSnX8V1lrTP2tI8rdIbH5rAe2TTNlStX3v3Ku9/3/ve95z3vuXzpchNUCU8jIV+RKQSwsb5x6+YdiJc+ERaIcO8R+9NUg4UAUBGSA7OuWNEEFJ9jKpKakktRE0USJZyjDWq5wQAWRXMwS4Ikg0Gz8P+3d209cl1ZeX1r71NV7Vt32e3E8a3ttmN3d90dRgiegBeEhMQgRLjMjDTzMDwgfgESCMETEhIwI4HCAw8joXnjEg1ISDwiBtAoyiQZJ+OQYI8HTy6+dle1u6vOXouHtfbpHl86mXTbcZLeeUi7q+r0qXP22Wvtb33ftzIUHpD1JMagCoG1Irypkq803k7XYNIKbbJdfsa68xfPCxhbWGBPaFjp7vr60MbKivfAdiUHS1l+4Utf/Llf+oWg9ZdfefVvX3jhzq1bxqnjANJAJIEZYBiLywK4s5aJlEpSApnYAo42IQvXPFQpvE+sMc/Iy4aWshIIJTR67C43rDXdJNPsZdgeuiLG+dOnn3vuwmAw6HZ7R44c2UJEv3lW3P/zvRNrO6GQCM3mQXapSSIi5uBq1apgZ8LDTH0xuW1KLj8icS42B5Te4UXVjRth/ncWQyKzkKYkkQEgMMWAnKSXzAFq0yDvFDyAaMVIIUKA59NU7fCwyXCMNj0MNquYrUfN7du3h8PhcGV5sj6eiLifDNkDZQkyJ6H9M9M//bM/sz5cXpukc+dPP/+bv/7C1/6KGjU2k0cFCMFCHKNS6RBRyG5vhZ9ovua2J1abF94UNm8e8h4RGyBzUuWq/TmIBApjN5MBg4F1z9Ses2fOXrgwGFwY9Lq9ZrO59dpx/91/5KFQVZvNQ/nzCOAygyIVU5mI1OZc4FSqOh/YxVvEStBCi5QmrEFSgvclTAxK6rsbISrdX0AnSYkDFzUgxBCzbsyhTMMtM/0OCKziTRfEd3CkvhmFJCFAKZmPlaRJjBGgclKuro6Go9XhcHR3dVVSsqlgqXRwm+FIajp3y3xFRPbt2//u9VsnTjavvnXlzJlTU1NFKALlDYfHbKWMvUlVKLRaqGaCqFTPpKGwZA+Ca3l4AyWjZH1icmAJYABRspVo0MDMCNPT04tL5wcXBv1e7/zCwvSP2z3eE152ZGw3FM7MzIhqwTwRa3Rn91cIyehp6s6MKqTJjXg4QBWUTIhCiQElDhS0DJOUaknEnI5VQ2CrPRvBBjDML9ZqdSKUVBrHj4DgvSFJndBClD0RKsCmQqyIKCWTEygzI01WV1dXR6vD4Wi0OirLknzfxyAh5C06hM02gSmpcnA8TUGaNDJPTdU4UDmh8wtnAxdXr/6wUa9bDw4FTAAK92Ejoo2UuXrsNYPyG6t+Fljff++hWoRQZvfHCqOLMRJhdvZwt9t5btC/cGFwev50o9GoPr71HNoccO5/5+MJhdQ8NCtAUu8ZFW1/F4IolbbeayLTsAsVwESSzTUGJyQA0AgoIQLAVIHx+kQQC1KRyIEoqJTEgAgRCzNTSSkVoWaFV/PKyLxMI1gEFa/qZrMP/591SVYR1bS6tjoarY6Gy6PRaDwu7XFPJMzEUDBncjybwo+IwIHUGDiVxzqZrAyxIMLaurz1xht3lp8+cfLUaOXd9bXx2tpavd4gzr6OxJL1EbCWMCB4Xz4PzvlVk8VGMX6iKhiJKHfXc0o3AdFtTkIswpEjT/V6vcFgMBgM5ubmNuDg+ybHw27oPW944DsfTyhskpl/AAbe2H/mXuJFBXZZvWb+bu48aU1gfBkxNIpRS6WEiJRgWSxxFEJ0VZIqYTyZcPD9YJXkWtcPQ/ocy8kAPYcgScr18XA4Gg5HyyvL6+vmOhGqXArOS4H9U5Q5OHMaZDVuy+I4kcaczAEAGaDIpHT18tv79/zi+eMn37r2o9/4/Of/7hvfqBYSWF0P7ixC6qupWlM532P6hU2kav2s823zPM6WLjX7SY0x1mq1M2fOdDrtwaDf6XSOHDlyz2Ta2QD34ce2d4XNZt6P+PdRkiLG8dhFckVEEhVX85HDdKQmxARpNhkHSQCBonBgcR8f1mRYKlk6Zh8Yra2rJlIAUwTJfD7kp0fBVCvq6+vrd4bD1eGd2yura6PVSRoDHAMnLQkEsILYwUZYjGLTByooOLeCrWhtrkQkRC7A0sqgwU0cQKCpRuPrf/n1n/rc526Phv/0j//w9mtvTjUasmmPrKQsDpXnbh1QUoe24L70QQ02Nf0ccmZKADGjXq8vLS0OBoNut9tut2dmZjaIYtuLX/fc9+0caruh8NChWbsxxgoqVQqECB6rMLM75jMD1qzSu8qL29KTCU1NnwSXvTOpMNdUBUS1ogBsQ43AKEI069jrN26fOHFSROy2BA7GDxmOVkYrK8t3lu+s3JlMxhxqgclmdQxRgVITszn8BAtHzBAEyq0PiOC2ZlnMCvfchwHfBmfZWmX0c/YcngIX+/dPv/7GmzN7991JN2uNeq55Z+N4m8S+W6igfgf8Db2rqkFVjz4GHzx4cHFxYTDo9fv9paWlen3q/sd++/Hr/jd8bKFwenp68xdjgwFjTLKmqoGDEomKN+8kKskZC/5MgAlKZuOt1vs4ryWOIKgSqbgbMEQTaVC+dev63bt3mwcPTtXr65PJ2mh1OBqtjIZEGmDOsFoUhetl/duzA05meWYDgYBAwkZ6BqutK4b0ZAeHACqFIrMimaluVtwDxngBCRkuhUC0PFqxR4p8riQiMLHYdcpFyfz1Kn6sLxIMYsbTTx9ttVqdTqff7587d65er28Oc49iK7eDY5uhUPfu3VsrirJM6o83WUKiKk4nJmUwG44svUMAAAqnSURBVJHSoWUNVuXQjSdVRNWbvsB3QQYxi7V2EGYSt1zWUkoAw5U7KysruTgDIQ2BTRUlRCBhIBEq6SYCmxzUEx4jxFnfVES/tTAE3kpDgix6J0Jg67JrvsVOmGGCkNHzFNbrJsMElC0YPUoDiTT/bai5kKuXz9k7D4T5+dP9fr/X7XS6nWeeOVoUxYe8kTsSv3bwUNsNhSHE6enpGzduEAVxgywBk0oyXrmqk9wZnCQZ9iCSjN0AhiiZN5BIaSR2Yyerqnm3GSqtTkdOuciIACIOnqxDrcQfXAulqhACAotIBDvmHtQdpJTBDA6QBGSyCAspmAOrgCmQKY4om47blpNJTdvtZOL8CHB1rVAFemZRCWBVn+AqpVasfiAEPrD/wNLSUqfT6fV6nU5n3759D7ydD7w7D3v1UxAKiYimDxy4deMmicKUyrYQqBBUVDhEyxvMBRoOJFsJVCwFTqqE7GRvfhdqKKoaDdDuI0BgFvfXVFWGGvuL4R0EOBNF1SwbSpVaiMj+Gcigl9MwjFKFnISDxVwX4Hi/seQEUBV2tzebIGR1ZfUzh0oCw/vJef0b5pIlLj80gJZCDMeOHWu1W71ut9vtzs/P1+v1ey7sExvgPvzY7q4QQLPZvPz2ZevHyzAhc2Y5unJQLREhCknHlTFBCEjJUFCklKySbxwVqZYoElJxKwebNSHkDsBmNK2WXwfzAjEhj7myApEDTOWkFIMXdIkqqQ9ydySjW0JUDMcwgo2CHB7QijNB4uephAo58BBqwcNekpQoF3yKIi4sLHS73V6v1263Dx8+XMnUNhHzP/74tYOH2m4oJGt/Yjpv2+SAmEMApUkZawYUIe8ck/kTk+TzZvPAVatyCAmDmZDEqi6avASbmMHKxJxUQ/Q6dwCLKiGETKYCKFh+YwVpg3/IjAGd7ieqdqrYdG6Z3OJ8GCIvJ1q8sx+sh0nVgs4+7dfJpBquq6YQMHNottVu9Xu9Xq/XarUajcb9l25jX/FkxK8dPNS2QqGN6QPTtv7bUoGs/rZSaPDk2hjmBKvQKY3Xx5PJZGrf3jIlMJg4OblRkD3ubJGqQBoQJ1U3oGFW1UTKoXJi+bGvymCBnYkXYWH9mKuyhmV53ouFydYuVHkSVXClvdPU2qgCJ0EygZcBMMUYT5yYa7fbvV6/0+nMzc1Z6g3DGz5jY1uh0F6aOdhUEcprO0AxcBFjss2PWkplrkaBlM49e+5Xf/vXbr6/9tqliy9+85sH9u8x+7MCYYzSIPAAJmWGhBhdz0BEQKDcLc0QL+N/QjI+TRGc/ZySUozkGL86amFbNspWLAY/5s6pjlD6ombDVjcoAoTIiLxEoMBgoNFoLCws9Pu+LB06dOj+KsoWs+pJi187eKjthkJVnZ6ZoU3z0gACZrb8SUUYpCnFGEWkiHj+S79VNOLpuflnO2cP7tv711/7i6PPHFWCBER1uYgpnNRsPJPRA9mEZraU2V6As5LYQjAplSLgoEQkQWjCZMxMh8HIvEbM4lg2RBOsapUZ8pnnVeGUkgmkCuNrgIuimD10uNVa6vY6/X5vcXGxVqsRfcB9+jCvPgnxawcPtQOhsDlzaCKTiBoRAWb1BA6sZalakHm5Zk/p2YMHRfjZ+VMvfffV2aeOnDp1cnrm0Orq3T1795njDBEhohQEp4lQCGy0k0BUsYejE9grMCzv5uAsHSKKZKYxUJt2btiqudGp+xESEUEzbkCkWk7EZYOgWkCtVjt1as4QgXa7feLECWsSts3r9ukeOxAKm80mZdTYcQRzZaGUq2AebIgo1Kau37p9+erVUIT9jfrt4Z09jWI4HBrHqfpbtWhJDMg3cMgkE2sWT3kBIsrLtSqJ8duqqqXtzjaV6ogyyOSOWWSR2iZWJQyLMTSm6u2l9mAw6HY7rdZis3mwOuwHXpyHXc+HXcAnJ37t4KF2IBQemJ62zqZE3s8e2ThflcyVMFGKgUlpMpmM745u3Wo8dfjwxUuXrl7+AREj1JzVyZqVmZqzHCKVJAnkDcSs6IvsY2YlECKyrN87JGbbBzPV5Y00jXLLMbNp9OJxAIUQDh8+3G63e71ev98/f/58rVbb4upvfXG2DiUf/p2f6VC4f//+IhSSrFBIxnqqLKCsmyx7PzN689Klnx8N5e7+Ny9fe/6Xf+XVl166du3aibk5ciOZDVBHs7mKLVTItDhRZ/ylJGS8KHe4U8+/s38TXEKQHWPI/MUE5Praer1+au5kr9fr97vtdufE8ZMhhM350m68+8hjB0Lhnj17Zw7M3Lp5U0mVTPFdmJDNVq287igB65PJP3/rxS9/+Sv/8/1Lf7N8/cW//1Zzpkkuj6IqvkGcPEmU8dYq1voscfNAGJcwnxBMrglWEdFKHev0URAae/Z02ku9bt9oAs1ms9rH3X8RHngFNv9yNxQ+7FC4R8P5kYb+3u/+zmvffQVEytZtCSJ47/1btdpU5WjAIRBRWZbj8ZhU5ufPFIF/8MOrIRSacx1Phog8dmmFFWwom4mqqcIuBTf0vVqTVQ1IIEIMFGOcPTy7uLA4uNDvdXsLC+eLoth6H7c7tj92IBSq0oULg5dfeomtk6RCWQHEaAWZjceXiEJADIWkdO3/ftSYasSibtpiyjC0/WSTBHkPmNOpzemzaXkJ7nfjb2dwiKjVw/z8maXFVrvT6nQ6x48fj7GywtqdUo9jYPNS8dFCoapeufK/X/zC85qyaVwAEG8vD9fGFqqIYd1JHGBUlRAiI5IRNF0wIKLmEVz56LmJtf05thKeJVVW8xZlRoghgpuHDrZbrXar3Wq3zp07e+DA9ANP+yeKX7uh8OMNhaSqf/LHf/hv//ovRgcJgZmL9XFaHq4lSZs2buQGtcwAM4LAHZjIcyhC9q+S3NBMSSr1O2VENEZMTU2dPn260+ksLbVardbx48cfph3YHY9/bBRBP/KwI7z33jtf/epXbt+4CeQukuDhyt3xJKm6EjpA3OsiEKNQwMq9nE2kUMFOAgBK1pDc2vUiFvHI008tLCx0Ot2lpcUzZ87MzEzff/q7we5JGDsQCu1nEbl06fU/+oPff+edd2xqEXg8luHd9ckkSRICMwlzTUQ4KHMBJoBTEnYZjw9Rq+VwiIgxnjxxvNfrd7rdVmvx2LFjRVEYwLUJ6XpU8Ws3FH7MobAaN66//+d/9qff+c5/TcrSeAVra3J3vVxfL9VkCyJE8CYlZkhnQh3yrV+MYd++vfPz8yZBabfbs7OzdvDdSPcJGjsQCqvhmJHKlStXvv0f//7f//ntS9//XlnK2kRX765PSkkpkSMBZguvRIghxiJOTx9YWFjo9/ut1uLZs2dnZmboQYST3TD3SRk7Fgrv+T0RicjyndtvvP691y++fvHixZdfeW04WjV7FiiHGGZmDvT7/V6v2+12T506NTU1ZR/PZpA/wQnshsIn7VA7HAq3GGU5uXr16nvvvStJwOHo0aPHjh21gEi7S9GnbuxkKNwdu6MaldMrbf5h8z+3mHkPe8mTrQ965+ZfPvAcPvwJfOCnNv9y65N5RIfa4vzvv1wPO5NP0KEeXyjcHZ+psRsKd8cjGbuh8DEdaovzf3Li1w4eajcU7o5HMnZD4e54JGM3FD6mQ21x/k9O/NrBQ/0/YkkccJSG1LUAAAAASUVORK5CYII=" }, "Event": "nodeQueriesComplete", "TimeStamp": 1593368191, "NodeManufacturerName": "Linear (Nortek Security Control LLC)", "NodeProductName": "GD00Z-4 Garage Door Opener Remote Controller", "NodeBasicString": "Routing Slave", "NodeBasic": 4, "NodeGenericString": "Entry Control", "NodeGeneric": 64, "NodeSpecificString": "Secure Barrier AddOn", "NodeSpecific": 7, "NodeManufacturerID": "0x014f", "NodeProductType": "0x4744", "NodeProductID": "0x3530", "NodeBaudRate": 100000, "NodeVersion": 4, "NodeGroups": 1, "NodeName": "", "NodeLocation": "", "NodeDeviceTypeString": "Access Control Sensor", "NodeDeviceType": 3078, "NodeRole": 5, "NodeRoleString": "Always On Slave", "NodePlusType": 0, "NodePlusTypeString": "Z-Wave+ node", "Neighbors": [ 1, 2, 8, 9, 10, 11, 12, 14, 15, 16, 18, 19, 20, 21, 22, 23, 26, 27, 28, 29, 32, 33 ], "Neighbors": [ 1, 2, 8, 9, 10, 11, 12, 14, 15, 16, 18, 19, 20, 21, 22, 23, 26, 27, 28, 29, 32, 33 ]} +OpenZWave/1/node/6/instance/1/,{ "Instance": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/32/,{ "Instance": 1, "CommandClassId": 32, "CommandClass": "COMMAND_CLASS_BASIC", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/32/value/101187601/,{ "Label": "Basic", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_BASIC", "Index": 0, "Node": 6, "Genre": "Basic", "Help": "Basic status of the node", "ValueIDKey": 101187601, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/48/,{ "Instance": 1, "CommandClassId": 48, "CommandClass": "COMMAND_CLASS_SENSOR_BINARY", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/48/value/105644048/,{ "Label": "Sensor", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Bool", "Instance": 1, "CommandClass": "COMMAND_CLASS_SENSOR_BINARY", "Index": 0, "Node": 6, "Genre": "User", "Help": "Binary Sensor State", "ValueIDKey": 105644048, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/94/,{ "Instance": 1, "CommandClassId": 94, "CommandClass": "COMMAND_CLASS_ZWAVEPLUS_INFO", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/94/value/114786321/,{ "Label": "ZWave+ Version", "Value": 1, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_ZWAVEPLUS_INFO", "Index": 0, "Node": 6, "Genre": "System", "Help": "ZWave+ Version Supported on the Device", "ValueIDKey": 114786321, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/94/value/281475091496982/,{ "Label": "InstallerIcon", "Value": 3078, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -32768, "Max": 32767, "Type": "Short", "Instance": 1, "CommandClass": "COMMAND_CLASS_ZWAVEPLUS_INFO", "Index": 1, "Node": 6, "Genre": "System", "Help": "Icon File to use for the Installer Application", "ValueIDKey": 281475091496982, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/94/value/562950068207638/,{ "Label": "UserIcon", "Value": 3078, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -32768, "Max": 32767, "Type": "Short", "Instance": 1, "CommandClass": "COMMAND_CLASS_ZWAVEPLUS_INFO", "Index": 2, "Node": 6, "Genre": "System", "Help": "Icon File to use for the User Application", "ValueIDKey": 562950068207638, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/102/,{ "Instance": 1, "CommandClassId": 102, "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/102/value/281475083239444/,{ "Label": "Barrier State", "Value": { "List": [ { "Value": 0, "Label": "Closed" }, { "Value": 1, "Label": "Closing" }, { "Value": 2, "Label": "Stopped" }, { "Value": 3, "Label": "Opening" }, { "Value": 4, "Label": "Opened" }, { "Value": 5, "Label": "Unknown" } ], "Selected": "Closed", "Selected_id": 0 }, "Units": "", "ValueSet": true, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", "Index": 1, "Node": 6, "Genre": "User", "Help": "The Current State of the Barrier", "ValueIDKey": 281475083239444, "ReadOnly": false, "WriteOnly": false, "Event": "valueChanged", "TimeStamp": 1593634453} +OpenZWave/1/node/6/instance/1/commandclass/102/value/562950064144404/,{ "Label": "Supported Signals", "Value": { "List": [ { "Value": 0, "Label": "None" }, { "Value": 1, "Label": "Audible" }, { "Value": 2, "Label": "Visual" }, { "Value": 3, "Label": "Both" } ], "Selected": "Both", "Selected_id": 3 }, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", "Index": 2, "Node": 6, "Genre": "Config", "Help": "Supported Operations for the Barrier", "ValueIDKey": 562950064144404, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/102/value/844425040855056/,{ "Label": "Audible Notification", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Bool", "Instance": 1, "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", "Index": 3, "Node": 6, "Genre": "Config", "Help": "Enable Audible Notifications of Barrier State Change", "ValueIDKey": 844425040855056, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/102/value/1125900017565712/,{ "Label": "Visual Notification", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Bool", "Instance": 1, "CommandClass": "COMMAND_CLASS_BARRIER_OPERATOR", "Index": 4, "Node": 6, "Genre": "Config", "Help": "Enable Visual Notifications of Barrier State Change", "ValueIDKey": 1125900017565712, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/,{ "Instance": 1, "CommandClassId": 114, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "CommandClassVersion": 2, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/value/115114003/,{ "Label": "Loaded Config Revision", "Value": 2, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -2147483648, "Max": 2147483647, "Type": "Int", "Instance": 1, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "Index": 0, "Node": 6, "Genre": "System", "Help": "Revision of the Config file currently loaded", "ValueIDKey": 115114003, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/value/281475091824659/,{ "Label": "Config File Revision", "Value": 2, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -2147483648, "Max": 2147483647, "Type": "Int", "Instance": 1, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "Index": 1, "Node": 6, "Genre": "System", "Help": "Revision of the Config file on the File System", "ValueIDKey": 281475091824659, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/value/562950068535315/,{ "Label": "Latest Available Config File Revision", "Value": 2, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -2147483648, "Max": 2147483647, "Type": "Int", "Instance": 1, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "Index": 2, "Node": 6, "Genre": "System", "Help": "Latest Revision of the Config file available for download", "ValueIDKey": 562950068535315, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/value/844425045245975/,{ "Label": "Device ID", "Value": "", "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "String", "Instance": 1, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "Index": 3, "Node": 6, "Genre": "System", "Help": "Manufacturer Specific Device ID/Model", "ValueIDKey": 844425045245975, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/114/value/1125900021956631/,{ "Label": "Serial Number", "Value": "", "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "String", "Instance": 1, "CommandClass": "COMMAND_CLASS_MANUFACTURER_SPECIFIC", "Index": 4, "Node": 6, "Genre": "System", "Help": "Device Serial Number", "ValueIDKey": 1125900021956631, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/,{ "Instance": 1, "CommandClassId": 115, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/115130388/,{ "Label": "Powerlevel", "Value": { "List": [ { "Value": 0, "Label": "Normal" }, { "Value": 1, "Label": "-1dB" }, { "Value": 2, "Label": "-2dB" }, { "Value": 3, "Label": "-3dB" }, { "Value": 4, "Label": "-4dB" }, { "Value": 5, "Label": "-5dB" }, { "Value": 6, "Label": "-6dB" }, { "Value": 7, "Label": "-7dB" }, { "Value": 8, "Label": "-8dB" }, { "Value": 9, "Label": "-9dB" } ], "Selected": "Normal", "Selected_id": 0 }, "Units": "dB", "ValueSet": true, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 0, "Node": 6, "Genre": "System", "Help": "Output RF PowerLevel", "ValueIDKey": 115130388, "ReadOnly": false, "WriteOnly": false, "Event": "valueChanged", "TimeStamp": 1593368077} +OpenZWave/1/node/6/instance/1/commandclass/115/value/281475091841041/,{ "Label": "Timeout", "Value": 0, "Units": "seconds", "ValueSet": true, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 1, "Node": 6, "Genre": "System", "Help": "Timeout till the PowerLevel is reset to Normal", "ValueIDKey": 281475091841041, "ReadOnly": false, "WriteOnly": false, "Event": "valueChanged", "TimeStamp": 1593368077} +OpenZWave/1/node/6/instance/1/commandclass/115/value/562950068551704/,{ "Label": "Set Powerlevel", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Button", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 2, "Node": 6, "Genre": "System", "Help": "Apply the Output PowerLevel and Timeout Values", "ValueIDKey": 562950068551704, "ReadOnly": false, "WriteOnly": true, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/844425045262353/,{ "Label": "Test Node", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 3, "Node": 6, "Genre": "System", "Help": "Node to Perform a test against", "ValueIDKey": 844425045262353, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/1125900021973012/,{ "Label": "Test Powerlevel", "Value": { "List": [ { "Value": 0, "Label": "Normal" }, { "Value": 1, "Label": "-1dB" }, { "Value": 2, "Label": "-2dB" }, { "Value": 3, "Label": "-3dB" }, { "Value": 4, "Label": "-4dB" }, { "Value": 5, "Label": "-5dB" }, { "Value": 6, "Label": "-6dB" }, { "Value": 7, "Label": "-7dB" }, { "Value": 8, "Label": "-8dB" }, { "Value": 9, "Label": "-9dB" } ], "Selected": "Normal", "Selected_id": 0 }, "Units": "dB", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 4, "Node": 6, "Genre": "System", "Help": "PowerLevel to use for the Test", "ValueIDKey": 1125900021973012, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/1407374998683670/,{ "Label": "Frame Count", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -32768, "Max": 32767, "Type": "Short", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 5, "Node": 6, "Genre": "System", "Help": "How Many Messages to send to the Node for the Test", "ValueIDKey": 1407374998683670, "ReadOnly": false, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/1688849975394328/,{ "Label": "Test", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Button", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 6, "Node": 6, "Genre": "System", "Help": "Perform a PowerLevel Test against the a Node", "ValueIDKey": 1688849975394328, "ReadOnly": false, "WriteOnly": true, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/1970324952104984/,{ "Label": "Report", "Value": false, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Button", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 7, "Node": 6, "Genre": "System", "Help": "Get the results of the latest PowerLevel Test against a Node", "ValueIDKey": 1970324952104984, "ReadOnly": false, "WriteOnly": true, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/2251799928815636/,{ "Label": "Test Status", "Value": { "List": [ { "Value": 0, "Label": "Failed" }, { "Value": 1, "Label": "Success" }, { "Value": 2, "Label": "In Progress" } ], "Selected": "Failed", "Selected_id": 0 }, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 8, "Node": 6, "Genre": "System", "Help": "The Current Status of the last PowerNode Test Executed", "ValueIDKey": 2251799928815636, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/115/value/2533274905526294/,{ "Label": "Acked Frames", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": -32768, "Max": 32767, "Type": "Short", "Instance": 1, "CommandClass": "COMMAND_CLASS_POWERLEVEL", "Index": 9, "Node": 6, "Genre": "System", "Help": "Number of Messages successfully Acked by the Target Node", "ValueIDKey": 2533274905526294, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/134/,{ "Instance": 1, "CommandClassId": 134, "CommandClass": "COMMAND_CLASS_VERSION", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/134/value/115441687/,{ "Label": "Library Version", "Value": "3", "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "String", "Instance": 1, "CommandClass": "COMMAND_CLASS_VERSION", "Index": 0, "Node": 6, "Genre": "System", "Help": "Z-Wave Library Version", "ValueIDKey": 115441687, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/134/value/281475092152343/,{ "Label": "Protocol Version", "Value": "4.05", "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "String", "Instance": 1, "CommandClass": "COMMAND_CLASS_VERSION", "Index": 1, "Node": 6, "Genre": "System", "Help": "Z-Wave Protocol Version", "ValueIDKey": 281475092152343, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/134/value/562950068862999/,{ "Label": "Application Version", "Value": "2.01", "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "String", "Instance": 1, "CommandClass": "COMMAND_CLASS_VERSION", "Index": 2, "Node": 6, "Genre": "System", "Help": "Application Version", "ValueIDKey": 562950068862999, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/152/,{ "Instance": 1, "CommandClassId": 152, "CommandClass": "COMMAND_CLASS_SECURITY", "CommandClassVersion": 1, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/152/value/115736592/,{ "Label": "Secured", "Value": true, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "Bool", "Instance": 1, "CommandClass": "COMMAND_CLASS_SECURITY", "Index": 0, "Node": 6, "Genre": "System", "Help": "Is Communication with Device Encrypted", "ValueIDKey": 115736592, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/113/,{ "Instance": 1, "CommandClassId": 113, "CommandClass": "COMMAND_CLASS_NOTIFICATION", "CommandClassVersion": 4, "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/113/value/72057594144636945/,{ "Label": "Previous Event Cleared", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_NOTIFICATION", "Index": 256, "Node": 6, "Genre": "User", "Help": "Previous Event that was sent", "ValueIDKey": 72057594144636945, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/113/value/74590868935032849/,{ "Label": "Sensor ID", "Value": 0, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 255, "Type": "Byte", "Instance": 1, "CommandClass": "COMMAND_CLASS_NOTIFICATION", "Index": 265, "Node": 6, "Genre": "User", "Help": "The ID of the Sensor that triggered the alert", "ValueIDKey": 74590868935032849, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/113/value/1688849966972948/,{ "Label": "Access Control", "Value": { "List": [ { "Value": 0, "Label": "Clear" }, { "Value": 68, "Label": "Barrier Failed Operation" }, { "Value": 69, "Label": "Barrier Unattended Operation Disabled" }, { "Value": 70, "Label": "Barrier Malfunction" }, { "Value": 73, "Label": "Barrier Sensor Not Detected" }, { "Value": 74, "Label": "Barrier Battery Low" } ], "Selected": "Clear", "Selected_id": 0 }, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_NOTIFICATION", "Index": 6, "Node": 6, "Genre": "User", "Help": "Access Control Alerts", "ValueIDKey": 1688849966972948, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/instance/1/commandclass/113/value/1970324943683604/,{ "Label": "Home Security", "Value": { "List": [ { "Value": 0, "Label": "Clear" }, { "Value": 3, "Label": "Tampering - Cover Removed" } ], "Selected": "Clear", "Selected_id": 0 }, "Units": "", "ValueSet": false, "ValuePolled": false, "ChangeVerified": false, "Min": 0, "Max": 0, "Type": "List", "Instance": 1, "CommandClass": "COMMAND_CLASS_NOTIFICATION", "Index": 7, "Node": 6, "Genre": "User", "Help": "Home Security Alerts", "ValueIDKey": 1970324943683604, "ReadOnly": true, "WriteOnly": false, "Event": "valueAdded", "TimeStamp": 1593368054} +OpenZWave/1/node/6/association/1/,{ "Name": "Group 1", "Help": "", "MaxAssociations": 1, "Members": [ "1.0" ], "TimeStamp": 1593368054}