From b70cbfbad888b73c2c5bbc1ecb67e13a6ea0f248 Mon Sep 17 00:00:00 2001 From: Franziska Kunsmann Date: Tue, 14 Mar 2023 09:55:54 +0100 Subject: [PATCH] initial commit --- hosted.lua | 231 +++++++++ hosted.py | 1374 ++++++++++++++++++++++++++++++++++++++++++++++++++ node.json | 4 + node.lua | 38 ++ package.json | 20 + package.png | Bin 0 -> 2750 bytes service | 27 + testcard.png | Bin 0 -> 62884 bytes vera.ttf | Bin 0 -> 65932 bytes vera.txt | 47 ++ 10 files changed, 1741 insertions(+) create mode 100644 hosted.lua create mode 100644 hosted.py create mode 100644 node.json create mode 100644 node.lua create mode 100644 package.json create mode 100644 package.png create mode 100644 service create mode 100644 testcard.png create mode 100644 vera.ttf create mode 100644 vera.txt diff --git a/hosted.lua b/hosted.lua new file mode 100644 index 0000000..2bad686 --- /dev/null +++ b/hosted.lua @@ -0,0 +1,231 @@ +--[[ + + Part of info-beamer hosted. You can find the latest version + of this file at: + + https://github.com/info-beamer/package-sdk + + Copyright (c) 2014,2015,2016,2017 Florian Wesch + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +]]-- + +local resource_types = { + ["image"] = function(value) + local surface + local image = { + asset_name = value.asset_name, + filename = value.filename, + type = value.type, + } + + function image.ensure_loaded() + if not surface then + surface = resource.load_image(value.asset_name) + end + return surface + end + function image.load() + image.ensure_loaded() + local state = surface:state() + return state ~= "loading" + end + function image.get_surface() + return image.ensure_loaded() + end + function image.draw(...) + image.ensure_loaded():draw(...) + end + function image.unload() + if surface then + surface:dispose() + surface = nil + end + end + function image.get_config() + return image + end + return image + end; + ["video"] = function(value) + local surface + local video = { + asset_name = value.asset_name, + filename = value.filename, + type = value.type, + } + function video.ensure_loaded(opt) + if not surface then + surface = util.videoplayer(value.asset_name, opt) + end + return surface + end + function video.load(opt) + video.ensure_loaded(opt) + local state = surface:state() + return state ~= "loading" + end + function video.get_surface(opt) + return video.ensure_loaded(opt) + end + function video.draw(...) + video.ensure_loaded():draw(...) + end + function video.unload() + if surface then + surface:dispose() + surface = nil + end + end + function video.get_config() + return video + end + return video + end; + ["child"] = function(value) + local surface + local child = { + asset_name = value.asset_name, + filename = value.filename, + type = value.type, + } + function child.ensure_loaded() + if surface then + surface:dispose() + end + surface = resource.render_child(value.asset_name) + return surface + end + function child.load() + return true + end + function child.get_surface() + return child.ensure_loaded() + end + function child.draw(...) + child.ensure_loaded():draw(...) + end + function child.unload() + if surface then + surface:dispose() + surface = nil + end + end + function child.get_config() + return child + end + return child + end; + ["json"] = function(value) + return require("json").decode(value) + end; +} + +local types = { + ["date"] = function(value) + return value + end; + ["json"] = function(value) + return value + end; + ["text"] = function(value) + return value + end; + ["string"] = function(value) + return value + end; + ["integer"] = function(value) + return value + end; + ["select"] = function(value) + return value + end; + ["device"] = function(value) + return value + end; + ["boolean"] = function(value) + return value + end; + ["duration"] = function(value) + return value + end; + ["custom"] = function(value) + return value + end; + ["color"] = function(value) + local color = {} + color.r = value.r + color.g = value.g + color.b = value.b + color.a = value.a + color.rgba_table = {color.r, color.g, color.b, color.a} + color.rgba = function() + return color.r, color.g, color.b, color.a + end + color.rgb_with_a = function(a) + return color.r, color.g, color.b, a + end + color.clear = function() + gl.clear(color.r, color.g, color.b, color.a) + end + return color + end; + ["resource"] = function(value) + return resource_types[value.type](value) + end; + ["font"] = function(value) + return resource.load_font(value.asset_name) + end; +} + +local function parse_config(options, config) + local function parse_recursive(options, config, target) + for _, option in ipairs(options) do + local name = option.name + if name then + if option.type == "list" then + local list = {} + for _, child_config in ipairs(config[name]) do + local child = {} + parse_recursive(option.items, child_config, child) + list[#list + 1] = child + end + target[name] = list + else + target[name] = types[option.type](config[name]) + end + end + end + end + local current_config = {} + parse_recursive(options, config, current_config) + return current_config +end + +return { + parse_config = parse_config; +} diff --git a/hosted.py b/hosted.py new file mode 100644 index 0000000..274d36c --- /dev/null +++ b/hosted.py @@ -0,0 +1,1374 @@ +# +# Part of info-beamer hosted. You can find the latest version +# of this file at: +# +# https://github.com/info-beamer/package-sdk +# +# Copyright (c) 2014-2020 Florian Wesch +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the +# distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +VERSION = "1.9" + +import os, re, sys, json, time, traceback, marshal, hashlib +import errno, socket, select, threading, Queue, ctypes +import pyinotify, requests +from functools import wraps +from collections import namedtuple +from tempfile import NamedTemporaryFile + +types = {} + +def init_types(): + def type(fn): + types[fn.__name__] = fn + return fn + + @type + def color(value): + return value + + @type + def string(value): + return value + + @type + def text(value): + return value + + @type + def section(value): + return value + + @type + def boolean(value): + return value + + @type + def select(value): + return value + + @type + def duration(value): + return value + + @type + def integer(value): + return value + + @type + def float(value): + return value + + @type + def font(value): + return value + + @type + def device(value): + return value + + @type + def resource(value): + return value + + @type + def device_token(value): + return value + + @type + def json(value): + return value + + @type + def custom(value): + return value + + @type + def date(value): + return value + +init_types() + +def log(msg, name='hosted.py'): + sys.stderr.write("[{}] {}\n".format(name, msg)) + +def abort_service(reason): + log("restarting service (%s)" % reason) + os._exit(0) + time.sleep(2) + os.kill(os.getpid(), 2) + time.sleep(2) + os.kill(os.getpid(), 15) + time.sleep(2) + os.kill(os.getpid(), 9) + time.sleep(100) + +CLOCK_MONOTONIC_RAW = 4 # see + +class timespec(ctypes.Structure): + _fields_ = [ + ('tv_sec', ctypes.c_long), + ('tv_nsec', ctypes.c_long), + ] + +librt = ctypes.CDLL('librt.so.1') +clock_gettime = librt.clock_gettime +clock_gettime.argtypes = [ctypes.c_int, ctypes.POINTER(timespec)] + +def monotonic_time(): + t = timespec() + clock_gettime(CLOCK_MONOTONIC_RAW , ctypes.pointer(t)) + return t.tv_sec + t.tv_nsec * 1e-9 + +class InfoBeamerQueryException(Exception): + pass + +class InfoBeamerQuery(object): + def __init__(self, host='127.0.0.1', port=4444): + self._sock = None + self._conn = None + self._host = host + self._port = port + self._timeout = 2 + self._version = None + + def _reconnect(self): + if self._conn is not None: + return + try: + self._sock = socket.create_connection((self._host, self._port), self._timeout) + self._conn = self._sock.makefile() + intro = self._conn.readline() + except socket.timeout: + self._reset() + raise InfoBeamerQueryException("Timeout while reopening connection") + except socket.error as err: + self._reset() + raise InfoBeamerQueryException("Cannot connect to %s:%s: %s" % ( + self._host, self._port, err)) + m = re.match("^Info Beamer PI ([^ ]+)", intro) + if not m: + self._reset() + raise InfoBeamerQueryException("Invalid handshake. Not info-beamer?") + self._version = m.group(1) + + def _parse_line(self): + line = self._conn.readline() + if not line: + return None + return line.rstrip() + + def _parse_multi_line(self): + lines = [] + while 1: + line = self._conn.readline() + if not line: + return None + line = line.rstrip() + if not line: + break + lines.append(line) + return '\n'.join(lines) + + def _send_cmd(self, min_version, cmd, multiline=False): + for retry in (1, 2): + self._reconnect() + if self._version <= min_version: + raise InfoBeamerQueryException( + "This query is not implemented in your version of info-beamer. " + "%s or higher required, %s found" % (min_version, self._version) + ) + try: + self._conn.write(cmd + "\n") + self._conn.flush() + response = self._parse_multi_line() if multiline else self._parse_line() + if response is None: + self._reset() + continue + return response + except socket.error: + self._reset() + continue + except socket.timeout: + self._reset() + raise InfoBeamerQueryException("Timeout waiting for response") + except Exception: + self._reset() + continue + raise InfoBeamerQueryException("Failed to get a response") + + def _reset(self, close=True): + if close: + try: + if self._conn: self._conn.close() + if self._sock: self._sock.close() + except: + pass + self._conn = None + self._sock = None + + @property + def addr(self): + return "%s:%s" % (self._host, self._port) + + def close(self): + self._reset() + + @property + def ping(self): + "tests if info-beamer is reachable" + return self._send_cmd( + "0.6", "*query/*ping", + ) == "pong" + + @property + def uptime(self): + "returns the uptime in seconds" + return int(self._send_cmd( + "0.6", "*query/*uptime", + )) + + @property + def objects(self): + "returns the number of allocated info-beamer objects" + return int(self._send_cmd( + "0.9.4", "*query/*objects", + )) + + @property + def version(self): + "returns the running info-beamer version" + return self._send_cmd( + "0.6", "*query/*version", + ) + + @property + def fps(self): + "returns the FPS of the top level node" + return float(self._send_cmd( + "0.6", "*query/*fps", + )) + + @property + def display(self): + "returns the display configuration" + return json.loads(self._send_cmd( + "1.0", "*query/*display", + )) + + ResourceUsage = namedtuple("ResourceUsage", "user_time system_time memory") + @property + def resources(self): + "returns information about used resources" + return self.ResourceUsage._make(int(v) for v in self._send_cmd( + "0.6", "*query/*resources", + ).split(',')) + + ScreenSize = namedtuple("ScreenSize", "width height") + @property + def screen(self): + "returns the native screen size" + return self.ScreenSize._make(int(v) for v in self._send_cmd( + "0.8.1", "*query/*screen", + ).split(',')) + + @property + def runid(self): + "returns a unique run id that changes with every restart of info-beamer" + return self._send_cmd( + "0.9.0", "*query/*runid", + ) + + @property + def nodes(self): + "returns a list of nodes" + nodes = self._send_cmd( + "0.9.3", "*query/*nodes", + ).split(',') + return [] if not nodes[0] else nodes + + class Node(object): + def __init__(self, ib, path): + self._ib = ib + self._path = path + + @property + def mem(self): + "returns the Lua memory usage of this node" + return int(self._ib._send_cmd( + "0.6", "*query/*mem/%s" % self._path + )) + + @property + def fps(self): + "returns the framerate of this node" + return float(self._ib._send_cmd( + "0.6", "*query/*fps/%s" % self._path + )) + + def io(self, raw=True): + "creates a tcp connection to this node" + status = self._ib._send_cmd( + "0.6", "%s%s" % ("*raw/" if raw else '', self._path), + ) + if status != 'ok!': + raise InfoBeamerQueryException("Cannot connect to node %s" % self._path) + sock = self._ib._sock + sock.settimeout(None) + return self._ib._conn + + @property + def has_error(self): + "queries the error flag" + return bool(int(self._ib._send_cmd( + "0.8.2", "*query/*has_error/%s" % self._path, + ))) + + @property + def error(self): + "returns the last Lua traceback" + return self._ib._send_cmd( + "0.8.2", "*query/*error/%s" % self._path, multiline=True + ) + + def __repr__(self): + return "%s/%s" % (self._ib, self._path) + + def node(self, node): + return self.Node(self, node) + + def __repr__(self): + return "" % self.addr + + +class Configuration(object): + def __init__(self): + self._restart = False + self._options = [] + self._config = {} + self._parsed = {} + self.parse_node_json(do_update=False) + self.parse_config_json() + + def restart_on_update(self): + log("going to restart when config is updated") + self._restart = True + + def parse_node_json(self, do_update=True): + with open("node.json") as f: + self._options = json.load(f).get('options', []) + if do_update: + self.update_config() + + def parse_config_json(self, do_update=True): + with open("config.json") as f: + self._config = json.load(f) + if do_update: + self.update_config() + + def update_config(self): + if self._restart: + return abort_service("restart_on_update set") + + def parse_recursive(options, config, target): + # print 'parsing', config + for option in options: + if not 'name' in option: + continue + if option['type'] == 'list': + items = [] + for item in config[option['name']]: + parsed = {} + parse_recursive(option['items'], item, parsed) + items.append(parsed) + target[option['name']] = items + continue + target[option['name']] = types[option['type']](config[option['name']]) + + parsed = {} + parse_recursive(self._options, self._config, parsed) + log("updated config") + self._parsed = parsed + + @property + def raw(self): + return self._config + + @property + def metadata(self): + return self._config['__metadata'] + + def __getitem__(self, key): + return self._parsed[key] + + def __getattr__(self, key): + return self._parsed[key] + +def setup_inotify(configuration): + class EventHandler(pyinotify.ProcessEvent): + def process_default(self, event): + basename = os.path.basename(event.pathname) + if basename == 'node.json': + log("node.json changed") + configuration.parse_node_json() + elif basename == 'config.json': + log("config.json changed!") + configuration.parse_config_json() + elif basename.endswith('.py'): + abort_service("python file changed") + + wm = pyinotify.WatchManager() + + notifier = pyinotify.ThreadedNotifier(wm, EventHandler()) + notifier.daemon = True + notifier.start() + + wm.add_watch('.', pyinotify.IN_MOVED_TO) + +class RPC(object): + def __init__(self, path, callbacks): + self._path = path + self._callbacks = callbacks + self._lock = threading.Lock() + self._con = None + thread = threading.Thread(target=self._listen_thread) + thread.daemon = True + thread.start() + + def _get_connection(self): + if self._con is None: + try: + self._con = InfoBeamerQuery().node( + self._path + "/rpc/python" + ).io(raw=True) + except InfoBeamerQueryException: + return None + return self._con + + def _close_connection(self): + with self._lock: + if self._con: + try: + self._con.close() + except: + pass + self._con = None + + def _send(self, line): + with self._lock: + con = self._get_connection() + if con is None: + return + try: + con.write(line + '\n') + con.flush() + return True + except: + self._close_connection() + return False + + def _recv(self): + with self._lock: + con = self._get_connection() + try: + return con.readline() + except: + self._close_connection() + + def _listen_thread(self): + while 1: + line = self._recv() + if not line: + self._close_connection() + time.sleep(0.5) + continue + try: + args = json.loads(line) + method = args.pop(0) + callback = self._callbacks.get(method) + if callback: + callback(*args) + else: + log("callback '%s' not found" % (method,)) + except: + traceback.print_exc() + + def register(self, name, fn): + self._callbacks[name] = fn + + def call(self, fn): + self.register(fn.__name__, fn) + + def __getattr__(self, method): + def call(*args): + args = list(args) + args.insert(0, method) + return self._send(json.dumps( + args, + ensure_ascii=False, + separators=(',',':'), + ).encode('utf8')) + return call + +class Cache(object): + def __init__(self, scope='default'): + self._touched = set() + self._prefix = 'cache-%s-' % scope + + def key_to_fname(self, key): + return self._prefix + hashlib.md5(key).hexdigest() + + def has(self, key, max_age=None): + try: + stat = os.stat(self.key_to_fname(key)) + if max_age is not None: + now = time.time() + if now > stat.st_mtime + max_age: + return False + return True + except: + return False + + def get(self, key, max_age=None): + try: + with open(self.file_ref(key)) as f: + if max_age is not None: + stat = os.fstat(f.fileno()) + now = time.time() + if now > stat.st_mtime + max_age: + return None + return f.read() + except: + return None + + def get_json(self, key, max_age=None): + data = self.get(key, max_age) + if data is None: + return None + return json.loads(data) + + def set(self, key, value): + with open(self.file_ref(key), "wb") as f: + f.write(value) + + def set_json(self, key, data): + self.set(key, json.dumps(data)) + + def file_ref(self, key): + fname = self.key_to_fname(key) + self._touched.add(fname) + return fname + + def start(self): + self._touched = set() + + def prune(self): + existing = set() + for fname in os.listdir("."): + if not fname.startswith(self._prefix): + continue + existing.add(fname) + prunable = existing - self._touched + for fname in prunable: + try: + log("pruning %s" % fname) + os.unlink(fname) + except: + pass + + def clear(self): + self.start() + self.prune() + + def call(self, max_age=None): + def deco(fn): + @wraps(fn) + def wrapper(*args, **kwargs): + key = marshal.dumps((fn.__name__, args, kwargs), 2) + cached = self.get(key, max_age) + if cached is not None: + return marshal.loads(cached) + val = fn(*args, **kwargs) + self.set(key, marshal.dumps(val, 2)) + return val + return wrapper + return deco + + def file_producer(self, max_age=None): + def deco(fn): + @wraps(fn) + def wrapper(*args, **kwargs): + key = marshal.dumps((fn.__name__, args, kwargs), 2) + if self.has(key, max_age): + return self.file_ref(key) + val = fn(*args, **kwargs) + if val is None: + return None + self.set(key, val) + return self.file_ref(key) + return wrapper + return deco + +class Node(object): + def __init__(self, node): + self._node = node + self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + + def send_raw(self, raw): + log("sending %r" % (raw,)) + self._sock.sendto(raw, ('127.0.0.1', 4444)) + + def send(self, data): + self.send_raw(self._node + data) + + def send_json(self, path, data): + self.send('%s:%s' % (path, json.dumps( + data, + ensure_ascii=False, + separators=(',',':'), + ).encode('utf8'))) + + @property + def is_top_level(self): + return self._node == "root" + + @property + def path(self): + return self._node + + def write_file(self, filename, content): + f = NamedTemporaryFile(prefix='.hosted-py-tmp', dir=os.getcwd()) + try: + f.write(content) + except: + traceback.print_exc() + f.close() + raise + else: + f.delete = False + f.close() + os.rename(f.name, filename) + + def write_json(self, filename, data): + self.write_file(filename, json.dumps( + data, + ensure_ascii=False, + separators=(',',':'), + ).encode('utf8')) + + class Sender(object): + def __init__(self, node, path): + self._node = node + self._path = path + + def __call__(self, data): + if isinstance(data, (dict, list)): + raw = "%s:%s" % (self._path, json.dumps( + data, + ensure_ascii=False, + separators=(',',':'), + ).encode('utf8')) + else: + raw = "%s:%s" % (self._path, data) + self._node.send_raw(raw) + + def __getitem__(self, path): + return self.Sender(self, self._node + path) + + def __call__(self, data): + return self.Sender(self, self._node)(data) + + def connect(self, suffix=""): + ib = InfoBeamerQuery() + return ib.node(self.path + suffix).io(raw=True) + + def rpc(self, **callbacks): + return RPC(self.path, callbacks) + + def cache(self, scope='default'): + return Cache(scope) + + def scratch_cached(self, filename, generator): + cached = os.path.join(os.environ['SCRATCH'], filename) + + if not os.path.exists(cached): + f = NamedTemporaryFile(prefix='scratch-cached-tmp', dir=os.environ['SCRATCH']) + try: + generator(f) + except: + raise + else: + f.delete = False + f.close() + os.rename(f.name, cached) + + if os.path.exists(filename): + try: + os.unlink(filename) + except: + pass + os.symlink(cached, filename) + +class APIError(Exception): + pass + +class APIProxy(object): + def __init__(self, apis, api_name): + self._apis = apis + self._api_name = api_name + + @property + def url(self): + index = self._apis.get_api_index() + if not self._api_name in index: + raise APIError("api '%s' not available" % (self._api_name,)) + return index[self._api_name]['url'] + + def unwrap(self, r): + r.raise_for_status() + if r.status_code == 304: + return None + if r.headers['content-type'] == 'application/json': + resp = r.json() + if not resp['ok']: + raise APIError(u"api call failed: %s" % ( + resp.get('error', ''), + )) + return resp.get(self._api_name) + else: + return r.content + + def add_default_args(self, kwargs): + if not 'timeout' in kwargs: + kwargs['timeout'] = 10 + return kwargs + + def get(self, **kwargs): + try: + return self.unwrap(self._apis.session.get( + url = self.url, + **self.add_default_args(kwargs) + )) + except APIError: + raise + except Exception as err: + raise APIError(err) + + def post(self, **kwargs): + try: + return self.unwrap(self._apis.session.post( + url = self.url, + **self.add_default_args(kwargs) + )) + except APIError: + raise + except Exception as err: + raise APIError(err) + + def delete(self, **kwargs): + try: + return self.unwrap(self._apis.session.delete( + url = self.url, + **self.add_default_args(kwargs) + )) + except APIError: + raise + except Exception as err: + raise APIError(err) + + +class OnDeviceAPIs(object): + def __init__(self, config): + self._config = config + self._index = None + self._valid_until = 0 + self._lock = threading.Lock() + self._session = requests.Session() + self._session.headers.update({ + 'User-Agent': 'hosted.py version/%s' % (VERSION,) + }) + + def update_apis(self): + log("fetching api index") + r = self._session.get( + url = self._config.metadata['api'], + timeout = 5, + ) + r.raise_for_status() + resp = r.json() + if not resp['ok']: + raise APIError("cannot retrieve api index") + self._index = resp['apis'] + self._valid_until = resp['valid_until'] - 300 + + def get_api_index(self): + with self._lock: + now = time.time() + if now > self._valid_until: + self.update_apis() + return self._index + + @property + def session(self): + return self._session + + def list(self): + try: + index = self.get_api_index() + return sorted(index.keys()) + except Exception as err: + raise APIError(err) + + def __getitem__(self, api_name): + return APIProxy(self, api_name) + + def __getattr__(self, api_name): + return APIProxy(self, api_name) + +class HostedAPI(object): + def __init__(self, api, on_device_token): + self._api = api + self._on_device_token = on_device_token + self._lock = threading.Lock() + self._next_refresh = 0 + self._api_key = None + self._uses = 0 + self._expire = 0 + self._base_url = None + self._session = requests.Session() + self._session.headers.update({ + 'User-Agent': 'hosted.py version/%s - on-device' % (VERSION,) + }) + + def use_api_key(self): + with self._lock: + now = time.time() + self._uses -= 1 + if self._uses <= 0: + log('hosted API adhoc key used up') + self._api_key = None + elif now > self._expire: + log('hosted API adhoc key expired') + self._api_key = None + else: + log('hosted API adhoc key usage: %d uses, %ds left' %( + self._uses, self._expire - now + )) + if self._api_key is None: + if time.time() < self._next_refresh: + return None + log('refreshing hosted API adhoc key') + self._next_refresh = time.time() + 15 + try: + r = self._api['api_key'].get( + params = dict( + on_device_token = self._on_device_token + ), + timeout = 5, + ) + except: + return None + self._api_key = r['api_key'] + self._uses = r['uses'] + self._expire = now + r['expire'] - 1 + self._base_url = r['base_url'] + return self._api_key + + def add_default_args(self, kwargs): + if not 'timeout' in kwargs: + kwargs['timeout'] = 10 + return kwargs + + def ensure_api_key(self, kwargs): + api_key = self.use_api_key() + if api_key is None: + raise APIError('cannot retrieve API key') + kwargs['auth'] = ('', api_key) + + def get(self, endpoint, **kwargs): + try: + self.ensure_api_key(kwargs) + r = self._session.get( + url = self._base_url + endpoint, + **self.add_default_args(kwargs) + ) + r.raise_for_status() + return r.json() + except APIError: + raise + except Exception as err: + raise APIError(err) + + def post(self, endpoint, **kwargs): + try: + self.ensure_api_key(kwargs) + r = self._session.post( + url = self._base_url + endpoint, + **self.add_default_args(kwargs) + ) + r.raise_for_status() + return r.json() + except APIError: + raise + except Exception as err: + raise APIError(err) + + def delete(self, endpoint, **kwargs): + try: + self.ensure_api_key(kwargs) + r = self._session.delete( + url = self._base_url + endpoint, + **self.add_default_args(kwargs) + ) + r.raise_for_status() + return r.json() + except APIError: + raise + except Exception as err: + raise APIError(err) + +class DeviceKV(object): + def __init__(self, api): + self._api = api + self._cache = {} + self._cache_complete = False + self._use_cache = True + + def cache_enabled(self, enabled): + self._use_cache = enabled + self._cache = {} + self._cache_complete = False + + def __setitem__(self, key, value): + if self._use_cache: + if key in self._cache and self._cache[key] == value: + return + self._api['kv'].post( + data = { + key: value + } + ) + if self._use_cache: + self._cache[key] = value + + def __getitem__(self, key): + if self._use_cache: + if key in self._cache: + return self._cache[key] + result = self._api['kv'].get( + params = dict( + keys = key, + ), + timeout = 5, + )['v'] + if key not in result: + raise KeyError(key) + value = result[key] + if self._use_cache: + self._cache[key] = value + return value + + # http api cannot reliably determine if a key has + # been deleted, so __delitem__ always succeeds and + # does not throw KeyError for missing keys. + def __delitem__(self, key): + if self._use_cache and self._cache_complete: + if key not in self._cache: + return + self._api['kv'].delete( + params = dict( + keys = key, + ), + timeout = 5, + ) + if self._use_cache and key in self._cache: + if key in self._cache: + del self._cache[key] + + def update(self, dct): + if self._use_cache: + for key, value in dct.items(): + if key in self._cache and self._cache[key] == value: + dct.pop(key) + if not dct: + return + self._api['kv'].post( + data = dct + ) + if self._use_cache: + for key, value in dct.iteritems(): + self._cache[key] = value + + def get(self, key, default=None): + try: + return self[key] + except KeyError: + return default + + def items(self): + if self._use_cache and self._cache_complete: + return self._cache.items() + result = self._api['kv'].get( + timeout = 5, + )['v'] + if self._use_cache: + for key, value in result.iteritems(): + self._cache[key] = value + self._cache_complete = True + return result.items() + + iteritems = items + + def clear(self): + self._api['kv'].delete() + if self._use_cache: + self._cache = {} + self._cache_complete = False + +class GPIO(object): + def __init__(self): + self._pin_fd = {} + self._state = {} + self._fd_2_pin = {} + self._poll = select.poll() + self._lock = threading.Lock() + + def setup_pin(self, pin, direction="in", invert=False): + if not os.path.exists("/sys/class/gpio/gpio%d" % pin): + with open("/sys/class/gpio/export", "wb") as f: + f.write(str(pin)) + # mdev is giving the newly create GPIO directory correct permissions. + for i in range(10): + try: + with open("/sys/class/gpio/gpio%d/active_low" % pin, "wb") as f: + f.write("1" if invert else "0") + break + except IOError as err: + if err.errno != errno.EACCES: + raise + time.sleep(0.1) + log("waiting for GPIO permissions") + else: + raise IOError(errno.EACCES, "Cannot access GPIO") + with open("/sys/class/gpio/gpio%d/direction" % pin, "wb") as f: + f.write(direction) + + def set_pin_value(self, pin, high): + with open("/sys/class/gpio/gpio%d/value" % pin, "wb") as f: + f.write("1" if high else "0") + + def monitor(self, pin, invert=False): + if pin in self._pin_fd: + return + self.setup_pin(pin, direction="in", invert=invert) + with open("/sys/class/gpio/gpio%d/edge" % pin, "wb") as f: + f.write("both") + fd = os.open("/sys/class/gpio/gpio%d/value" % pin, os.O_RDONLY) + self._state[pin] = bool(int(os.read(fd, 5))) + self._fd_2_pin[fd] = pin + self._pin_fd[pin] = fd + self._poll.register(fd, select.POLLPRI | select.POLLERR) + + def poll(self, timeout=1000): + changes = [] + for fd, evt in self._poll.poll(timeout): + os.lseek(fd, 0, 0) + state = bool(int(os.read(fd, 5))) + pin = self._fd_2_pin[fd] + with self._lock: + prev_state, self._state[pin] = self._state[pin], state + if state != prev_state: + changes.append((pin, state)) + return changes + + def poll_forever(self): + while 1: + for event in self.poll(): + yield event + + def on(self, pin): + with self._lock: + return self._state.get(pin, False) + +class SyncerAPI(object): + def __init__(self): + self._session = requests.Session() + + def unwrap(self, r): + r.raise_for_status() + return r.json() + + def get(self, path, params={}): + return self.unwrap(self._session.get( + 'http://127.0.0.1:81%s' % path, + params=params, timeout=10 + )) + + def post(self, path, data={}): + return self.unwrap(self._session.post( + 'http://127.0.0.1:81%s' % path, + data=data, timeout=10 + )) + +class ProofOfPlay(object): + def __init__(self, api, dirname): + self._api = api + self._prefix = os.path.join(os.environ['SCRATCH'], dirname) + try: + os.makedirs(self._prefix) + except: + pass + + pop_info = self._api.pop.get() + + self._max_delay = pop_info['max_delay'] + self._max_lines = pop_info['max_lines'] + self._submission_min_delay = pop_info['submission']['min_delay'] + self._submission_error_delay = pop_info['submission']['error_delay'] + + self._q = Queue.Queue() + self._log = None + + thread = threading.Thread(target=self._submit_thread) + thread.daemon = True + thread.start() + + thread = threading.Thread(target=self._writer_thread) + thread.daemon = True + thread.start() + + def _submit(self, fname, queue_size): + with open(fname, 'rb') as f: + return self._api.pop.post( + timeout = 10, + data = { + 'queue_size': queue_size, + }, + files={ + 'pop-v1': f, + } + ) + + def _submit_thread(self): + time.sleep(3) + while 1: + delay = self._submission_min_delay + try: + log('[pop][submit] gathering files') + files = [ + fname for fname + in os.listdir(self._prefix) + if fname.startswith('submit-') + ] + log('[pop][submit] %d files' % len(files)) + for fname in files: + fullname = os.path.join(self._prefix, fname) + if os.stat(fullname).st_size == 0: + os.unlink(fullname) + continue + try: + log('[pop][submit] submitting %s' % fullname) + status = self._submit(fullname, len(files)) + if status['disabled']: + log('[pop][submit] WARNING: Proof of Play disabled for this device. Submission discarded') + else: + log('[pop][submit] success') + except APIError as err: + log('[pop][submit] failure to submit log %s: %s' % ( + fullname, err + )) + delay = self._submission_error_delay + break + os.unlink(fullname) + break + if not files: + delay = 10 + except Exception as err: + log('[pop][submit] error: %s' % err) + log('[pop][submit] sleeping %ds' % delay) + time.sleep(delay) + + def reopen_log(self): + log_name = os.path.join(self._prefix, 'current.log') + if self._log is not None: + self._log.close() + self._log = None + if os.path.exists(log_name): + os.rename(log_name, os.path.join( + self._prefix, 'submit-%s.log' % os.urandom(16).encode('hex') + )) + self._log = open(log_name, 'wb') + return self._log + + def _writer_thread(self): + submit, log_file, lines = monotonic_time() + self._max_delay, self.reopen_log(), 0 + while 1: + reopen = False + max_wait = max(0.1, submit - monotonic_time()) + log('[pop] got %d lines. waiting %ds for more log lines' % (lines, max_wait)) + try: + line = self._q.get(block=True, timeout=max_wait) + log_file.write(line + '\n') + log_file.flush() + os.fsync(log_file.fileno()) + lines += 1 + log('[pop] line added: %r' % line) + except Queue.Empty: + if lines == 0: + submit += self._max_delay # extend deadline + else: + reopen = True + except Exception as err: + log("[pop] error writing pop log line") + if lines >= self._max_lines: + reopen = True + if reopen: + log('[pop] closing log of %d lines' % lines) + submit, log_file, lines = monotonic_time() + self._max_delay, self.reopen_log(), 0 + + def log(self, play_start, duration, asset_id, asset_filename): + uuid = "%08x%s" % ( + time.time(), os.urandom(12).encode('hex') + ) + self._q.put(json.dumps([ + uuid, + play_start, + duration, + 0 if asset_id is None else asset_id, + asset_filename, + ], + ensure_ascii = False, + separators = (',',':'), + ).encode('utf8')) + +class Device(object): + def __init__(self, kv, api): + self._socket = None + self._gpio = GPIO() + self._kv = kv + self._api = api + + @property + def kv(self): + return self._kv + + @property + def gpio(self): + return self._gpio + + @property + def serial(self): + return os.environ['SERIAL'] + + @property + def screen_resolution(self): + with open("/sys/class/graphics/fb0/virtual_size", "rb") as f: + return [int(val) for val in f.read().strip().split(',')] + + @property + def screen_w(self): + return self.screen_resolution[0] + + @property + def screen_h(self): + return self.screen_resolution[1] + + @property + def syncer_api(self): + return SyncerAPI() + + def ensure_connected(self): + if self._socket: + return True + try: + log("establishing upstream connection") + self._socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self._socket.connect(os.getenv('SYNCER_SOCKET', "/tmp/syncer")) + return True + except Exception as err: + log("cannot connect to upstream socket: %s" % (err,)) + return False + + def send_raw(self, raw): + try: + if self.ensure_connected(): + self._socket.send(raw + '\n') + except Exception as err: + log("cannot send to upstream: %s" % (err,)) + if self._socket: + self._socket.close() + self._socket = None + + def send_upstream(self, **data): + self.send_raw(json.dumps(data)) + + def turn_screen_off(self): + self.send_raw("tv off") + + def turn_screen_on(self): + self.send_raw("tv on") + + def screen(self, on=True): + if on: + self.turn_screen_on() + else: + self.turn_screen_off() + + def reboot(self): + self.send_raw("system reboot") + + def halt_until_powercycled(self): + self.send_raw("system halt") + + def restart_infobeamer(self): + self.send_raw("infobeamer restart") + + def verify_cache(self): + self.send_raw("syncer verify_cache") + + def pop(self, dirname='pop'): + return ProofOfPlay(self._api, dirname) + + def hosted_api(self, on_device_token): + return HostedAPI(self._api, on_device_token) + +if __name__ == "__main__": + print("nothing to do here") + sys.exit(1) +else: + log("starting version %s" % (VERSION,)) + + node = NODE = Node(os.environ['NODE']) + config = CONFIG = Configuration() + api = API = OnDeviceAPIs(CONFIG) + device = DEVICE = Device( + kv = DeviceKV(api), + api = api, + ) + + setup_inotify(CONFIG) + log("ready to go!") diff --git a/node.json b/node.json new file mode 100644 index 0000000..4243d4b --- /dev/null +++ b/node.json @@ -0,0 +1,4 @@ +{ + "name": "c3voc testcard", + "options": [] +} diff --git a/node.lua b/node.lua new file mode 100644 index 0000000..53e5791 --- /dev/null +++ b/node.lua @@ -0,0 +1,38 @@ +util.init_hosted() + +local json = require "json" + +local serial = sys.get_env "SERIAL" +local location = "" +local description = "" + +util.data_mapper{ + ["device_info"] = function(info) + info = json.decode(info) + location = info.location + description = info.description + end +} + +gl.setup(NATIVE_WIDTH, NATIVE_HEIGHT) + +card = resource.load_image("testcard.png") +font = resource.load_font("vera.ttf") + +function node.render() + gl.clear(0,0,0,1) + + card:draw(0, 0, 1920, 1080) + + -- upper: 623 + -- lower: 707 + + upper_text = "C3VOC: " .. description + lower_text = location .. " - Serial " .. serial + + upper_width = font:width(upper_text, 40) + font:write(1920-(upper_width/2), 631, upper_text, 40, 1,1,1,1) + + lower_width = font:width(lower_text, 20) + font:write(1920-(lower_width/2), 679, lower_text, 20, 1,1,1,1) +end diff --git a/package.json b/package.json new file mode 100644 index 0000000..e6b3e79 --- /dev/null +++ b/package.json @@ -0,0 +1,20 @@ +{ + "name": "c3voc testcard", + "author": "Kunsi ", + "desc": "testcard", + "repository": "https://git.kunsmann.eu/kunsi/icinga2beamer", + "nesting": { + "parents": [ + "top-level" + ], + "childs": "any" + }, + "platforms": [ + "pi/epoch-1", + "pi/epoch-2" + ], + "offline": { + "support": "no", + "info": "Needs to fetch information about itself from info-beamer api" + } +} diff --git a/package.png b/package.png new file mode 100644 index 0000000000000000000000000000000000000000..08a5f2d639194439cc5b39cd89f6bc3a29e9aa94 GIT binary patch literal 2750 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 sys.stderr, info + node["/device_info"]( + dict( + description=info["description"], + location=info["location"], + ) + ) + + +if __name__ == "__main__": + while 1: + try: + fetch_info() + except: + traceback.print_exc() + finally: + time.sleep(15) diff --git a/testcard.png b/testcard.png new file mode 100644 index 0000000000000000000000000000000000000000..4b75fee824c83adbeb7fd6cc874947214879375d GIT binary patch literal 62884 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

B-* zC^QzD=7A5@!hAMQtdbVU3v~1J<@)*N#pcD<8ljf06jwpfN)(KwZpZzF^0u2a0p-|!ObcW!}m_*E{=TZbfN8XRDk9()43 z^bP|YgmykD6|i~dJ`>KjIO|O5Cb*~wU%^FHpFlKXG(&K&oz_fa8y~g3ucYqeTf%SN z{1Bc(gOdw2D+D^=XD)Ul1RKt5us+a~pieM$7kcY^nnvg+N)PIbg-7)Bgn6bKVTn*H zt=6wFZ4%ZCTcoG-n@yqcQkY(+GawWI=Qhw_x5U#9LL!ToI_MG%i6*zD2jN~o=NqTVAwyT6x1cLziBqm2}Qk#f_k%@{ls=PlC&v=#|>^ zqfp(vf`vn4HbG;4gEgfmn>-!7yMh)DKqff{^y%D@L)L=mk)TU;2341;ak^hu8^p-f zMt@207kUWELNcT^Q}75L$)kTjctCnUUnD#(Y!vJPG=xPO<7p!6MSC-k5&L#FpOqVT z8~N!FQzZ@BSG<(Jc``@lvoS78Pzkp`_uJ29xQTQkS-A(w&s@((;Fma(i2kv z3(?z6Nv0mGk3P*blnvL9HjQJG^u?@1UuK%e=Ia-mcAEk?XK+3NJJN$jRf_dZIqdA+ z0qjWAbm_|WyJZKriyJs5Ja=LuGSqZrtj8uEkdF!n$V=GFv%y4<6Z{K2_R9kmEdfy^ z_@NuP#Uk}!7=FXv9km8sKhZKgGE_QSnPj|$9;S#*su^0-{f}qemoF9!2Y?1 zP^L`${(IT~$3NG}B8T-V+m9>9kL6!KYIHDj2H!2_{UBOk>`|Q z%CK_+groTqU9HSPQUfIZh7vCND~GVVxBZqJfK?RjJo<7OWCedj|GR%w4%O9hYz~UI zgjI4eT6Xgo=rQuL$c9j)GH@io1#g@d$z?#{{&)aifwYWjcN16f+R&pRvK4EpZYa&mEorr04tO+!eKo(>%=uMGK@1GG5dR@2-+oXvu zeC{U1Sy-f$cxB}%yZ{Ol}D6Emb=TNmP9OxT;g65 z71Z`DaRBWFHnoJBquRyZh1Wkjw6tv7iN?mXQ!5XhZ@x=~=eFb>&nS<}K77x+HXc zXhSI9ytTN-JPyx;o$9U$@mTgv_ER}8pE>h#&QsZ=_D*SrgV%-1fs|Bi({63DFBf9ZpjQrxyHQ9u(84 zb-Eq3cwkIrrk3y$(DpomJ=56O_oc_q-@AAIv6q_9f^7TugLLe;F!iS!`wR2w5UR&( zNWS9ol84cfS8g#Js!WJsBZ5Z5d%I zh^N(4AWl5(X#2K$Wba8#3oj3E2>&4bR=AW#(rB8H=1L2dI_r}3NrukGGEzp%gfdrI zsA0;ZoWN0PT19Ih89P!PBFs1f5f?WdHD7#X=GkclA3UPmR?gDIrZ1?jQP{h3`w6Qs zb@J_SdZhAmXW_>q1*2$^^5KaiM-IOx`)|vcQBc>E#6GOce)V~k z2g-PHGI(G@w##swA(+Dr&Kkdf6E=1tKBh6@l;MQ!wUF@mV4^n-IxB7~zS_RQY;O?&rls^8nFD0lJ?J@CM; zF~2?5=jdanv=1?6LYoCr+flJm;-5!k*@bgk8ILy}qZpR`ze+RaE#rr{7y(`U1?$&!szI zSNXd55;=u)X}w4?Th65sx5fJAdqyqI9_yP&fcY`?TaEZn%)8ql`~MZ=-TOotua0LT zHZsH$W)gJ7`np+HE4@ZenP0N&?UFp&LiJ{nX;+V|uS3a0k$?~UjFdA06FEGN97mp` z+@Ve6?+XHJ6F&Rf%x)zk)mhhk^ybd|ZE}adLZUbYcLEb5tWV;v$AV9hExur|o@BNU z24DB>kocK!yI`rx3ev}gX}r!xb9uuN4kHrTkPNBEir^gc6neI zZXpj&o;)GMeb;Z%=vT-VfdZSBIKIbX_r~kX zrCSJ5s_X)*WdEP=d&DZObm3Sv(PXkGUUnLSY(x&%xy-fUZq^ujD%h?g4x3&t=Q#AX zoUkC6q8Mndl%^)c>r~IUfB);Z)i5p>L62W@Y)))>?E2USyxxfYEcRZk0Wzsdp{uQA zwu-1r6Vb$sHl+eR?MsSYg*QJKlJ< zxmL_OJbl_@UJS%SVBm+-xOVI1)Gx0WZa&rZaxBmFdnB0Ow_?2D{OXFq#C*YMI)9F; zZvvrj{Nxi(a>Crm^DCXU2bj~9abJF=CnhbpnpDe+b&K_jvDaB_sx~jSEVeGTEw(Rq zR684jZv{I5O`DXPc4?TEn+`o+zwywajkl;%xq0jF%JR!NLdJLL> z@s|i31n`{QRFyP5Jru4*JC~#K#EBNqLg?*tH}*FlmW>D7_!jg#pUDLETC}wao6qlQ zw5h%nT|I@~n`(T6X(+;+_=KDUKj4*MM&x8w=Eq1+cV`Gc=(|ov%Q7=6B z)4#kj#fF1&4wCHgmk~X2;JT%?(QryP>kVR# zMKseJ#DovFO7yRBtqS5kSR8yXUlempsNSm6`$uPV;80y|7sZ5Ah772G-sFo@-3e+@ zO!bq;cM|yKb#|CB%oJws3fH2usk6DCp`Wpzsh`>8CTb@WT}PjYn(=n&B% zGSQtF6`N3FtTEM?Yb;IzdI^GTlugXcEX>Mm%+7*Y2n%IlxK5Rjl$e(IaN^>`C5h`3 z8xn6N24R!EnLb|&DiSf{gYR%nzkwJ^xl8}aq>H}iqGUPTT}GB z=lQLF`CaibG3{`N4!OCWtSD>8ZL4-3kBND`M~_JljL3md zcoYiWXdc3CPEW%9u?`uz1=iaodL%ppG!Q^5Ueb>{rB!F8#- z!=EKFt{aBHAP))hP|^lrkD%xC8<0uD4-!IHh!~H6Y9dP%-TEG+2kp!HiU^<}%$LQo z#7t?J?9q=W&Bp;PJ9ca(?jhKjBw-PoFD?Sp7t0HEixD|oU|4LZ zHqJFIGS~7Gc^q!>6=H1qPWFOrl>|xJ~&r1j71G?w+d(1Cd ze=EGiUK8=#0fslMr-gUe1@V1pfhs7WG!_47jETmKZ~XeJt6zWBsC;tu?>}6H$ZTda z`TK4I+uSr0#O{YRhhKm|D0i|aQ{utfK#8aPI%<^^8cgAuMz7J_a?nJC?P`-n)}1Q5HNqf2SdgMV8ZEv zPgJ%VMbQ`{x{UG00b)1fIB|k*qOsUGmo60N>Z*)u#bw5A;%;$^?n&c%<34&od{Nx1 zd)C-s3`3ww!cm0@L4C<(2r==HaGaqd0>X%zvtCkn9S`FtTe4WDlwlZd@>p<8LMI86 z*aT_3JV`fRKi)9Olw&Eg%%_VjJLo3e^K_5yh~@W|&n)*WNnnXV;1ORnEH4%+kI;ix zm6OWJtMp~1;wnv~iDF*!XU%WXMrD{VTnJDer97540GEgXk6jfGjY_V z2B%u0tgS~%>S+qjiBr^j1e_;&l@oS#`P$)?wJcwi6Zj5jQSRf!E!=EIDpwZvtZw|4B*b+!A zOt@QgONmH^h%?5TV$BJbj@FJgx1$&IEkf2}veety)6~=4+tSC{$Cm6EL_8D$Y^0}n zyvsG+kYOBZ$+BkIJdRxQ0DV9h$8y9RaBUp8Ho-6fOLm-jl68_T$5Bj+g&D>YYl$t- zQLUeEoo`!3o-nL1tuU{$tg^1MZ8OxH>do7&+iiPHd(6*UpSK-x{NC}I5)v$PqHwFKf!s7g%2QJcLMcf}2$4XJ}@8MQEX5*(|-W;WL zu2kcNp+c5UGU;umAQr0cq<5QoB1oQW;xx=qX*gIv0ip7TO?fm=C}w$Lo-_^N@+GDh zO`%-Pv;@o_Wiy*c3dfoj3CEg?#Jv4YpKRREkOM}EauheT{gH9J%+o#C<}%4~h7h|e z+$6c97%?3%AiVpg!F9mzr8u*}D8&W@lW?QtC-@V0@L;1&io>lu9-)DA15cH2t@#^! zZCrBYn{7CU{KmGgvL)<}{9|AY{qDv1C`|PfiMv1p;QniT!c$MxEke9TO|QhCfK)MX z;7#wn7JNY`L2Zc(L53drIm$S=}GE%efc z(?xZG?$6Igxf;*jV~Ot{FGEtZeeQHJNEYJvVFJz=7*# zJ@-@E>*MQw+_^3^c->P!uA5M|@zY!Nm338HzW;O+_;QtALI!;|w1TXq5EU9aG02VBL<69@0+~m^5(I*rTH}`m2v4$-R5fR>)P>WeZR<;0lhd zDI=%o9Pm)9nT=?il|+&Ao?NrTVh#-pwK~E=Bk&G)goTA#98tC?v%_k(*`nMITT~?f zo^B4cSq$tgmm#9wVp!)6iwF-3az{p4oU#?$!ca0kD9k30cZNkpa|?MR#eVrF4h`_~ z2{8{t_W$~$o2cNpw;uTWPEEZ59sJQsuoH6Q7-NdZ9b&FD?=bU>v(TKFVoQm2j-}eV zAZ$VST=(3lB{60!*tR=ghO|4L+TptvqvboZ+(~Jk2@})OCT&%22~o<#0RwkeRy>{7 zU+~xRpXJGElO_yGn>bPV2NI#P6DzYS8=kJnoSS%OwVDzQ%2q0Kc#bhBi-ZqOS@J2x zu?}i@F6?UEBdF=1)j+g&(K%X;l&YJGnr_}2i70A~nh~b*DaBjEXo6a!W_GAGy?r(0 zrdp$(;vkD5f#)OOKOI?%p9tg-{JduHuhx9rt_C+tTSi;guBKO;nm@L!K^A{&pKIQl zN0mAJbOJS*Uf4dxFJW=m)JVJv^{^JGSN}@QVDf7 zQAYz;@E_+7e)Y>sgZ4Fpf3@c0b~PLV-)QUF)o=)WHGlNhsQX(L0@z?L1o#~@K=AXL z!TcA_ezE4`b~PLV-)QT24K!V!d;J*lW1veCkOM8AFycofn?mt4ylnqCe4gBW-l!vz6eO8>Z4Fo6eusLjinkN}T+#ZMg zj_Wje$GjobFxmMan;aCXUSxq9y^YMKc30u>0~&$+1{@DtVDSqir?fODr?hOeXKtsi zT~E~19&41!%5p}}o;`YW`Ori18U&^Va!5IgT=uOv+l?X*cslt7_!FC% znshiYGTCcvE6peT1578vBf}a4)9q16xb31!EQvCt~gnb+L>=Eq4R}P_>tA-6)HLCdU z{6_cRi)q%XmirWhpe# zG|(@U&;>V*%Z9NZf>v=i@~G|GNZ~^94OVm%{33iwJ z<1&z%NDmXLUVREvT@L*2h1cac#&Ze7 z5V|x)-Z*>qqi+Xnk&YctOx$t#<2ohj;6eIf-AyX}Ba+kqp?d@H`-D6@b|Bf{>7SI` z5&yTk@Z_GNCE%{*vX?KfqgE#khOi{ zgiU>mAN@4=qa{-w?APzTeOcSs{;rd|j$BdO<-x8aRtg*UBqZbvom^?t&)Z%!c})+$DV)wu|w|s1V zs(uI_a}wF^N$!#mWfoZ(w z&(kv_eQ;XJxnarY`V1fZzPZo)&dL_?J_sOqu%7 z)Gr_3N_Dem&zd!Rw(`@~t;$c@Gu17st}dN0vG~a0lDwe7T~{4i+AphT`VOgh>eQ)U zEnE8K)Ts|YJax(!%U66kW$M)FrRaTU`&Q-d?AfJwrqb5!RK~M1O}Q~}#K^Si^A?OR zcj!lDefD8qsxO@$=rE_yOk!_PsFZ{n&2jle=FS`hL(k@?PvYbFcg%1Cpn9 zG{{4y;^wGxI5K+Fi;D z1)ob_mR|qd^E*5X(+980{Nvrbf6Q7bUHmnYO#dYU{&Q)R`^BerAC8P(93FQ2gAacQ zgWjbHY@?is^=`(A|3FU^#ie+o=(HlZc+LWYj+6;$8Z%5YSqf~^{0bZ{HTmu`bgP-F7Q!R*Z%lE^L{@wc|+a_353Li5CTC)L<^{hC8O==)e2QFYBg{zy;UlYO#a{Xotf~^d++alKL3GPIdjh5 zXYak%+H0-7_TFn(NRTxz_{h&mXT*~OALL_}P8G?u)bN#lTw=YGu4layW!L|<-bws{y0zix&Yxqs(?g<9 z-ZNgUFGeg^nKyr2R%5?wP=B^))0J^Lg4Z3v5DYR5)=7mdq!Kq!ES$upYqF^U&#&0L z=7kh`Bfhg_Ok8`{ypR@qNacYEsf5eOI}JXDX;}EWNL!>^WL#vj+^S(}UgGcRroR1l zbotwFn>=s5^_IxU4^$C$ejml`#O1+Uc)0Ysy$0;|cI^>YuBo z`=@8l?XyBH_1}|O-^UJJWW}xp*~fz5aH4J$rkzsE*euOx87b8%W{788W0uZbWO${k z^75x|!>*vBqqjUW%P{fW*5H-0MQG8h zuLiG_JwuCL8?kYwX4x$JTduoi*Q7URMNe_x&^6cWnh3ldRY#3`^{Xf( zu)@!kpK1uWi*f=P?woQ5e)&u#zTV|AC%No55W@q;rJ#cTEO2JTWAc~-mVh;26OU=SC(E1V%krlur3ccJ^L6?9e0Wc@ zu{1s3l8=cE@tu}<%DiR1G6Ya7!K7%Ft_sW4vGCVaZmzOaS*vV=U4z|&J;S`ie8c>M zlLiL{Ctn3$;8k&d>Q$Dj;7=Xx8toqKx!!xd?|T2}q|t%V$rH9^y^#Gv&I`FO6uwaO zLZ5BL=)AITCZ+<#X%n*qI3ozNp+~;MT7;C34M+4px$ME4W~{tt(zplqT=u~DnN7HQ zu=(m=PJL)6A_x6^uY2jjho}?fzEn{e3sN-THtJ5r4fi{aAaS>6~dZ&M@oKNHYkPiWBTEGIS9u7b+Ga6kn0- z-!rSh$qWwF(l}I0!wS*3KfKR_?q>IM?#=F(-Nqu!G8DOrJ$<}=eATWR&uYg*zUQ33 zcC~t1ye@H~$;v)ximDy#&sA3M}7#@w@5s6OIHs2K8rdgtIyskB9%XdZpi0hYc z!bbFPv_=azRQ{p?duK-IUh8_L;TM&Hp%7+yKEo^kj%W!MAY6bx*`&8R^qS9YTAi6J zQ|{{bIcZj(OuJ{vygMTZVD*L=_gGniNSi0P&w@*XUdhUxmb*6>%l|H#f@jZ*EnzKW zT*Ja5Z|K#BS3mLOt9b?1?9Ad(c~^~dSFEd>`B+JGg2~o3a@`ZpKd*cA+%vT`cE=Mb z$z#S|fBl#-UGE8h&F=oYez&m{{@Y?z7fe${Io1qQQNV{I-X4U<7 z^~<`vF8US%SG*X#`u$(MscE--d{<*My7#UIxFkW7wCKIq4YM1P{MKNS&EU`(&Dav| zupwA7Vj`Ikt}hmv!h6-Ln z)HGP{vOlJK3^!MrM0rUF0qo>OFS2UYhR$Y-Jf)yG_)d8e;z#Bm)UiJtlpR%{Hr@XS$&ZEzWZ>hqjyGnT55_Z--lp~ zIzwJ^z?hrmbL9DE8}qXAVW-HZOHfeMcp_3F_V3G@Wq1KELmUL^L7pq^e z7(kzrlpOG4K$V%AndZ&wBb_o2YfZ@m1FI29CdMe$j8iPyCl6{S$FTa9Ic|4ZwYPsk z@7~qv_bdS%h(}UF|gB&KSXP(Po@cw?!^)p5c z%_(==Y|%5i7w)Xl>9yBxx?!?S4Qg9TzYClT-Ti~eeD%F|gLGUZBkJmKMaA#`n zJZA}-fRSBA1;YsnslioWe=1uV_I&l97~;vy1Xuus7VgFLR#ne{4a=R;y!aFi7H!CY zS!{r+wYnF&#_B>(_G`X%HF%&&HkZoY=iFAXmHW6 z5vv!ke%Nr!ExEZ(nVBz~yz=_sbdHq&&+wEJo zuGLCj#gf&BqxVMN{$uogM6%S&oQHWK*65iK;rVh+AH1@tv|y;qsRpzZBtIB<$fsId zgMB+P)A~PHy0b*T!_{uS%=T(l+9L(S22>ZC+^V2D(_H8dD2sDwp~YQVZOOfA7{tsw zhtAa^0w&rMpTHuc>=AXe=hJft-wJktNbq21g?JdH;pM?q<$cThm6w+HFE1-E5B3fA z3zi1^2g`!xWBZQnH@0+a|FLCb%OB|bK>5mGb8vI;h2S58`+^_i-^pMvcp6Q^oWoqh z+{VN^68RH(vAw{w(7DjH&^@i+w9;w)riZp*?(nOFK#=aHENCp z*Mno0hU!JiQF`XZTV?bKh8e1vUeSKN=I1+HBSs(k(SK+bY*Tn=`|LkWpT2MIZ@#^5 z)ccS9{=kJBX?}e8AF)j~x+i3Rf>u6xYV_!t$-DkkRfXLP%kN#bto`}(J8PyzQ{%gC zK)I3K&lolsUW<>zJ`L9P?N^x9EB!m;upNcY9qF%rXB>u6STD0L?}lQJFXbv3hk@lP z;$sXUM_e(3QeRy(4vWpFmj@U1(T0^yN}7;4zSo58xq+EEIBUkxWNf-%9dMJQ!C4<@ zNN>t$%53V@)VnFGDZ3%3DYq%FDZi3VX`zhY#`l`sXO5cbpMf!4 zy}FBIxHY|>OkJPxGg&U;OF%yVn;NA3r#9 zLI0m!*Kx0gmBy6=p1=O3>)u=@tB(g%K0gMw4I(}2e+PRt8*1ypU|DuLHny756sI>- z&i#3gC;gA)ttv3(rX^dAno7?_r~)lFGp7)N36l{i?ZhF*c49{dj$<|&P#pa;dIE3` z`yRHB2ab@$;y5haxODnGXuk`aeeW{eWxglVD1MMwjI_9d<3=P=9uiAU!mc8)TBY{& z>(!Gd53am_{+Mmkrv72ps~?Y=G_kx8;k5R=^_F48h8aJ+dE)m*P8+DX5S{O$QxocV zYJzT+!GaL5dbBbYnU4!hzy2RiO+drqI|dWy99+8cq~}}(O%|f&dHt1sox-^afoGBo z??n;c=P_+Y^cSLOKhUzUMqnz&zbQeRVS^4q@={=WA@C{v^m|04iy@BD$Ma{O(@(|X zsV61h(C+t)X{JVu!%Bjw*hP+m4`9aV6n2#J3X(*|t?L?sw`WBsAeclFtfz;AK@23_4sTlTG}*0g zFnfFVP8*))Kw$UYTDq;p;(yrpd2)+edsuyLXvz7RJJXWiyBCZrhaI)DDIbifSS|Kc zAjF*X!c*demVSwEVg!>?A-gzWSe+lfTxwUvXPC@9oIz)j&Jl}NTMfp@@pFi6)D@2H zH*HB;EvCTUXd3+5&cV~m2HakD`~2KB-)bqt^56Vf6?E&fy)x^66pcLA^+5F4!9enJ zIXP>d)3rUOjo$u-PsWuvgylp1*RcDCU~gSk|E!u4RhsLU6&$@wHe6P-As5Ry92@+# zy;Z5Z7Q?ijScu|Fqz{NbGaFZjOlZ+9 zd}+*8L*N)R4ZZdzxisoBH$7Eihnv}$Kg@F&>YmV-B(W&|oUH|x4 zcjcM&*nPjp=sq(HZ{DaLH54E&CSuA$;*8RNA#tC+i0$zH0#(JTW6TVhY+vAD4(k^d zt3&?StWLAj@`c B$Rw4SzSQ=Ui5YQD@exg+`lsp<{syr;k8E%leX-35St!f~_w0 zE+oQ7#)2sDcnf$J5l7M=`(r4OGbW;a^J0GtdAqP3@9SOKGvl;pdM;&LxEn1QdA=o% zFL3gR&1(MwQI(uuV8y5dO~9H_;}?j@pw}6`z#eAP7wA<+G+EQsa0lW|u_X?RW>l7i zHnX-+uNI*twdXLfj~h=sP9@P2S+scGFOg_LqD2UZDecg-g4mzk+TmzlH020fO#yvM<9Eh0h*iLr84cnyC5N%zvrpX`>Y%TJrOgttP z<>IVPeDyy)bV%27`0$yw!-u2%$Qpv!+9Fv2lUQ|Rl2u1NPha(E z1*}vu$_g0Z8*3&k4(KWmJQ+iRS@1N&&#YFZikI1%idaPfxR<@~G6&L}4C)65GdKd> zFSb{J27$y+Pk4(1ITHRy<)q}r{#KgLB%<1#eJ^@_^a^d4_TsEn(OnWoUb_M=Qzhg(TzmI;0r9HPG>(w;> zBLhq-IrlQF8zDBXxy)z1p|3CVssS)rWGgjo%$Opjafx+P3DXj+T^=kLR&`s|qN+_* zd#mZQ=es>BY}1@jlo zPwZ`4c;~!D(W9#qd!IyODeX&x(k%zZJg*>}z?YbQD0`D5`Ev2$5)vrQVG^Lrbup7)PrwzOV&qegm zyE3=~^Oi#)c4E$hDCR`5rXF~dAC)+(S$I0R+~A^q+#YH4KwMm zf!^^P`Ramq^8^C)3`FwP)cJQC4>OkU?-CJx@ouaPlzOKI?P{Zb6$0a;wov-#7!?>J zrdTy&6^vI+Ftb%3)!s|w#5o9(Q(G+NLhKj>$r&r&AjKOGKNa1r4U^H)2kNJoOInC4 z>E*@2B-N=ibsBV*4F;P77Tyx9zC@FFD1+d7&pAXVmp+5OE?YUpd87O26h2*N#2sr` zcq;1qMt6mHg-y{s{Z}SgQ;2{~K`%tP1@Zf0@l6p?1wNaE8N!v=RB zyol1GYr2o={>+hc-=H6>$r1exM*``G>mE_-44@k7fu?=>X~O0Ziv#9{%omn!J~w5v z@#N`$iF}``#u;8SY=!kxrtXKPvStJfrM*>ArY@(K!&jPQx9RB)uu+h6lkOhy&!aS z+_Jn_arP+69u0Y+UKHA6PrYF@EZ+ch%`bv|>`AF+>_+pfcBQ_a{G#h;R`r@u!+fV9 z86IkPlEGq0Q8v@H2(kbpP*!lu@(Peubmiw2UtvW`+}7>!7N*l%n6A>}-a-r}xHK8R z(PZ3D%oL}4l07L11ej(h&lsDr(!J8N65$&5W&9(KZY@KMa8W2CgYkkeBGb)=! zZ_#Y9WIUSBb#1aVG1kKK4V3m>6i6VMtxHzPm$VMQQ6TOoTIVfK8Jn`ww$i>bWpm2D zlz*gPDvbl3OT!9apNQHK-F`l@fb5GlHe4KA;QR_inJdrsnRY0TWrq#=#$|J?()}^X zttNS$Sc_Xe7y&n7Cs#LUyk$kIPW2IAK2UnvFFXvhvTagWrZTw zDryTqicZm0FdMH^K4Aw-4+=IPu_)UBz~R^v{JWEKcD%i@u-#VcTgXhshcj=N;2UV ze^KmpI_kRUOi>Q8m&TP6Kf$?RQGjexN_{*A_&QeLwjN| zG-UWkvB!BGm^uiH3tJ~PEWAWE%N{6+h;++^>+&v$nRPAs3g_G>=1?xMXf8TL?E;@@ z4g|jcf^=9g8FN}+;xDy)ee?9`7ap#5`mXqKYK8(Hu9i4zZEO7SwN3HE*mU1>+SJrO^j?Y#9o{{kD?9Ji5UE6e3cpSbQb$5)nr*Wxx@lt=Vs zB9H$3YV=Fisl$Y#mHrGwVHQ`g_luWf=q{5d-BCQ5W|kTxo|t1#Fs@U&iPX!9C;Ir4 zArR&}FM69P{v>Ae%Qzun^Bdx;-eXUsoWv9JMNclwV~RhCt(2E1iIwt(_)7WM6M0+W ziTR=@7v?d^6ZFyDsP%HpSL#*vcC|~VT@Cbb)@mxf{Wl1WwL zY)_-CU&7H`cVi$OTP_LrWKV4U*cwwa#pVTDb}RjPML6gBl_$PgyKUQAS;+LwH+b_a z#$Ni-rfSR!+!4%IKC{bi(0pdM-Qarz#~8g4u>WT!4jEA9z=Y&`vG41iOs&0Lqa#U?dLDzvM!DwFz>hT5N*wYd8gBFNNdr(i7ZJSdRxUw)^tZvxEGV z7q&KhkNx(WCroqRW81iH-A2>MYpxl6?PJZ&SgE$&I6^m*Ys>ltt-5#BpAA@77MJ>o zR-poy2IZnBZv8v&m^|-@)$x_#6TJ_SEM-N_Z9y-#*8G=sxBH)|YJy`KHqxX*FMKU} zL?W9fFcqU&Dmf<=>kfMMD#{AB#Icho`a3BuuoSBk3*=!z>YkbyyyE7YuLw@8-?Vh; zCixn_9yal2+?*I(x_PtQ1MamvgfBziz?!M7pv!8qIsb(t^^~VbZ^a6H=?10wJ-k^qu8+l~{y`ukPH|Z&$Bs{Rm;y zq7O-&WNFK_J#EPjy6rBT`CqQD!Cp2)krzgS1df0qcP`eLO0J8Q9?-LLQ+xH^(!SLL zvoFso9MQXeY1Pn)S^fLF-4EDoH{V)52QRuv66n=7gZ2_m!@C>7PUDgQ3-m6o{&ysS zzA~k{Qm?&2LGX>?D{a{~-=OkZ_kY1sy&GdeCw!E>5lK|seaZyChz0h5-Gw75v`mM2 zFhXIwWaulVTSDt1iZ~p4<=e{LW8Dadfu))SDH=^3j4KYlt<{W;-iv_ZQ=ho*6GW_g z>cfT6uMp*5H)QUDjneycVA+wdk?m?~5J6961)>RIQ&FrHYyIjGkjPda+w<}1x!O;A z3Y9fKoD%?3erHp&-xCifztm7~Tjc!MdD3Z>iecyjdkobIzuI_h+{~a;`$ieQF~VDBH0iL66t)(6s5r{F7t)VvV?QKz zHayj3)15LXfzsEpt=YH}baP;YF)Ntuv9{QqpqlSVm)&gE(qM)=lhX_pHm@_&qL!!A zZ6TXLV`qfCSrNCBf_<_xnlfI<&~LJCvTd?&!tVJ^?oFOe-d)yRwq5pJj$N)@?p>Z; zUJut_(9u~lbzb90BMcA z-6n_6cZ127Dxtt2`=H5sR#yVq@y)RqN6Rod7Ci+A!&%~Am;C)tvnw7TiU+3*E0G1I z_aqne&FYg|mRFWvTu@qAT2#_!V8PV|6SF7gOhcr>nYnjo-<@-JuD>7;!)UC2FX}Te z9|`iWDwv!-Ij1hW4s(P}T9d9`-@rIQO&7!oYVtMto01v=^%?b?E0leS%W^lDoGdAl zaa&@#FScgTFN^ABS{#$(;+8AIv71GeDFrD;{nZr{i+{5t^!U2aKm)oU2JxKqcw1yAA^HVAvQurU@I3c2N_=<+M#Mvd8LlU-&L_dg ztLy={6&>D}hPi5+hJgAQAHp}>6C++`2N49wosyL@EakS8*hvLEE|Ia}v1luH{7d95 z9M%;J4*wRy#sB=r;JI% z`~EmdCt`7uE{#RRI7tk;_J4|#WPZKtnePph1bO%Y&MW;;_a5ZJ`BO$?yL)2`GPrV3 z_nxd1#E@_pj=<`G?0g`2ooz!b!o&v578r1{7lKh3H(&#XVM8n;#RiE;fy2I(Z381x z47bU#L70}YAn2=AqDPx$r4|-gG8hF`efKQ?PV@)yeo9%+Q}Nzy7=@;)(XenE5i>uf(PT0V$JD0ls9PP?{o8)j?OT_o zT$cN^fD5Z65lk21!nk@zBE)lSnHWW4R*^0~n2%Kh5l!L3Wjlc+&4k&I=et^ShiMaM zj~`G!^126V)`g-k57N7qEXW$9T{d<24S9JDnVCPjb8Ym~a@4L)_b5G#ebmTck(}0f z)S7iP+kZ6RJZk;c^zY20+27`^D^B*Sq_q1AJ@?5uoyDjiW+P;i1dVX`_+%_BixFfL zT&{iBNXmndj`fb7HAWbq>Ks#My#8WMkAtg?CPvI`#JHxAmEM!>ED#4k?~<7kLAD3^ReWKYrn4{ljP(>@TysV(5juz-Jy~* zcQ`$dB)@9>nO&FVK(ug+#b)|Jn$LfgoRx`HL+4UzvGuxZW|JkdhU=PT7#+PZC z!NJ+SgSno*=7ZL>r_)2pPxjJy{8rhzUXK)8EBfZ<6z3IU=1z}YB9?yHg?_Ww0)r<_ z6_(_b)gIbYagNbS;|}te&S&@8Q-L*@J&OpA3hrQ2_MB2j*AOG?U~|qjFQjr4P6fwE z74Rg)7iiYwEN{)OvtM>o(j3Q~t_ALeo`v3pzJ>ldN%OK6W-rWHn7c4U4<24-d1!~}?K8a3ybb7EUbaSK+Fg$ik z%gkTCm94v?y6bbD?D2hlQ1s#Kw|+UZ<(5f1ru}F1?LG&q*J|1yt2gw~2A-(ffpf^_ zO#V}QLu&uL?Ea|@?QczG^lrB z%qF%*$^K5UX~m6*A+rku%h+i7d$vZ&Lt_8G-4*3UitpbQg?Fd&6busTd=&BEcXvyn zgP>=~>~mtfl<@;Btbu05o-y4?dKa272ZebbOeE@uE8Q7P{b23~+fGCgy%Sdr@$-XG zGMCCW!z5xA`aI|_^q>XWTCDA$Ex5U72O2gTy2&Pv$<|93rA&_sWJ@*(W8bK zZdUL3^ykJ?(QlzOUIC6r8^6SQlDmUB$sV`f@4yl8dP|Dq4TJxU49l6`9?gx@i6^9* zCs+{}B(5x|(rWRe0@f`Ty(emW>0!W$+Fp8i@HUS?(t;wb~-AHP1Eo70Mia&dMz=% zCWteZaDInGX;<3+znI3RZU3(V?c7HHeQWKB=}7@Gh~bA0?zfoxgI#z6X!U( zMhoxx`R9Uj`06yZ7k-4xjNifwcP~~}$uW{}!pUNmJu$@Y;mDiRzjV-@z~`mG@)C13 zm!=Q;g#{c2VS-**bY7;F8m#E(aWCF8uN_?b+;eM<-$qYu-Fi{Y9*o6~KLe)#4?u}o zF){C;M2w^38)pH~p#yfjwBY}HMbRhpm@ig7y~mWTa`o9Jsc78E@C@sD5Kac$)~!*F zR)@hJ`xz83#Kn))uhq+{cWl*C?9}f77LiqHN270RRmsn- zUfmq6GtP|Os>|&9bpFnr%f&VgJ=N{YU$C@`8za3apJ?P$sdejb{NSAJ=@x$0CM5JEA zxeA$=a5ox1{4;GY9a#&iM-#E?T@~ z>0NiWBCL=z#}UKeXoIwU0ddt(Z7B4u`=i`N1F$$YzY2zb)V|i%$irr!bvt?-7;9A5O+ z%C#%BaR_C(Olw5mH+AnbuOE49m{*tUX5MMYt6_!(TVT4s!S{W9H+N$c-hE~F>~4ho zSL)oUa~~@8@lQW~;NuA&&6PWUTl}}%l=|yGjJrrYncYC78Z4!e4_5W@b0+p%>!GNY zt#K|$8y-*bJM}Aci3im0)lb#m)q_}Tu~z+3wWw!7^oOx_~?@Cy7)J*3`% z6@C({0b13+P}(=@8Px_qL0E-Uow`FctLf@(HADSLy`}c5chsNNyXp%yQyozI)PA)^ z%~JnR>(pU&P#sdURVUV;txS@&k>a0|&)N%Enh``f@Inmgs8>@r-{tHtB9!*zYQv)n;ir*41=>Xm}=eZGKzrl>3Iyn0}|E(~rjQzG|U9PgUbt z$nYBQwN_2Q-yw2ss8kb;STL>IiYOzpa2n;a-O_fnTiTpxlhj}8^u1ryQR;W$7ximK z{lfVE4d1U5b(8vC_?3EH_(j`m@O=aH`JK=R*Ha9yYL&R&XvB%pFitY!-y(y8-Kx}k zQg5{10^H9uwW^~DTCzPUY8>*0uo7mrak@&wzN`&~SGqp|Udr?xYAL?cOuf_?^M`2L zXKEzq|CsO|^QNhx$eYFM$=zr0d?UWQ!5=4ZUnOuQG`Bp4ZyDMK9>#NJC_tI`f+yv> zRo;PB(I(;@wAUs?*Wevf^_5t|R;hNQZDsOB{u=Tz@=1Q%YoMplLuirsi)--TGvL1{ z{+jR|B6Uc7$!o%I_zIuko$`GJ-^2KZfw%Se`xXA?;qOWOy%v9W8=AWROLw)>fp=C5 z-w1ySj|hK&?`@drR2N8a8k?J{k{Sy@$T4Zc(HtuyadYvSKJ=`X^I(qDSs3*I7M zC;rOwc>fi=qAu^nX^T3;G*qxh@x{A`;VenmH>vUP!`zIxV3X8jbql=6x59sXo0_Je)S(lm zs~M1uvmo#1K-SNLoSzR#zYtP>G3ESSkn|$wmqEtYs|LvUM#%RjB@+IJ&_1G@9)x^; z2)g27=%z=YiGB>MHA9m;4&4Ol3(fU2$nBp)V*f&IfcDy`HbIv>4ej(R^{o1}dQSaD zJrAAMs(!0}2aOeiE_y+|s6;1-77&f_s@ef<(yp)-S-q}ysXt&9z#pOS_CQCx2@Urr z=()Gl+i|V7ml{p<*kS0L_n=`uh-;gp&@~@H_k5!MgL>#Q^*QwF7tmv!&{!v+v%Z2B zJV~AUFKE!O)hXyL(OPGrt3{i2YcS~~DlxoQMpzPN9BE^PFU<~@rPI1}=3TRwFPc4L zfosu>C36-|zhlONyJjqzG2L+0-Afi4?-)3ssz%_za>C09D+ntI2NG5j4kD}}+vS2= zccRdbR+^Roi$T2K1JZ0Esc+2oNL~FRp_(PM?bf4)H^R?#f=5v-Amc5p* ztjX4K)}_{vEz96vkn&M#M(UNRD^tHsOHR8t z?Ij%XI4=F^^!GDXXY4@~vS0SviF2gx&H5tymh2_j|H7iJ;W_`2^N*Z!xz^ldOgNS2 z4$U2%dvose+{L-~<*vOey(Q$(McW`yT8!qTgfv zUMwA3y1Bor|G56GWvk1tDF6Ls#>;Xp8++N_ijfud6(3bzUAYMV8Y>^J{8{Da1L_An zHsDtS_7CW;%B-rXnpL%~YGc)JtM(4OW#CT+{<-?f>Xz!`gVdnRL8EKjHJLTVH3Ms| ztQlK#Yt7u6dux7Fv#w@i&2MX7t?8&aQ1g$$nS&b!Zyx;F5X+FMLw-DD&ycTcb8By_ z{Y~w*+TFG9)_zzU9eT&*LoOeA`S{D9y8Q2#cMZFJ*rUUa1P2GN2~G*l57q})2cHN& z9SjBAgMSJh4*tg#!7Cm-)!&`^{`^wv{+5r8$_4*?GDZUY?By&kZ(+X*OhwI0YIff8-e1L;!;IG)#&x+A!r%n^~2#Fah>=tY`*)r&A6@5xt%ye=WEARIs_KJk2D>~=u0 z{E@o55pZyKGay!70oL;A)lB~b!jXidK(%}|j@LI4-b^@=xh4Vs`D!xopO0vKcLUb3 zCexW_7U68BT*&K1go_E65H2NLPFPRaK)8aik?=mgp^0!M;VQxw)(z8TD7TH}h6uMX z*Eaan^3}`Th&O{Ma#FW;wy^`8l@A#$7>f|@WBUDs2M7=Horeey6JoT5^qqXealY*o zQ=aDiv%Ee>*hPqAwxLV0+De-LgA1? z)Isjo@w$cAQhFh9D^Ej&+X!FA??T{Hp311G5cm`rArxE{0$1`>@KeOHu#*ROiokmU z2lKwPx(K~b?nsG6N=ht3ZxR?H+y-th0v#iO(&{4Bfxcg)!h9Mbl$I8=lw#$LZpU>m zP^uUujsO&F7lZ!=j^Leb7yq?JWQ<$cXa1P;I!g+*u63!=FK)8sx z785QZTuQi{Z>}e7AY4J%NO&L9G!d>OTt(Od%oM}=5ZK1|hX@4^#jro*{!ZTM!1|tI z;6d6LAr!h7tK+;DikA>4C8Tl*Ft8nW1oI`J^?E>|bqO(FLd=(t)+MBM3Ha?Gp1w@j z&h#CiLJ4VILRy!A%IhJ!g_rtLBK3tuDc919zHCKbyk|SEUj{$-1?{#&%6kZfA4*C6 zQr4lAbtonEOG*7w<}GF3Qsiw$dZBwM+Is|g!qZ(0DDUZyUe*j)K`64WzZ!(v_Gka< zkM?fI^$4aMi8}WO-33l0oC50iXHEK}56XLH5zgit<}lY>!g+*u63!=FK)8tSSxmTu za4F$(!g|66!WD##g!d6P5w0X$Mc4xQ+@IL%Pi*ujHu|eAtkpJPvOjUsADkdHZ)fYI zC-x_P`p5CJkLmXl9w0o(79AoyOxVf1$N8SKOw$Ee2HYN@q=cIqSltd-9sL||5NcS4 zUYrFu7@St7YNICsN1*gF?9rE8;|M1bN^dFyr^$O}@jbKohB-_x-l;NJ`U3AHoKJ{J ze%uj#fsrQR5<<}zWlHo#nG$_bhIkGFMPHOD(HCXvKEfu#m4vGZg(u61)iUt8)F(u^ zg|*riy&b<^?vgf2|0+}MY?olQ3_LICBZT{yem~&>!h>wlA;QCioy;peu>!rL2G9#x zT|s?aL5_uGgIZOTpays8IhbiY0&Lg~&a6aJz z!bQxxm~aWpw|dMFYN7V&?^ftA6lat^m+(Ttc7Yd zBH9Lcb@W-lk%ZTRvejxFug6CZ;(7wpOpHcwJ(<^2(C@0zN91kO`L;Q{KbLSG;hlu@ z2^SD9 zau+F7LuV`Q2x}=Zm*%;UPHUR29{d{(pe5TL%L(+X1Jb^ufT4q@Tm|a|!1W-bpy0 zZ~@^WzF{%p62hf~%L(fV8wghrHWJ>)vYH5260RZ?i7}W~++g5Du0w>|SSztz2Ll^Y zL*cibP7Wb=4MES6r?dD}`j`dUhlT3VsCv_fkkJwC_%k$ieB@KX!9At@(Hc3 zIZQv7a30~Eg!2g(5H8{y785QZTuQi{u%57ia0Ou_;e9NziEt(1D#8}Xy;{&qS|swJ zmhz#Nc4jT`(~LV}Z`6`rwUiIFln=GQk31FIvKHJcP^`yVj4qque-Z0(C^hC#;(sXK zCU@j*LxJrh@DbkvI0`A70llchC~*6BK=Ck)f>%MH@bf6pQSOT-8ik&91)%WKDDu)M zye)uh;h!1O0a3!JmdB&6a zGSg2c2Tlggi!qNOezRM^b-Mw_5sJU-7VwhX zSxmTua4F$(!g|66!WD##gy)!7JV;a6kETG*$aODp$Q0IO3TrZjHJQSiOhL^LLNbcw zUq_y)BlYVbOQ9(tmyQ6I5Q>JaQv(Ra)~bVamH8JL9l(DF{;7kF+6*YZ!8%x~@>JSb zM=q*EOXXU8gLP=HTno3(!y($sHN%)p4v>$FW`=$9i=f>(z0rSBKdjd4upw9eJh>GeL4K5~GehQwPZ} z<%(~xj@r3SiEpqD6xRcaZ?F#IDQTnl2J4^&Bqc2j>gYP^=sN1?I;=;K_sgiEj-!S; z%-qPe_y+4Bh2(AGbE~7xSqG^o*Fw`edfw`kP{pI zbZV~Y)Lhd^@#&y=A<~HdZ94sL)2X?pQ*%vceWug@Hl1~tg|c8Lfh*boMJCLGwh|~K z&{-UT&O+(UxE5dBES5ft*qa5tAa}$UHw)6{AfU+bSsa1R0{@S|wfJOaK`#iD5$J5T zYc_4d*|Z5~qxA~+#g{mnZJEtF&t{!x(6ha@yKzS(=W^y+&RolpYdh|Ut8x(tAV*1m}>=dtzfPd%(a5KRxsBJ z=32pAE0}8qb2TzoBXcz}S0i&ZGFKyWH8NKtb2T#88s=KVG;5e<4bn7YhEy=N25H(b zhanhlW}0TEX+|2k|1$8|j5P90tg;r&;~W7LdD5ba2#a}NWJ?P?e3GV=*D{aOf*vJM z#&<0kVGEQ|UJFK(0;~CE85g%e=ExgF=Cptt=K&7owP>prXhnhJ2*(pnVtTO?T4*P< zkjGjmVOqe6l71QCa>9DT2ErADjf86mn=vokLjG(af3{%WSKc7@Y74ks>LXt67IJJ0 z=5*y+#+xlzvm{XFaS*VGu#@S3+fkgo4jj;b^GWzBcNb^GWzBcNb^GWzBcNRmy04A8 zuZ_B|jk>Rmy04A8uZ_B|jk>Rmy04A8uZ_B|jk>Rmy04A8uMK#T_lxe6H4Fj;|83NL zZRpo}T#N2&11+SDqWjvY`(%}#q!)^`QTMe`_q9>?wNdxAQTMe`*R)ahwNdxAkR7|+yp|b_ zZE6`)E@!TK!Un<>gpGu2Sd-=`G_-2t8$yIK`>+l471+-Dgn2(gD0275)wv?IL} z^$^cSJ3Sli^lY?)7R|UL^K0$&Y_!v}(GE}4cH9xqMms$l?euK4qX$V!nMZ4#k0`?NhNdMqP07SlMe8wTo)4xe|D(8gr(@G9jZUC%LoN~9jcPo z19)Asl7tclq_*38{w6_Bi3_co2FnPat z&O3Yx?WLH_JeolGzO{|@k{ykGdUgZS(qKEu=nVd{b~B}|yQ0A--P zVQTF#bwQZAAWU5lrY;Cm7htpoT@a=&2vZk?sSCo?1!3xfFm*wgeLPHE5T-5&Qx}A( z3&PX|Vd{b~bwQZAAWU5lrY;Cm7lf$`!qf#}>VhzJL72KAOkEJBE(lW>gsBU{)CFPc zf-rSKn7SZLT@a=&2vc%~sS9MCJp9Gf1z~FKFm*wgx*$wl5C$$~Zc;|9Vd{b~bwQZA zAWU5lrY;Cm7lf$`!qf#}>VhzJL72KAOkEJBE(lW>gsBU{)CE{G1sNV8r6QzMgp>jw zfKpf&Kq&TAgp`VqQkWG%&x(*zuqr?)c(}n25mG8bN<~Pi2q_gIr6QzMgp`VqQV~)r zLQ27x1L++hr6QzMgp`VqQV~)rLP|wQsR$_*A*CXuRD_g@kWvv+Dnd#{NT~=Z6(OY} zq*R2IijYzfQYu19MM$X#DHS25BBWG=l!}m25mG8bO3CgAc>nQFpx9RtQYu19MM$X# zDHS25BBWG=l!}m25mG8bN<~Pi2q_gIr6Q!%K5FfK)Y|(3_|QETs`*4{_0 zy^k7UA6vAKT6-V0_C9LueUy{?sI~V|Ywx4h-bbyyk6L>_OWe;A_p`+PED@{R(8m2N zaX(Ak&l2~u#QiLBKTF)t68E#j{VZ`mOWe;A_p`+PEO9?eJirnUu*3r_@c>K2iaL~d zfF&Mai3eEX0hV}xB_3dj2Uy|(mUw_A9$<+FSmFVecz`7yV2QHkPJu!)&vlSCgLvBH zT6`J@!2<$igebj4plIqt%yo#l4l&mu<~qb&hnVXSa~)!?L(FxUxehbeVdgr_T!)$K zFmoMduEWfAn7NK2S0Ok?=2eez{CJGx?qeJw9%FwzhWALC=}aSIKN( z5ea_`Zx$%y++!T)9^*Lo7=FnenO8kVK0L;G)nlAj{fzd;XBg=!XaX67dyV9WSTFL=2_ekkHnWqvmNW7#SZDD9nwiVq?2|?Cv|Qo?T}8|A)T~C zI%$V=(hljQ9nwiVq?3BElX|d|c1S1fkWShmowP$bX@_*u4(X&F(n&j{lXgfa?T}8| zA)T~CI%$V=(hljQ9nwiVq?2|?C+(0<+993bx-7Ip?2t~{A)T~CI;mAV(duU07tD0h z4(X&F(n&j{le)E&y0w$KwUc_YlX~+w@qCLh%%xCdZy8$DSs~ zo+ihhrdQ`QIrcO;_B1*6G&%M(IrcO;_B1*6G&%M(IrcQlmp7j#JWJRGc$O_a%a)#H ziD%KqBe*YZJj*toWgE}3jc3`$v&8UOdScI_jgnqg3Y}#e&$5kYS?*c1RGvz?T`a4M zWp%NvE|%5BvbtDS7t88mSzRovi)D4OtS*+-#j?6sRu{|aVp&}*tBYlEnrkiQe>Fg%G-eS<{3@eq|;!)Y7C7*nT&$(+U%F8~B^C6;1+IsVRP2>j3 zCdEV=#0+ZQa2r;tcQ-2)Lxa$v=vapmO-FXJZ(FYzF@ zKQ<`qabTzw2TmJ|7W~kgdOoO=#bUIX%!rf&fJa6PF7eMO(1>U_28+?i^vI^y8}(NC zfujZxh#C*Dd%=R7u@_wM+6xPj{PMM0twy88YDSUBgPpHbf8is+@bc#XwiFrXkaZmXB!+8-sAL0YQY&IM4VH0%V6h%bhlZqm?i4oMoTaW-~wb*S&Btyl3u=DtE z#;^cR7 zNOJ@eF??9fpdtQQ&1OjsstL=OkqxNCes+9}_$B0&zetAEIJ<-&;S{7x&{2LdKknP@ zcJP25)C2wSM!~1iVh1UuBqWqqBTADA$xy7|!z`5*CUMJ)_+Dg2Z7<+)lO9zCPFYE- z)EEU>&A4j;$>a?&%7B6jQRuM`9h_nV-oaxgo8TjcVu1z&aA|Vl3hl941s^t)Cp>~< z7J(RW85lxX#)52kuD44*^cD0#v*aSZjxyp=C(iW@JX+kno3~1D$ug37<;j0ACf=$%4hx^cri4QsA2Co5c8Bq{u zi>k;!G&hzOoU4@6Yau@D7Ka`9Fx$cD7vTfAG&@lM>H`kKOYEqu4Ryr<9ylN#_=xqU z9()M$h!2t!_z;4l9Im6K9Eq-CFm%>&FOc~ie1L#PkOk!k3z|@n-KqzXgs?_~bVYoCUxkqERweSxX>-}Z zV-}}~AYzz+xU}FHLLdP>7udHr?GCF0C%f2fZUD$fFobj=w4C^GOU2MJtrif$0^#RG zZmXPO!_W8NL%0}06s$M`54^j#j0Uts!2ad=&|2fas zk~oeJo5uqw;PePOfB*~dj#@fAc(dRGRQI4O;lObVlA&T~o!|p0fscS494Oo>odGDh z03TKZDr+^eHa6k|1>uNO5DEXFzAnUvH%0Jawz%vbCpwVT1=VCi1L7a@memUuMt$U6 z4yzlLbs`j>)9!QH9N;o=G3o@dYeV0(8NI@;5LCiHXq3tB0y6DvA{#G2>MhB@cKDzZ zpk8*n*Xu=}@HoNF$YX^h5t#veAnY^VVzYUX*y;0Hk<4gxp-53?U_PVKn!*Z;U=(aR zofq_Z8^jNUvaqSmCSB4Dd^l|;x$6*h9_L*2CZ&9-cANuiwz%zHCsdc!4IO+|{0Cvf-zKDY}>0(`iDUj)F$TaW;Baryl?LKt$xjXo&&KuUC)R0og_Jxl_k zuuJgaw3;B7PzI!r*$l+HP%(?s>a;?gUx*KXy5IvxA~<|5;KSw-e274ceM~rM+hg+s z;i!*W@L~730W(lm-ZwS z02FxK;6}UG?QwWqPKVnCe7K-Ly=afq?sOm<@MTIu&72TbNQw4BIeL-XiNkVZ7$yeD z*ZeKTKscc1Ih{#KN$3+v9+1x~oze}NWp(=jLQln#Qi`ZfIgArMUg%*hsy&gW%DFC?G~RCZ$Sbi_a-OXk<4uN0gDFWLpn`n z4?ciQ!3VjIzyTs6RB=pB`+UF$5HI+U&`S=OHzM%y0jDXI+*|NrwfS5DFH~0yA0TM_ zgJOL?M=}cVx`123hoAUxIX&)VoRbWlF8Bba;0Sf}C#NYHHFH65yIeqo!)12)go8ca zSbe@99}r2%l#Hg@eF5SFcidjlDc%4y6W-(lK9eC@ys61{Btyj@#SD<;z$Ng}8z(kP z`QRI`7c6oSKJYGw8Pq||L_}GEc&`frMeqTNp6|&@rDP#GKTIFLJJ|<(IQ(M5q5<&_ zdCQT40#F~H*KBq>K|hzz<92y*7>vsUo$iM$krSkmjrfr63kBzP`GF4@3x45XuTQ!S zKI90gw>wpxLBpBo*>1Lf|vNKcXv>%*Fk#rs(X0ywb3QD;# z3URxW+(47XorK(OpFdWg7(T=t{0=_csi~=u5h;EYiL4F}x(M)*;&R&XGYQR21wQ=g zsSYGV#ehWvR60_^O3CiQ2apMrm}6}eNPIXge&Sw4lnsdY3qH{C!QqxTJ|NYVO3TI3 za2A^*;7Lt_Dt871A0TM_W3hm@oM}L~-vitNAFgD7k~_)kar?Y!Ubh!gC;(XkPH|g3 z9^k_)Sn|M}^bjA2M;Q((^pTN3u7K_(+za2pSOokhfgvC;;?HO0rnIf)7s;LOc6?={}DS zhG{a|gExDuUew2JP6Io55$fOL4xsfgo|2Ip_>gXck4pgYAs75Wd4Nt{PkMSfWJFpL z*f|+@d`WH>_$A%rvf*bknwt*Ml9ZX@L^6vd87MSBx5e<0hq_Rg3PXcMF2IM|?1d=9 z;RzrVq%rUT#3vyfD(?DFLD63FAwDwlJqlvfk>X7cz_f9t$S@#*4Y3!&TdoXr>3|oS z4yxOok`(X+{2-Js!|(OOo=Abv2d8*#qRTv%bjb~Y?!|Fa9>GV7&*%3h1(ITKMMCO4 zOYEmW$q#|+&B(}rj7UcaxRey!0SQE>WWaX9&lE_74B#WsE7OH!s2HdKV;EK~ez@{| zkWivag`t5G2=~Otjh6deR zx*