From 25d036f8facb2888b785ce7a4269400a4058b3fc Mon Sep 17 00:00:00 2001 From: Diego Capusotto Date: Thu, 16 Dec 2021 17:08:33 -0300 Subject: [PATCH] Added some preliminary support for v6 SCHs - Currently just loads the files - No save implemented - Seems to be enough to generate some trivial BoMs --- kibot/kicad/sexpdata.py | 685 ++++++ kibot/kicad/v6_sch.py | 1123 ++++++++++ kibot/kiplot.py | 11 +- kibot/misc.py | 1 + tests/board_samples/kicad_6/deeper.kicad_sch | 68 + .../board_samples/kicad_6/sub-sheet.kicad_sch | 455 ++++ tests/board_samples/kicad_6/test_v5.kicad_sch | 1845 +++++++++++++++++ 7 files changed, 4187 insertions(+), 1 deletion(-) create mode 100644 kibot/kicad/sexpdata.py create mode 100644 kibot/kicad/v6_sch.py create mode 100644 tests/board_samples/kicad_6/deeper.kicad_sch create mode 100644 tests/board_samples/kicad_6/sub-sheet.kicad_sch create mode 100644 tests/board_samples/kicad_6/test_v5.kicad_sch diff --git a/kibot/kicad/sexpdata.py b/kibot/kicad/sexpdata.py new file mode 100644 index 00000000..72dae5c6 --- /dev/null +++ b/kibot/kicad/sexpdata.py @@ -0,0 +1,685 @@ +# -*- coding: utf-8 -*- +# [[[cog import cog; cog.outl('"""\n%s\n"""' % file('README.rst').read()) ]]] +""" +S-expression parser for Python +============================== + +`sexpdata` is a simple S-expression parser/serializer. It has +simple `load` and `dump` functions like `pickle`, `json` or `PyYAML` +module. + +>>> from sexpdata import loads, dumps +>>> loads('("a" "b")') +['a', 'b'] +>>> print(dumps(['a', 'b'])) +("a" "b") + + +You can install `sexpdata` from PyPI_:: + + pip install sexpdata + + +Links: + +* `Documentation (at Read the Docs) `_ +* `Repository (at GitHub) `_ +* `Issue tracker (at GitHub) `_ +* `PyPI `_ +* `Travis CI `_ + + +License +------- + +`sexpdata` is licensed under the terms of the BSD 2-Clause License. +See the source code for more information. + +""" +# [[[end]]] + +# Copyright (c) 2012 Takafumi Arakaki +# 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__ = '0.0.4.dev1' +__author__ = 'Takafumi Arakaki' +__license__ = 'BSD License' +__all__ = [ + # API functions: + 'load', 'loads', 'dump', 'dumps', + # Utility functions: + 'car', 'cdr', + # S-expression classes: + 'Symbol', 'String', 'Quoted', +] + +import re +from string import whitespace +import functools + +BRACKETS = {'(': ')', '[': ']'} + + +# ** Generic errors + +class SExpData(Exception): + pass + + +# ** Python 3 compatibility + +try: + unicode + PY3 = False +except NameError: + basestring = unicode = str # Python 3 + PY3 = True + + +def uformat(s, *args, **kwds): + """Alias of ``unicode(s).format(...)``.""" + return tounicode(s).format(*args, **kwds) + + +# ** Utility + +def tounicode(string): + """ + Decode `string` if it is not unicode. Do nothing in Python 3. + """ + if not isinstance(string, unicode): + string = unicode(string, 'utf-8') + return string + + +def return_as(converter): + """ + Decorator to convert result of a function. + + It is just a function composition. The following two codes are + equivalent. + + Using `@return_as`:: + + @return_as(converter) + def generator(args): + ... + + result = generator(args) + + Manually do the same:: + + def generator(args): + ... + + result = converter(generator(args)) + + Example: + + >>> @return_as(list) + ... def f(): + ... for i in range(3): + ... yield i + ... + >>> f() # this gives a list, not an iterator + [0, 1, 2] + + """ + def wrapper(generator): + @functools.wraps(generator) + def func(*args, **kwds): + return converter(generator(*args, **kwds)) + return func + return wrapper + + +# ** Interface + +def load(filelike, **kwds): + """ + Load object from S-expression stored in `filelike`. + + :arg filelike: A text stream object. + + See :func:`loads` for valid keyword arguments. + + >>> import io + >>> fp = io.StringIO() + >>> sexp = [Symbol('a'), Symbol('b')] # let's dump and load this object + >>> dump(sexp, fp) + >>> _ = fp.seek(0) + >>> load(fp) == sexp + True + + """ + return loads(filelike.read(), **kwds) + + +def loads(string, **kwds): + """ + Load object from S-expression `string`. + + :arg string: String containing an S-expression. + :type nil: str or None + :keyword nil: A symbol interpreted as an empty list. + Default is ``'nil'``. + :type true: str or None + :keyword true: A symbol interpreted as True. + Default is ``'t'``. + :type false: str or None + :keyword false: A symbol interpreted as False. + Default is ``None``. + :type line_comment: str + :keyword line_comment: Beginning of line comment. + Default is ``';'``. + + >>> loads('(a b)') + [Symbol('a'), Symbol('b')] + >>> loads('a') + Symbol('a') + >>> loads('(a \'b)') + [Symbol('a'), Quoted(Symbol('b'))] + >>> loads('(a \'(b))') + [Symbol('a'), Quoted([Symbol('b')])] + >>> loads(''' + ... ;; This is a line comment. + ... 'a' 'b') ; this is also a comment. + ... ''') + ['a', 'b'] + >>> loads(''' + ... # This is a line comment. + ... ('a' 'b') # this is also a comment. + ... ''', line_comment='#') + ['a', 'b'] + + ``nil`` is converted to an empty list by default. You can use + keyword argument `nil` to change what symbol must be interpreted + as nil: + + >>> loads('nil') + [] + >>> loads('null', nil='null') + [] + >>> loads('nil', nil=None) + Symbol('nil') + + ``t`` is converted to True by default. You can use keyword + argument `true` to change what symbol must be converted to True.: + + >>> loads('t') + True + >>> loads('#t', true='#t') + True + >>> loads('t', true=None) + Symbol('t') + + No symbol is converted to False by default. You can use keyword + argument `false` to convert a symbol to False. + + >>> loads('#f') + Symbol('#f') + >>> loads('#f', false='#f') + False + >>> loads('nil', false='nil', nil=None) + False + + """ + obj = parse(string, **kwds) + if len(obj) != 1: + raise SExpData("Not an s-expression file") + return obj[0] + + +def dump(obj, filelike, **kwds): + """ + Write `obj` as an S-expression into given stream `filelike`. + + :arg obj: A Python object. + :arg filelike: A text stream object. + + See :func:`dumps` for valid keyword arguments. + + >>> import io + >>> fp = io.StringIO() + >>> dump([Symbol('a'), Symbol('b')], fp) + >>> print(fp.getvalue()) + (a b) + + """ + filelike.write(unicode(dumps(obj))) + + +def dumps(obj, **kwds): + """ + Convert python object into an S-expression. + + :arg obj: A Python object. + :type str_as: ``'symbol'`` or ``'string'`` + :keyword str_as: How string should be interpreted. + Default is ``'string'``. + :type tuple_as: ``'list'`` or ``'array'`` + :keyword tuple_as: How tuple should be interpreted. + Default is ``'list'``. + :type true_as: str + :keyword true_as: How True should be interpreted. + Default is ``'t'`` + :type false_as: str + :keyword false_as: How False should be interpreted. + Default is ``'()'`` + :type none_as: str + :keyword none_as: How None should be interpreted. + Default is ``'()'`` + + Basic usage: + + >>> print(dumps(['a', 'b'])) + ('a' 'b') + >>> print(dumps(['a', 'b'], str_as='symbol')) + (a b) + >>> print(dumps(dict(a=1))) + (:a 1) + >>> print(dumps([None, True, False, ()])) + (() t () ()) + >>> print(dumps([None, True, False, ()], + ... none_as='null', true_as='#t', false_as='#f')) + (null #t #f ()) + >>> print(dumps(('a', 'b'))) + ('a' 'b') + >>> print(dumps(('a', 'b'), tuple_as='array')) + ['a' 'b'] + + More verbose usage: + + >>> print(dumps([Symbol('a'), Symbol('b')])) + (a b) + >>> print(dumps(Symbol('a'))) + a + >>> print(dumps([Symbol('a'), Quoted(Symbol('b'))])) + (a 'b) + >>> print(dumps([Symbol('a'), Quoted([Symbol('b')])])) + (a '(b)) + + """ + return tosexp(obj, **kwds) + + +def car(obj): + """ + Alias of ``obj[0]``. + + >>> car(loads('(a . b)')) + Symbol('a') + >>> car(loads('(a b)')) + Symbol('a') + + """ + return obj[0] + + +def cdr(obj): + """ + `cdr`-like function. + + >>> cdr(loads('(a . b)')) + Symbol('b') + >>> cdr(loads('(a b)')) + [Symbol('b')] + >>> cdr(loads('(a . (b))')) + [Symbol('b')] + >>> cdr(loads('(a)')) + [] + >>> cdr(loads('(a . nil)')) + [] + + """ + # This is very lazy implementation. Probably the best way to do + # it is to define `Cons` S-expression class. + if len(obj) > 2: + dot = obj[1] + if isinstance(dot, Symbol) and dot.value() == '.': + return obj[2] + return obj[1:] + + +# ** Core + +def tosexp(obj, str_as='string', tuple_as='list', + true_as='t', false_as='()', none_as='()'): + """ + Convert an object to an S-expression (`dumps` is just calling this). + + See this table for comparison of lispy languages, to support them + as much as possible: + `Lisp: Common Lisp, Scheme/Racket, Clojure, Emacs Lisp - Hyperpolyglot + `_ + + """ + def _tosexp(x): + tosexp(x, str_as=str_as, tuple_as=tuple_as, true_as=true_as, false_as=false_as, none_as=none_as) + + if isinstance(obj, list): + return Bracket(obj, '(').tosexp(_tosexp) + elif isinstance(obj, tuple): + if tuple_as == 'list': + return Bracket(obj, '(').tosexp(_tosexp) + elif tuple_as == 'array': + return Bracket(obj, '[').tosexp(_tosexp) + else: + raise ValueError(uformat("tuple_as={0!r} is not valid", tuple_as)) + elif obj is True: # must do this before ``isinstance(obj, int)`` + return true_as + elif obj is False: + return false_as + elif obj is None: + return none_as + elif isinstance(obj, (int, float)): + return str(obj) + elif isinstance(obj, basestring): + if str_as == 'symbol': + return obj + elif str_as == 'string': + return String(obj).tosexp() + else: + raise ValueError(uformat("str_as={0!r} is not valid", str_as)) + elif isinstance(obj, dict): + return _tosexp(dict_to_plist(obj)) + elif isinstance(obj, SExpBase): + return obj.tosexp(_tosexp) + else: + raise TypeError(uformat( + "Object of type '{0}' cannot be converted by `tosexp`. " + "It's value is '{1!r}'", type(obj), obj)) + + +@return_as(list) +def dict_to_plist(obj): + for key in obj: + yield Symbol(uformat(":{0}", key)) + yield obj[key] + + +class SExpBase(object): + + def __init__(self, val): + self._val = val + + def __repr__(self): + return uformat("{0}({1!r})", self.__class__.__name__, self._val) + + def __eq__(self, other): + if isinstance(other, self.__class__): + return self._val == other._val + else: + return False + + def value(self): + return self._val + + def tosexp(self, tosexp=tosexp): + """ + Decode this object into an S-expression string. + + :arg tosexp: A function to be used when converting sub S-expression. + + """ + raise NotImplementedError + + @classmethod + def quote(cls, string): + for (s, q) in cls._lisp_quoted_specials: + string = string.replace(s, q) + return tounicode(string) + + @classmethod + def unquote(cls, string): + return cls._lisp_quoted_to_raw.get(string, string) + + +class Symbol(SExpBase): + + _lisp_quoted_specials = [ + ('\\', '\\\\'), # must come first to avoid doubly quoting "\" + ("'", r"\'"), ("`", r"\`"), ('"', r'\"'), + ('(', r'\('), (')', r'\)'), ('[', r'\['), (']', r'\]'), + (' ', r'\ '), ('.', r'\.'), (',', r'\,'), ('?', r'\?'), + (';', r'\;'), ('#', r'\#'), + ] + + _lisp_quoted_to_raw = dict((q, r) for (r, q) in _lisp_quoted_specials) + + def tosexp(self, tosexp=None): + return self.quote(self._val) + + +class String(SExpBase): + + _lisp_quoted_specials = [ # from Pymacs + ('\\', '\\\\'), # must come first to avoid doubly quoting "\" + ('"', '\\"'), ('\b', '\\b'), ('\f', '\\f'), + ('\n', '\\n'), ('\r', '\\r'), ('\t', '\\t')] + + _lisp_quoted_to_raw = dict((q, r) for (r, q) in _lisp_quoted_specials) + + def tosexp(self, tosexp=None): + return uformat('"{0}"', self.quote(self._val)) + + +class Quoted(SExpBase): + + def tosexp(self, tosexp=tosexp): + return uformat("'{0}", tosexp(self._val)) + + +class Bracket(SExpBase): + + def __init__(self, val, bra): + assert bra in BRACKETS # FIXME: raise an appropriate error + super(Bracket, self).__init__(val) + self._bra = bra + + def __repr__(self): + return uformat("{0}({1!r}, {2!r})", + self.__class__.__name__, self._val, self._bra) + + def tosexp(self, tosexp=tosexp): + bra = self._bra + ket = BRACKETS[self._bra] + c = ' '.join(tosexp(v) for v in self._val) + return uformat("{0}{1}{2}", bra, c, ket) + + +def bracket(val, bra): + if bra == '(': + return val + else: + return Bracket(val, bra) + + +class ExpectClosingBracket(Exception): + + def __init__(self, got, expect): + super(ExpectClosingBracket, self).__init__(uformat( + "Not enough closing brackets. " + "Expected {0!r} to be the last letter in the sexp. " + "Got: {1!r}", expect, got)) + + +class ExpectNothing(Exception): + + def __init__(self, got): + super(ExpectNothing, self).__init__(uformat( + "Too many closing brackets. " + "Expected no character left in the sexp. " + "Got: {0!r}", got)) + + +class Parser(object): + + closing_brackets = set(BRACKETS.values()) + _atom_end_basic = set(BRACKETS) | set(closing_brackets) | set('"\'') | set(whitespace) + _atom_end_basic_or_escape_regexp = "|".join(map(re.escape, + _atom_end_basic | set('\\'))) + quote_or_escape_re = re.compile(r'"|\\') + + def __init__(self, string, string_to=None, nil='nil', true='t', false=None, + line_comment=';'): + self.string = string + self.nil = nil + self.true = true + self.false = false + self.string_to = (lambda x: x) if string_to is None else string_to + self.line_comment = line_comment + self.atom_end = set([line_comment]) | self._atom_end_basic + self.atom_end_or_escape_re = re.compile("{0}|{1}".format(self._atom_end_basic_or_escape_regexp, + re.escape(line_comment))) + + def parse_str(self, i): + string = self.string + chars = [] + append = chars.append + search = self.quote_or_escape_re.search + + assert string[i] == '"' # never fail + while True: + i += 1 + match = search(string, i) + end = match.start() + append(string[i:end]) + c = match.group() + if c == '"': + i = end + 1 + break + elif c == '\\': + i = end + 1 + append(String.unquote(c + string[i])) + else: + raise ExpectClosingBracket('"', None) + return (i, ''.join(chars)) + + def parse_atom(self, i): + string = self.string + chars = [] + append = chars.append + search = self.atom_end_or_escape_re.search + atom_end = self.atom_end + + while True: + match = search(string, i) + if not match: + append(string[i:]) + i = len(string) + break + end = match.start() + append(string[i:end]) + c = match.group() + if c in atom_end: + i = end # this is different from str + break + elif c == '\\': + i = end + 1 + append(Symbol.unquote(c + string[i])) + i += 1 + else: + raise ExpectClosingBracket('"', None) + return (i, self.atom(''.join(chars))) + + def atom(self, token): + if token == self.nil: + return [] + if token == self.true: + return True + if token == self.false: + return False + try: + return int(token) + except ValueError: + try: + return float(token) + except ValueError: + return Symbol(token) + + def parse_sexp(self, i): + string = self.string + len_string = len(self.string) + sexp = [] + append = sexp.append + while i < len_string: + c = string[i] + if c == '"': + (i, subsexp) = self.parse_str(i) + append(self.string_to(subsexp)) + elif c in whitespace: + i += 1 + continue + elif c in BRACKETS: + close = BRACKETS[c] + (i, subsexp) = self.parse_sexp(i + 1) + append(bracket(subsexp, c)) + try: + nc = string[i] + except IndexError: + nc = None + if nc != close: + raise ExpectClosingBracket(nc, close) + i += 1 + elif c in self.closing_brackets: + break + elif c == "'": + (i, subsexp) = self.parse_sexp(i + 1) + append(Quoted(subsexp[0])) + sexp.extend(subsexp[1:]) + elif c == self.line_comment: + i = string.find('\n', i) + 1 + if i <= 0: + i = len_string + break + else: + (i, subsexp) = self.parse_atom(i) + append(subsexp) + return (i, sexp) + + def parse(self): + (i, sexp) = self.parse_sexp(0) + if i < len(self.string): + raise ExpectNothing(self.string[i:]) + return sexp + + +def parse(string, **kwds): + """ + Parse s-expression. + + >>> parse('(a b)') + [[Symbol('a'), Symbol('b')]] + >>> parse('a') + [Symbol('a')] + >>> parse('(a \'b)') + [[Symbol('a'), Quoted(Symbol('b'))]] + >>> parse('(a \'(b))') + [[Symbol('a'), Quoted([Symbol('b')])]] + + """ + return Parser(string, **kwds).parse() diff --git a/kibot/kicad/v6_sch.py b/kibot/kicad/v6_sch.py new file mode 100644 index 00000000..56697d6a --- /dev/null +++ b/kibot/kicad/v6_sch.py @@ -0,0 +1,1123 @@ +# -*- coding: utf-8 -*- +# Copyright (c) 2021 Salvador E. Tropea +# Copyright (c) 2021 Instituto Nacional de Tecnología Industrial +# License: GPL-3.0 +# Project: KiBot (formerly KiPlot) +""" +KiCad v6 Schematic format. +A basic implementation of the .kicad_sch file format. +Currently oriented to collect the components for the BoM. +Documentation: https://dev-docs.kicad.org/en/file-formats/sexpr-schematic/ +""" +# Encapsulate file/line +import os +from copy import deepcopy +from collections import OrderedDict +from ..gs import GS +from .. import log +from ..misc import W_NOLIB, W_UNKFLD +from .v5_sch import SchError, SchematicComponent, Schematic +from .sexpdata import load, SExpData, Symbol + +logger = log.get_logger(__name__) + + +def _check_is_symbol_list(e, allow_orphan_symbol=[]): + # Each entry is a list + if not isinstance(e, list): + if isinstance(e, Symbol): + name = e.value() + if name in allow_orphan_symbol: + return name + raise SchError('Orphan symbol `{}`'.format(e.value())) + else: + raise SchError('Orphan data `{}`'.format(e)) + # The first element is a symbol + if not isinstance(e[0], Symbol): + raise SchError('Orphan data `{}`'.format(e[0])) + return e[0].value() + + +def _check_len(items, pos, name): + if len(items) < pos+1: + raise SchError('Missing argument {} in `{}`'.format(pos, name)) + return items[pos] + + +def _check_len_total(items, num, name): + if len(items) != num: + raise SchError('Wrong number of attributes for {} `{}`'.format(name, items)) + + +def _check_symbol(items, pos, name): + value = _check_len(items, pos, name) + if not isinstance(value, Symbol): + raise SchError('{} is not a Symbol `{}`'.format(name, value)) + return value.value() + + +def _check_hide(items, pos, name): + value = _check_symbol(items, pos, name + ' hide') + if value != 'hide': + raise SchError('Found Symbol `{}` when `hide` expected'.format(value)) + return True + + +def _check_integer(items, pos, name): + value = _check_len(items, pos, name) + if not isinstance(value, int): + raise SchError('{} is not an integer `{}`'.format(name, value)) + return value + + +def _check_float(items, pos, name): + value = _check_len(items, pos, name) + if not isinstance(value, (float, int)): + raise SchError('{} is not a float `{}`'.format(name, value)) + return value + + +def _check_str(items, pos, name): + value = _check_len(items, pos, name) + if not isinstance(value, str): + raise SchError('{} is not a string `{}`'.format(name, value)) + return value + + +def _check_symbol_value(items, pos, name, sym): + value = _check_len(items, pos, name) + if not isinstance(value, list) or not isinstance(value[0], Symbol) or value[0].value() != sym: + raise SchError('Missing `{}` in `{}`'.format(sym, name)) + return value + + +def _check_symbol_float(items, pos, name, sym): + name += ' ' + sym + values = _check_symbol_value(items, pos, name, sym) + return _check_float(values, 1, name) + + +def _check_symbol_int(items, pos, name, sym): + name += ' ' + sym + values = _check_symbol_value(items, pos, name, sym) + return _check_integer(values, 1, name) + + +def _check_symbol_str(items, pos, name, sym): + name += ' ' + sym + values = _check_symbol_value(items, pos, name, sym) + return _check_str(values, 1, name) + + +def _get_offset(items, pos, name): + value = _check_symbol_value(items, pos, name, 'offset') + return _check_float(value, 1, 'offset') + + +def _get_yes_no(items, pos, name): + sym = _check_symbol(items, pos, name) + return sym == 'yes' + + +def _get_id(items, pos, name): + value = _check_symbol_value(items, pos, name, 'id') + return _check_integer(value, 1, 'id') + + +def _get_at(items, pos, name): + value = _check_symbol_value(items, pos, name, 'at') + angle = 0 + if len(value) > 3: + angle = _check_float(value, 3, 'at angle') + return _check_float(value, 1, 'at x'), _check_float(value, 2, 'at y'), angle + + +class Point(object): + def __init__(self, items): + super().__init__() + self.x = _check_float(items, 1, 'x coord') + self.y = _check_float(items, 2, 'y coord') + + @staticmethod + def parse(items): + return Point(items) + + +def _get_xy(items): + if len(items) != 3: + raise SchError('Point definition with wrong args (`{}`)'.format(items)) + return Point.parse(items) + + +def _get_points(items): + points = [] + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'xy': + points.append(_get_xy(i)) + else: + raise SchError('Unknown points attribute `{}`'.format(i)) + return points + + +class FontEffects(object): + """ Class used to describe text attributes """ + def __init__(self): + super().__init__() + self.hide = False + self.w = self.h = 1.27 + self.thickness = None + self.bold = self.italic = False + self.hjustify = self.vjustify = 'C' + self.mirror = False + + @staticmethod + def parse_font(items): + w = h = 1.27 + thickness = None + bold = italic = False + for i in items[1:]: + if isinstance(i, Symbol): + name = i.value() + if name == 'bold': + bold = True + elif name == 'italic': + italic = True + else: + raise SchError('Unknown font effect attribute `{}`'.format(name)) + else: # A list + i_type = _check_is_symbol_list(i) + if i_type == 'size': + w = _check_float(i, 1, 'font width') + h = _check_float(i, 2, 'font height') + elif i_type == 'thickness': + thickness = _check_float(i, 1, 'font thickness') + else: + raise SchError('Unknown font effect attribute `{}`'.format(i)) + return w, h, thickness, bold, italic + + @staticmethod + def parse_justify(items): + h = v = 'C' + mirror = False + for i in items[1:]: + if isinstance(i, Symbol): + name = i.value() + if name == 'left': + h = 'L' + elif name == 'right': + h = 'R' + elif name == 'top': + h = 'T' + elif name == 'bottom': + h = 'B' + elif name == 'mirror': + mirror = True + else: + raise SchError('Unknown font effect attribute `{}`'.format(name)) + else: # A list + raise SchError('Unknown font effect attribute `{}`'.format(i)) + return h, v, mirror + + @staticmethod + def parse(items): + o = FontEffects() + for c, i in enumerate(items[1:]): + if isinstance(i, Symbol): + # Only hide exists + o.hide = _check_hide(items, c+1, 'font effect') + elif isinstance(i, list): + i_type = _check_is_symbol_list(i) + if i_type == 'font': + o.w, o.h, o.thickness, o.bold, o.italic = FontEffects.parse_font(i) + elif i_type == 'justify': + o.hjustify, o.vjustify, o.mirror = FontEffects.parse_justify(i) + else: + raise SchError('Unknown font effect attribute `{}`'.format(i)) + return o + + +class Color(object): + def __init__(self, items): + super().__init__() + self.r = _check_integer(items, 1, 'red color') + self.g = _check_integer(items, 2, 'green color') + self.b = _check_integer(items, 3, 'blue color') + # Sheet sheet.fill.color is float ... + self.a = _check_float(items, 4, 'alpha color') + + @staticmethod + def parse(items): + return Color(items) + + +class Stroke(object): + def __init__(self): + super().__init__() + self.width = 0 + self.type = 'default' + self.color = None + + @staticmethod + def parse(items): + stroke = Stroke() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'width': + stroke.width = _check_float(i, 1, 'stroke width') + elif i_type == 'type': + stroke.type = _check_symbol(i, 1, 'stroke type') + elif i_type == 'color': + stroke.color = Color.parse(i) + else: + raise SchError('Unknown stroke attribute `{}`'.format(i)) + return stroke + + +class Fill(object): + def __init__(self): + super().__init__() + self.type = 'none' + self.color = None + + @staticmethod + def parse(items): + fill = Fill() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'type': + fill.type = _check_symbol(i, 1, 'fill type') + elif i_type == 'color': + # Not documented, found in sheet.fill + fill.color = Color.parse(i) + else: + raise SchError('Unknown fill attribute `{}`'.format(i)) + return fill + + +class DrawArcV6(object): + def __init__(self): + super().__init__() + self.start = None + self.mid = None + self.end = None + self.stroke = None + self.fill = None + + @staticmethod + def parse(items): + arc = DrawArcV6() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'start': + arc.start = _get_xy(i) + elif i_type == 'mid': + arc.mid = _get_xy(i) + elif i_type == 'end': + arc.end = _get_xy(i) + elif i_type == 'stroke': + arc.stroke = Stroke.parse(i) + elif i_type == 'fill': + arc.fill = Fill.parse(i) + else: + raise SchError('Unknown arc attribute `{}`'.format(i)) + return arc + + +class DrawCircleV6(object): + def __init__(self): + super().__init__() + self.center = None + self.radius = 0 + self.stroke = None + self.fill = None + + @staticmethod + def parse(items): + circle = DrawCircleV6() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'center': + circle.center = _get_xy(i) + elif i_type == 'radius': + circle.radius = _check_float(i, 1, 'circle radius') + elif i_type == 'stroke': + circle.stroke = Stroke.parse(i) + elif i_type == 'fill': + circle.fill = Fill.parse(i) + else: + raise SchError('Unknown circle attribute `{}`'.format(i)) + return circle + + +class DrawRectangleV6(object): + def __init__(self): + super().__init__() + self.start = None + self.end = None + self.stroke = None + self.fill = None + + @staticmethod + def parse(items): + rectangle = DrawRectangleV6() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'start': + rectangle.start = _get_xy(i) + elif i_type == 'end': + rectangle.end = _get_xy(i) + elif i_type == 'stroke': + rectangle.stroke = Stroke.parse(i) + elif i_type == 'fill': + rectangle.fill = Fill.parse(i) + else: + raise SchError('Unknown rectangle attribute `{}`'.format(i)) + return rectangle + + +class DrawCurve(object): + """ Qubic Bezier """ + def __init__(self): + super().__init__() + self.points = [] + self.stroke = None + self.fill = None + + @staticmethod + def parse(items): + curve = DrawCurve() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'pts': + curve.points = _get_points(i) + elif i_type == 'stroke': + curve.stroke = Stroke.parse(i) + elif i_type == 'fill': + curve.fill = Fill.parse(i) + else: + raise SchError('Unknown curve attribute `{}`'.format(i)) + return curve + + +class DrawPolyLine(object): + def __init__(self): + super().__init__() + self.points = [] + self.stroke = None + self.fill = None + + @staticmethod + def parse(items): + line = DrawPolyLine() + for i in items[1:]: + i_type = _check_is_symbol_list(i) + if i_type == 'pts': + line.points = _get_points(i) + elif i_type == 'stroke': + line.stroke = Stroke.parse(i) + elif i_type == 'fill': + line.fill = Fill.parse(i) + else: + raise SchError('Unknown polyline attribute `{}`'.format(i)) + return line + + +class DrawTextV6(object): + def __init__(self): + super().__init__() + self.text = None + self.x = self.y = self.ang = 0 + self.effects = None + + @staticmethod + def parse(items): + text = DrawTextV6() + text.text = _check_str(items, 1, 'text') + text.x, text.y, text.ang = _get_at(items, 2, 'text') + text.effects = _get_effects(items, 3, 'text') + return text + + +def _get_effects(items, pos, name): + values = _check_symbol_value(items, pos, name, 'effects') + return FontEffects.parse(values) + + +class PinV6(object): + def __init__(self): + super().__init__() + self.type = self.gtype = self.name = self.number = '' + self.pos_x = self.pos_y = self.ang = self.len = 0 + self.name_effects = self.number_effects = None + self.hide = False + + @staticmethod + def parse(items): + name = 'pin' + pin = PinV6() + pin.type = _check_symbol(items, 1, name+' type') + pin.gtype = _check_symbol(items, 2, name+' style') + for c, i in enumerate(items[3:]): + i_type = _check_is_symbol_list(i, allow_orphan_symbol=['hide']) + if i_type == 'at': + pin.pos_x, pin.pos_y, pin.ang = _get_at(items, c+3, name) + elif i_type == 'length': + pin.len = _check_float(i, 1, name+' length') + elif i_type == 'hide': + # Not documented yet + pin.hide = True + elif i_type == 'name': + pin.name = _check_str(i, 1, name+' name') + pin.name_effects = _get_effects(i, 2, name+' name') + elif i_type == 'number': + pin.number = _check_str(i, 1, name+' number') + pin.number_effects = _get_effects(i, 2, name+' number') + else: + raise SchError('Unknown pin attribute `{}`'.format(i)) + return pin + + +class SchematicFieldV6(object): + # Fixed ids: + # 0 Reference + # 1 Value + # 2 Footprint + # 3 Datasheet + # Reserved names: ki_keywords, ki_description, ki_locked, ki_fp_filters + + @staticmethod + def parse(items): + if len(items) != 6: + _check_len_total(items, 5, 'property') + field = SchematicFieldV6() + field.name = _check_str(items, 1, 'field name') + field.value = _check_str(items, 2, 'field value') + field.number = _get_id(items, 3, 'field id') + field.x, field.y, field.ang = _get_at(items, 4, 'field') + if len(items) > 5: + field.effects = _get_effects(items, 5, 'field') + else: + field.effects = None + return field + + +class LibComponent(object): + def __init__(self): + super().__init__() + self.pin_numbers_hide = None + self.pin_names_hide = None + self.pin_names_offset = None + self.in_bom = False + self.on_board = False + self.is_power = False + self.unit = 0 + self.draw = [] + self.fields = [] + self.dfields = {} + + @staticmethod + def load(c, project, is_unit=False): # noqa: C901 + if not isinstance(c, list): + raise SchError('Library component definition is not a list') + if len(c) < 3: + raise SchError('Truncated library component definition (len<3)') + if not isinstance(c[0], Symbol) or c[0].value() != 'symbol': + raise SchError('Library component definition is of wrong type') + comp = LibComponent() + comp.project = project + # First argument is the LIB:NAME + comp.lib_id = comp.name = _check_str(c, 1, 'name') + res = comp.name.split(':') + comp.lib = None + if len(res) == 2: + comp.name = res[1] + comp.lib = res[0] + # libs[comp.lib] = None + else: + if not is_unit: + logger.warning(W_NOLIB + "Component `{}` doesn't specify its library".format(comp.name)) + comp.units = [] + comp.pins = [] + # Variable list + for i in c[2:]: + i_type = _check_is_symbol_list(i) + if i_type == 'pin_numbers': + comp.pin_numbers_hide = _check_hide(i, 1, i_type) + elif i_type == 'pin_names': + value = _check_len(i, 1, i_type) + index = 1 + if isinstance(value, list): + comp.pin_names_offset = _get_offset(i, 1, i_type) + index = 2 + comp.pin_names_hide = None + try: + comp.pin_names_hide = _check_symbol(i, index, i_type) + except SchError: + # Optional + pass + elif i_type == 'in_bom': + comp.in_bom = _get_yes_no(i, 1, i_type) + elif i_type == 'on_board': + comp.on_board = _get_yes_no(i, 1, i_type) + elif i_type == 'power': + # Not yet documented + comp.is_power = True + # SYMBOL_PROPERTIES... + elif i_type == 'property': + field = SchematicFieldV6.parse(i) + comp.fields.append(field) + comp.dfields[field.name.lower()] = field + # GRAPHIC_ITEMS... + elif i_type == 'arc': + comp.draw.append(DrawArcV6.parse(i)) + elif i_type == 'circle': + comp.draw.append(DrawCircleV6.parse(i)) + elif i_type == 'gr_curve': + comp.draw.append(DrawCurve.parse(i)) + elif i_type == 'polyline': + comp.draw.append(DrawPolyLine.parse(i)) + elif i_type == 'rectangle': + comp.draw.append(DrawRectangleV6.parse(i)) + elif i_type == 'text': + comp.draw.append(DrawTextV6.parse(i)) + # PINS... + elif i_type == 'pin': + comp.pins.append(PinV6.parse(i)) + # UNITS... + elif i_type == 'symbol': + obj = LibComponent.load(i, project, is_unit=True) + comp.units.append(obj) + # logger.warning('Unit: '+str(obj)) + else: + raise SchError('Unknown symbol attribute `{}`'.format(i)) + return comp + + +class SchematicComponentV6(SchematicComponent): + def __init__(self): + super().__init__() + self.in_bom = False + self.on_board = False + self.pins = OrderedDict() + self.unit = 0 + self.ref = None + + def set_ref(self, ref): + self.ref = ref + # Separate the reference in its components + m = SchematicComponent.ref_re.match(ref) + if not m: + raise SchError('Malformed component reference `{}`'.format(ref)) + self.ref_prefix, self.ref_suffix = m.groups() + + def set_footprint(self, fp): + res = fp.split(':') + cres = len(res) + if cres == 1: + self.footprint = res[0] + self.footprint_lib = None + elif cres == 2: + self.footprint_lib = res[0] + self.footprint = res[1] + else: + raise SchError('Footprint with more than one colon (`{}`)'.format(fp)) + + @staticmethod + def load(c, project, parent): + if not isinstance(c, list): + raise SchError('Component definition is not a list') + if len(c) < 7: + raise SchError('Truncated component definition (len<7)') + if not isinstance(c[0], Symbol) or c[0].value() != 'symbol': + raise SchError('Component definition is of wrong type') + comp = SchematicComponentV6() + comp.project = project + comp.sheet_path_h = parent.sheet_path_h + name = 'component' + # First argument is the LIB:NAME + comp.lib_id = comp.name = _check_symbol_str(c, 1, name, 'lib_id') + res = comp.name.split(':') + comp.lib = None + if len(res) == 2: + comp.name = res[1] + comp.lib = res[0] + # libs[comp.lib] = None + else: + logger.warning(W_NOLIB + "Component `{}` doesn't specify its library".format(comp.name)) + # 2 The position + comp.x, comp.y, comp.ang = _get_at(c, 2, name) + # 3 Unit + # Variable list + for i in c[4:]: + i_type = _check_is_symbol_list(i) + if i_type == 'unit': + # This is documented as mandatory, but isn't always there + comp.unit = _check_integer(i, 1, name+' unit') + elif i_type == 'in_bom': + comp.in_bom = _get_yes_no(i, 1, i_type) + elif i_type == 'on_board': + comp.on_board = _get_yes_no(i, 1, i_type) + elif i_type == 'uuid': + comp.uuid = _check_symbol(i, 1, name + ' uuid') + # SYMBOL_PROPERTIES... + elif i_type == 'property': + field = SchematicFieldV6.parse(i) + name_lc = field.name.lower() + # Add to the global collection + if name_lc not in parent.fields_lc: + parent.fields.append(field.name) + parent.fields_lc.add(name_lc) + # Add to the component + comp.add_field(field) + # PINS... + elif i_type == 'pin': + pin_name = _check_str(i, 1, name + 'pin name') + pin_uuid = _get_uuid(i, 2, name) + comp.pins[pin_name] = pin_uuid + return comp + + +def _get_uuid(items, pos, where): + values = _check_symbol_value(items, pos, where + ' uuid', 'uuid') + return _check_symbol(values, 1, where + ' uuid') + + +class Junction(object): + @staticmethod + def parse(items): + _check_len_total(items, 5, 'junction') + jun = Junction() + jun.pos_x, jun.pos_y, jun.ang = _get_at(items, 1, 'junction') + jun.diameter = _check_symbol_float(items, 2, 'junction', 'diameter') + jun.color = Color.parse(items[3]) + jun.uuid = _get_uuid(items, 4, 'junction') + return jun + + +class NoConnect(object): + @staticmethod + def parse(items): + _check_len_total(items, 3, 'no_connect') + nocon = NoConnect() + nocon.pos_x, nocon.pos_y, nocon.ang = _get_at(items, 1, 'no connect') + nocon.uuid = _get_uuid(items, 2, 'no connect') + return nocon + + +class BusEntry(object): + @staticmethod + def parse(items): + _check_len_total(items, 5, 'bus entry') + buse = BusEntry() + buse.pos_x, buse.pos_y, buse.ang = _get_at(items, 1, 'bus entry') + values = _check_symbol_value(items, 2, 'bus entry size', 'size') + buse.size = _get_xy(values) + buse.stroke = Stroke.parse(items[3]) + buse.uuid = _get_uuid(items, 4, 'bus entry') + return buse + + +class SchematicWireV6(object): + @staticmethod + def parse(items, name): + _check_len_total(items, 4, name) + wire = SchematicWireV6() + wire.points = _get_points(items[1]) + wire.stroke = Stroke.parse(items[2]) + wire.uuid = _get_uuid(items, 3, name) + return wire + + +class SchematicBitmapV6(object): + @staticmethod + def parse(items): + bmp = SchematicBitmapV6() + if len(items) == 5: + bmp.scale = _check_symbol_float(items, 2, 'image', 'scale') + index = 3 + else: + _check_len_total(items, 4, 'image') + bmp.scale = None + index = 2 + bmp.pos_x, bmp.pos_y, bmp.ang = _get_at(items, 1, 'image') + bmp.uuid = _get_uuid(items, index, 'image') + values = _check_symbol_value(items, index+1, 'image data', 'data') + bmp.data = [_check_symbol(values, i+1, 'image data') for i, d in enumerate(values[1:])] + return bmp + + +class PolyLine(object): + @staticmethod + def parse(items): + _check_len_total(items, 4, 'polyline') + poly = PolyLine() + poly.points = _get_points(items[1]) + poly.stroke = Stroke.parse(items[2]) + poly.uuid = _get_uuid(items, 3, 'polyline') + return poly + + +class Text(object): + @staticmethod + def parse(items, name): + _check_len_total(items, 5, name) + text = Text() + text.name = name + text.text = _check_str(items, 1, name) + text.pos_x, text.pos_y, text.ang = _get_at(items, 2, name) + text.effects = _get_effects(items, 3, name) + text.uuid = _get_uuid(items, 4, name) + return text + + +class GlobalLabel(object): + def __init__(self): + super().__init__() + self.text = '' + self.shape = None + self.fields_autoplaced = False + self.pos_x = self.pos_y = self.ang = 0 + self.effects = None + self.uuid = None + self.properties = [] + + @staticmethod + def parse(items): + label = GlobalLabel() + label.text = _check_str(items, 1, 'global_label') + for c, i in enumerate(items[2:]): + i_type = _check_is_symbol_list(i) + if i_type == 'shape': + label.shape = _check_symbol(i, 1, i_type) + elif i_type == 'fields_autoplaced': + label.fields_autoplaced = True + elif i_type == 'at': + label.pos_x, label.pos_y, label.ang = _get_at(items, c+2, 'global_label') + elif i_type == 'effects': + label.effects = FontEffects.parse(i) + elif i_type == 'uuid': + label.uuid = _get_uuid(items, c+2, 'global_label') + elif i_type == 'property': + label.properties.append(SchematicFieldV6.parse(i)) + else: + raise SchError('Unknown label attribute `{}`'.format(i)) + return label + + +class HierarchicalLabel(object): + @staticmethod + def parse(items): + name = 'hierarchical_label' + _check_len_total(items, 6, name) + label = HierarchicalLabel() + label.text = _check_str(items, 1, name) + label.shape = _check_symbol(items[2], 1, 'shape') + label.pos_x, label.pos_y, label.ang = _get_at(items, 3, name) + label.effects = _get_effects(items, 4, name) + label.uuid = _get_uuid(items, 5, name) + return label + + +class HSPin(object): + """ Hierarchical Sheet Pin """ + @staticmethod + def parse(items): + name = 'hierarchical sheet pin' + _check_len_total(items, 6, name) + pin = HSPin() + pin.name = _check_str(items, 1, name+' name') + pin.type = _check_symbol(items, 2, name+' type') + pin.pos_x, pin.pos_y, pin.ang = _get_at(items, 3, name) + pin.effects = _get_effects(items, 4, name) + pin.uuid = _get_uuid(items, 5, name) + return pin + + +class Sheet(object): + def __init__(self): + super().__init__() + self.pos_x = self.pos_y = self.ang = 0 + self.w = self.h = 0 + self.fields_autoplaced = False + self.stroke = self.fill = self.uuid = None + self.properties = [] + self.name = self.file = '' + self.pins = [] + + @staticmethod + def parse(items): + sheet = Sheet() + for c, i in enumerate(items[1:]): + i_type = _check_is_symbol_list(i) + if i_type == 'at': + sheet.pos_x, sheet.pos_y, sheet.ang = _get_at(items, c+1, 'sheet') + elif i_type == 'size': + sheet.w = _check_float(i, 1, 'sheet width') + sheet.h = _check_float(i, 2, 'sheet height') + elif i_type == 'fields_autoplaced': + sheet.fields_autoplaced = True + elif i_type == 'stroke': + sheet.stroke = Stroke.parse(i) + elif i_type == 'fill': + sheet.fill = Fill.parse(i) + elif i_type == 'uuid': + sheet.uuid = _get_uuid(items, c+1, 'sheet') + elif i_type == 'property': + field = SchematicFieldV6.parse(i) + sheet.properties.append(field) + if field.name == 'Sheet name': + sheet.name = field.value + elif field.name == 'Sheet file': + sheet.file = field.value + else: + logger.warning(W_UNKFLD+"Unknown sheet property `{}` ({})".format(field.name, field.value)) + elif i_type == 'pin': + sheet.pins.append(HSPin.parse(i)) + else: + raise SchError('Unknown sheet attribute `{}`'.format(i)) + return sheet + + def load_sheet(self, project, parent_file, parent_obj): + assert self.name + sheet = SchematicV6() + self.sheet = sheet + parent_dir = os.path.dirname(parent_file) + sheet.path = os.path.join(parent_obj.path, self.uuid) + sheet.sheet_path_h = os.path.join(parent_obj.sheet_path_h, self.name) + parent_obj.sheet_paths[sheet.path] = sheet + sheet.load(os.path.join(parent_dir, self.file), project, parent_obj) + return sheet + + +class SheetInstance(object): + @staticmethod + def parse(items): + name = 'sheet instance' + instances = [] + for c, i in enumerate(items[1:]): + v = _check_symbol_value(items, c+1, name, 'path') + instance = SheetInstance() + instance.path = _check_str(v, 1, name+' path') + instance.page = _check_symbol_str(v, 2, name, 'page') + instances.append(instance) + return instances + + +class SymbolInstance(object): + @staticmethod + def parse(items): + name = 'symbol instance' + instances = [] + for c, i in enumerate(items[1:]): + v = _check_symbol_value(items, c+1, name, 'path') + instance = SymbolInstance() + instance.path = _check_str(v, 1, name+' path') + instance.reference = _check_symbol_str(v, 2, name, 'reference') + instance.unit = _check_symbol_int(v, 3, name, 'unit') + instance.value = _check_symbol_str(v, 4, name, 'value') + instance.footprint = _check_symbol_str(v, 5, name, 'footprint') + instances.append(instance) + return instances + + +class SchematicV6(Schematic): + def __init__(self): + super().__init__() + self.annotation_error = False + + def _get_title_block(self, items): + if not isinstance(items, list): + raise SchError('The title block is not a list') + for item in items: + if not isinstance(item, list) or len(item) < 2 or not isinstance(item[0], Symbol): + raise SchError('Wrong title block entry ({})'.format(item)) + i_type = item[0].value() + if i_type == 'title': + self.title = _check_str(item, 1, i_type) + elif i_type == 'date': + self.date = _check_str(item, 1, i_type) + elif i_type == 'rev': + self.revision = _check_str(item, 1, i_type) + elif i_type == 'company': + self.company = _check_str(item, 1, i_type) + elif i_type == 'comment': + index = _check_integer(item, 1, i_type) + if index < 1 or index > 4: + raise SchError('Unsupported comment index {} in title block'.format(index)) + value = _check_str(item, 2, i_type) + if index == 1: + self.comment1 = value + elif index == 2: + self.comment2 = value + elif index == 3: + self.comment3 = value + elif index == 4: + self.comment4 = value + else: + raise SchError('Unsupported entry in title block ({})'.format(item)) + # Fill in some missing info + self.date = GS.format_date(self.date, self.fname, 'SCH') + if not self.title: + self.title = os.path.splitext(os.path.basename(self.fname))[0] + logger.debug("SCH title: `{}`".format(self.title)) + logger.debug("SCH date: `{}`".format(self.date)) + logger.debug("SCH revision: `{}`".format(self.revision)) + logger.debug("SCH company: `{}`".format(self.company)) + + def _get_lib_symbols(self, comps): + if not isinstance(comps, list): + raise SchError('The lib symbols is not a list') + for c in comps[1:]: + obj = LibComponent.load(c, self.project) + self.lib_symbols.append(obj) + self.lib_symbol_names[obj.lib_id] = obj + + def load(self, fname, project, parent=None): # noqa: C901 + """ Load a v6.x KiCad Schematic. + The caller must be sure the file exists. + Only the schematics are loaded not the libs. """ + logger.debug("Loading sheet from "+fname) + if parent is None: + self.fields = [] + self.fields_lc = set() + self.sheet_paths = {'/': self} + self.symbol_uuids = {} + self.lib_symbol_names = {} + self.path = '/' + self.sheet_path_h = '/' + else: + self.fields = parent.fields + self.fields_lc = parent.fields_lc + self.sheet_paths = parent.sheet_paths + self.symbol_uuids = parent.symbol_uuids + self.lib_symbol_names = parent.lib_symbol_names + # self.path is set by sch.load_sheet + self.parent = parent + self.fname = fname + self.project = project + self.all = [] + self.lib_symbols = [] + self.symbols = [] + self.components = [] + self.juntions = [] # Connect + self.no_conn = [] + self.bus_entry = [] + self.wires = [] + self.bitmaps = [] + self.texts = [] + self.lines = [] + self.labels = [] + self.glabels = [] + self.hlabels = [] + self.sheets = [] + self.sheet_instances = [] + self.symbol_instances = [] + with open(fname, 'rt') as fh: + error = None + try: + sch = load(fh) + except SExpData as e: + error = str(e) + if error: + raise SchError(error) + if sch[0].value() != 'kicad_sch': + raise SchError('No kicad_sch signature') + for e in sch[1:]: + e_type = _check_is_symbol_list(e) + obj = None + if e_type == 'version': + self.version = _check_integer(e, 1, e_type) + elif e_type == 'generator': + self.generator = _check_symbol(e, 1, e_type) + elif e_type == 'uuid': + self.uuid = _check_symbol(e, 1, e_type) + elif e_type == 'paper': + self.paper = _check_str(e, 1, e_type) + index = 2 + if self.paper == "User": + self.paper_w = _check_float(e, 2, 'paper width') + self.paper_h = _check_float(e, 3, 'paper height') + index += 2 + if len(e) > index: + self.paper_orientation = _check_symbol(e, index, 'paper orientation') + else: + self.paper_orientation = None + elif e_type == 'title_block': + self._get_title_block(e[1:]) + elif e_type == 'lib_symbols': + self._get_lib_symbols(e) + # The following are mixed + elif e_type == 'junction': + obj = Junction.parse(e) + self.juntions.append(obj) + elif e_type == 'no_connect': + obj = NoConnect.parse(e) + self.no_conn.append(obj) + elif e_type == 'bus_entry': + obj = BusEntry.parse(e) + self.bus_entry.append(obj) + elif e_type == 'bus' or e_type == 'wire': + obj = SchematicWireV6.parse(e, e_type) + self.wires.append(obj) + elif e_type == 'image': + obj = SchematicBitmapV6.parse(e) + self.bitmaps.append(obj) + elif e_type == 'polyline': + obj = PolyLine.parse(e) + self.lines.append(obj) + elif e_type == 'text': + obj = Text.parse(e, e_type) + self.texts.append(obj) + elif e_type == 'label': + obj = Text.parse(e, e_type) + self.labels.append(obj) + elif e_type == 'global_label': + obj = GlobalLabel.parse(e) + self.glabels.append(obj) + elif e_type == 'hierarchical_label': + obj = HierarchicalLabel.parse(e) + self.hlabels.append(obj) + # Ordered again + elif e_type == 'symbol': + obj = SchematicComponentV6.load(e, self.project, self) + if obj.annotation_error: + self.annotation_error = True + self.symbols.append(obj) + self.symbol_uuids[obj.uuid] = obj + elif e_type == 'sheet': + obj = Sheet.parse(e) + self.sheets.append(obj) + elif e_type == 'sheet_instances': + self.sheet_instances = SheetInstance.parse(e) + elif e_type == 'symbol_instances': + self.symbol_instances = SymbolInstance.parse(e) + else: + raise SchError('Unknown kicad_sch attribute `{}`'.format(e)) + if obj is not None: + self.all.append(obj) + # Load sub-sheets + self.sub_sheets = [] + for sch in self.sheets: + sheet = sch.load_sheet(project, fname, self) + if sheet.annotation_error: + self.annotation_error = True + self.sub_sheets.append(sheet) + # Create the components list + for s in self.symbol_instances: + # Get a copy of the original symbol + path = os.path.dirname(s.path) + sheet = self.sheet_paths[path] + comp_uuid = os.path.basename(s.path) + comp = deepcopy(self.symbol_uuids[comp_uuid]) + # Transfer the instance data + comp.set_ref(s.reference) + comp.unit = s.unit + comp.value = s.value + comp.set_footprint(s.footprint) + # Link with its library symbol + lib_symbol = self.lib_symbol_names[comp.lib_id] + comp.lib_symbol = lib_symbol + comp.is_power = lib_symbol.is_power + # Add it to the list + self.components.append(comp) diff --git a/kibot/kiplot.py b/kibot/kiplot.py index 9208ebe4..c12fd8e4 100644 --- a/kibot/kiplot.py +++ b/kibot/kiplot.py @@ -27,7 +27,8 @@ from .misc import (PLOT_ERROR, MISSING_TOOL, CMD_EESCHEMA_DO, URL_EESCHEMA_DO, C W_KIAUTO) from .error import PlotError, KiPlotConfigurationError, config_error, trace_dump from .pre_base import BasePreFlight -from .kicad.v5_sch import Schematic, SchFileError +from .kicad.v5_sch import Schematic, SchFileError, SchError +from .kicad.v6_sch import SchematicV6 from .kicad.config import KiConfError from . import log @@ -246,6 +247,14 @@ def load_sch(): GS.check_sch() # We can't yet load the new format if GS.sch_file[-9:] == 'kicad_sch': + GS.sch = SchematicV6() + try: + GS.sch.load(GS.sch_file, GS.sch_basename) + except SchError as e: + trace_dump() + logger.error('While loading `{}`'.format(GS.sch_file)) + logger.error(str(e)) + exit(CORRUPTED_SCH) return # pragma: no cover (Ki6) GS.sch = Schematic() load_any_sch(GS.sch, GS.sch_file, GS.sch_basename) diff --git a/kibot/misc.py b/kibot/misc.py index 88ea0c3e..d325a7b3 100644 --- a/kibot/misc.py +++ b/kibot/misc.py @@ -213,6 +213,7 @@ W_NOGLOBALS = '(W072) ' W_EMPTREP = '(W073) ' W_BADCHARS = '(W074) ' W_DATEFORMAT = '(W075) ' +W_UNKFLD = '(W076) ' class Rect(object): diff --git a/tests/board_samples/kicad_6/deeper.kicad_sch b/tests/board_samples/kicad_6/deeper.kicad_sch new file mode 100644 index 00000000..f716e3e4 --- /dev/null +++ b/tests/board_samples/kicad_6/deeper.kicad_sch @@ -0,0 +1,68 @@ +(kicad_sch (version 20211123) (generator eeschema) + + (uuid 3b838d52-596d-4e4d-a6ac-e4c8e7621137) + + (paper "A4") + + (lib_symbols + (symbol "Device:R" (pin_numbers hide) (pin_names (offset 0)) (in_bom yes) (on_board yes) + (property "Reference" "R" (id 0) (at 2.032 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Value" "R" (id 1) (at 0 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at -1.778 0 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "R res resistor" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Resistor" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "R_*" (id 6) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "R_0_1" + (rectangle (start -1.016 -2.54) (end 1.016 2.54) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "R_1_1" + (pin passive line (at 0 3.81 270) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin passive line (at 0 -3.81 90) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + ) + ) + + + (symbol (lib_id "Device:R") (at 139.7 80.01 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f3bbcff) + (property "Reference" "R3" (id 0) (at 141.478 78.8416 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Value" "1m" (id 1) (at 141.478 81.153 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Footprint" "" (id 2) (at 137.922 80.01 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 139.7 80.01 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid c8dca1a6-f09a-4305-804d-2295b5448f55)) + (pin "2" (uuid 4dec140a-3f2f-4b17-b6f0-89a0fc1cf30b)) + ) +) diff --git a/tests/board_samples/kicad_6/sub-sheet.kicad_sch b/tests/board_samples/kicad_6/sub-sheet.kicad_sch new file mode 100644 index 00000000..cfdf3ba0 --- /dev/null +++ b/tests/board_samples/kicad_6/sub-sheet.kicad_sch @@ -0,0 +1,455 @@ +(kicad_sch (version 20211123) (generator eeschema) + + (uuid 5b2b5c7d-f943-4634-9f0a-e9561705c49d) + + (paper "A4") + + (lib_symbols + (symbol "74xx:74LS04" (in_bom yes) (on_board yes) + (property "Reference" "U" (id 0) (at 0 1.27 0) + (effects (font (size 1.27 1.27))) + ) + (property "Value" "74LS04" (id 1) (at 0 -1.27 0) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_locked" "" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27))) + ) + (property "ki_keywords" "TTL not inv" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Hex Inverter" (id 6) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "DIP*W7.62mm* SSOP?14* TSSOP?14*" (id 7) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "74LS04_1_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_2_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "3" (effects (font (size 1.27 1.27)))) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "4" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_3_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "5" (effects (font (size 1.27 1.27)))) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "6" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_4_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "8" (effects (font (size 1.27 1.27)))) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "9" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_5_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "10" (effects (font (size 1.27 1.27)))) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "11" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_6_0" + (polyline + (pts + (xy -3.81 3.81) + (xy -3.81 -3.81) + (xy 3.81 0) + (xy -3.81 3.81) + ) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (pin output inverted (at 7.62 0 180) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "12" (effects (font (size 1.27 1.27)))) + ) + (pin input line (at -7.62 0 0) (length 3.81) + (name "~" (effects (font (size 1.27 1.27)))) + (number "13" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_7_0" + (pin power_in line (at 0 12.7 270) (length 5.08) + (name "VCC" (effects (font (size 1.27 1.27)))) + (number "14" (effects (font (size 1.27 1.27)))) + ) + (pin power_in line (at 0 -12.7 90) (length 5.08) + (name "GND" (effects (font (size 1.27 1.27)))) + (number "7" (effects (font (size 1.27 1.27)))) + ) + ) + (symbol "74LS04_7_1" + (rectangle (start -5.08 7.62) (end 5.08 -7.62) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + ) + ) + (symbol "power:GND" (power) (pin_names (offset 0)) (in_bom yes) (on_board yes) + (property "Reference" "#PWR" (id 0) (at 0 -6.35 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "GND" (id 1) (at 0 -3.81 0) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "power-flag" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Power symbol creates a global label with name \"GND\" , ground" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "GND_0_1" + (polyline + (pts + (xy 0 0) + (xy 0 -1.27) + (xy 1.27 -1.27) + (xy 0 -2.54) + (xy -1.27 -1.27) + (xy 0 -1.27) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "GND_1_1" + (pin power_in line (at 0 0 270) (length 0) hide + (name "GND" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + ) + ) + (symbol "power:VCC" (power) (pin_names (offset 0)) (in_bom yes) (on_board yes) + (property "Reference" "#PWR" (id 0) (at 0 -3.81 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "VCC" (id 1) (at 0 3.81 0) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "power-flag" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Power symbol creates a global label with name \"VCC\"" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "VCC_0_1" + (polyline + (pts + (xy -0.762 1.27) + (xy 0 2.54) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 0) + (xy 0 2.54) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 2.54) + (xy 0.762 1.27) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "VCC_1_1" + (pin power_in line (at 0 0 90) (length 0) hide + (name "VCC" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + ) + ) + ) + + + (wire (pts (xy 104.14 63.5) (xy 106.68 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 10109f84-4940-47f8-8640-91f185ac9bc1) + ) + (wire (pts (xy 175.26 63.5) (xy 177.8 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 47baf4b1-0938-497d-88f9-671136aa8be7) + ) + (wire (pts (xy 121.92 63.5) (xy 124.46 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 55e740a3-0735-4744-896e-2bf5437093b9) + ) + (wire (pts (xy 157.48 63.5) (xy 160.02 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid c022004a-c968-410e-b59e-fbab0e561e9d) + ) + (wire (pts (xy 193.04 63.5) (xy 195.58 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid e615f7aa-337e-474d-9615-2ad82b1c44ca) + ) + (wire (pts (xy 85.09 63.5) (xy 88.9 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid ef8fe2ac-6a7f-4682-9418-b801a1b10a3b) + ) + (wire (pts (xy 139.7 63.5) (xy 142.24 63.5)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid f4f99e3d-7269-4f6a-a759-16ad2a258779) + ) + + (hierarchical_label "IN" (shape input) (at 85.09 63.5 180) + (effects (font (size 1.27 1.27)) (justify right)) + (uuid 4fb02e58-160a-4a39-9f22-d0c75e82ee72) + ) + (hierarchical_label "OUT" (shape output) (at 195.58 63.5 0) + (effects (font (size 1.27 1.27)) (justify left)) + (uuid 77ed3941-d133-4aef-a9af-5a39322d14eb) + ) + + (symbol (lib_id "74xx:74LS04") (at 96.52 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f34307a) + (property "Reference" "U1" (id 0) (at 96.52 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 96.52 57.7596 0)) + (property "Footprint" "" (id 2) (at 96.52 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 96.52 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid f1e9ac99-f8d4-4d05-beb3-290dccb8d277)) + (pin "2" (uuid 014c98b2-ac35-4831-825d-74c6fa5ddc67)) + ) + + (symbol (lib_id "74xx:74LS04") (at 114.3 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f344a0e) + (property "Reference" "U1" (id 0) (at 114.3 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 114.3 57.7596 0)) + (property "Footprint" "" (id 2) (at 114.3 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 114.3 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "3" (uuid c1630947-26ec-4031-96dd-f1cdf939d3a7)) + (pin "4" (uuid e2858b6c-d9d5-4bfd-a26d-d7110c9ff81c)) + ) + + (symbol (lib_id "74xx:74LS04") (at 132.08 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f345e39) + (property "Reference" "U1" (id 0) (at 132.08 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 132.08 57.7596 0)) + (property "Footprint" "" (id 2) (at 132.08 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 132.08 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "5" (uuid 9a609661-5895-4db4-a600-14bffdacc16e)) + (pin "6" (uuid f6c777f1-b4a6-4529-9b29-67dfedcb1744)) + ) + + (symbol (lib_id "74xx:74LS04") (at 149.86 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f346e8b) + (property "Reference" "U1" (id 0) (at 149.86 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 149.86 57.7596 0)) + (property "Footprint" "" (id 2) (at 149.86 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 149.86 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "8" (uuid 47d49bdd-bacb-468f-bcfb-647fd9ccff38)) + (pin "9" (uuid 71c84a4a-5d81-46df-a82f-84ff433708b7)) + ) + + (symbol (lib_id "74xx:74LS04") (at 167.64 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f348270) + (property "Reference" "U1" (id 0) (at 167.64 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 167.64 57.7596 0)) + (property "Footprint" "" (id 2) (at 167.64 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 167.64 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "10" (uuid 01fec0dc-78cf-4a7d-851f-e24a9edd4a86)) + (pin "11" (uuid 92e30d01-6115-49a3-bead-4b8b74d533c9)) + ) + + (symbol (lib_id "74xx:74LS04") (at 185.42 63.5 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f348d95) + (property "Reference" "U1" (id 0) (at 185.42 55.4482 0)) + (property "Value" "74LS04" (id 1) (at 185.42 57.7596 0)) + (property "Footprint" "" (id 2) (at 185.42 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 185.42 63.5 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "12" (uuid b9a8ff4c-342a-4f44-bfb4-1b1895e9679b)) + (pin "13" (uuid 29941c34-ddd5-4a9c-bdef-5bf81398f604)) + ) + + (symbol (lib_id "74xx:74LS04") (at 139.7 88.9 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f34a12f) + (property "Reference" "U1" (id 0) (at 145.542 87.7316 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Value" "74LS04" (id 1) (at 145.542 90.043 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Footprint" "" (id 2) (at 139.7 88.9 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "http://www.ti.com/lit/gpn/sn74LS04" (id 3) (at 139.7 88.9 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "14" (uuid bf0862f0-7b4d-4da4-a5e8-91a9bdbee56f)) + (pin "7" (uuid 0639e567-d45a-4c84-98fa-a167b211ae20)) + ) + + (symbol (lib_id "power:VCC") (at 139.7 76.2 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f34bc05) + (property "Reference" "#PWR01" (id 0) (at 139.7 80.01 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "VCC" (id 1) (at 140.081 71.8058 0)) + (property "Footprint" "" (id 2) (at 139.7 76.2 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 139.7 76.2 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid 0030af45-9cbd-4108-9b0f-2e3885996ada)) + ) + + (symbol (lib_id "power:GND") (at 139.7 101.6 0) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f34c535) + (property "Reference" "#PWR02" (id 0) (at 139.7 107.95 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "GND" (id 1) (at 139.827 105.9942 0)) + (property "Footprint" "" (id 2) (at 139.7 101.6 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 139.7 101.6 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid 03d3f3dc-57cc-4a5d-b588-5d7b6cd2d907)) + ) + + (sheet (at 114.3 127) (size 25.4 12.7) (fields_autoplaced) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (fill (color 0 0 0 0.0000)) + (uuid 00000000-0000-0000-0000-00005f3bb8bb) + (property "Sheet name" "Deeper test" (id 0) (at 114.3 126.2884 0) + (effects (font (size 1.27 1.27)) (justify left bottom)) + ) + (property "Sheet file" "deeper.kicad_sch" (id 1) (at 114.3 140.2846 0) + (effects (font (size 1.27 1.27)) (justify left top)) + ) + ) +) diff --git a/tests/board_samples/kicad_6/test_v5.kicad_sch b/tests/board_samples/kicad_6/test_v5.kicad_sch new file mode 100644 index 00000000..fffd101a --- /dev/null +++ b/tests/board_samples/kicad_6/test_v5.kicad_sch @@ -0,0 +1,1845 @@ +(kicad_sch (version 20211123) (generator eeschema) + + (uuid e6521bef-4109-48f7-8b88-4121b0468927) + + (paper "A4") + + (title_block + (title "Title") + (date "2020-08-12") + (rev "r1B") + (company "Company") + (comment 1 "Comment 1") + (comment 2 "Comment 2") + (comment 3 "Comment 3") + (comment 4 "@Comment4@") + ) + + (lib_symbols + (symbol "Device:C" (pin_numbers hide) (pin_names (offset 0.254)) (in_bom yes) (on_board yes) + (property "Reference" "C" (id 0) (at 0.635 2.54 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Value" "C" (id 1) (at 0.635 -2.54 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Footprint" "" (id 2) (at 0.9652 -3.81 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "cap capacitor" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Unpolarized capacitor" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "C_*" (id 6) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "C_0_1" + (polyline + (pts + (xy -2.032 -0.762) + (xy 2.032 -0.762) + ) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy -2.032 0.762) + (xy 2.032 0.762) + ) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "C_1_1" + (pin passive line (at 0 3.81 270) (length 2.794) + (name "~" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin passive line (at 0 -3.81 90) (length 2.794) + (name "~" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + ) + (symbol "Device:L" (pin_numbers hide) (pin_names (offset 1.016) hide) (in_bom yes) (on_board yes) + (property "Reference" "L" (id 0) (at -1.27 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Value" "L" (id 1) (at 1.905 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "inductor choke coil reactor magnetic" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Inductor" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "Choke_* *Coil* Inductor_* L_*" (id 6) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "L_0_1" + (arc (start 0 -2.54) (mid 0.635 -1.905) (end 0 -1.27) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (arc (start 0 -1.27) (mid 0.635 -0.635) (end 0 0) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (arc (start 0 0) (mid 0.635 0.635) (end 0 1.27) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (arc (start 0 1.27) (mid 0.635 1.905) (end 0 2.54) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "L_1_1" + (pin passive line (at 0 3.81 270) (length 1.27) + (name "1" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin passive line (at 0 -3.81 90) (length 1.27) + (name "2" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + ) + (symbol "Device:R_US" (pin_numbers hide) (pin_names (offset 0)) (in_bom yes) (on_board yes) + (property "Reference" "R" (id 0) (at 2.54 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Value" "R_US" (id 1) (at -2.54 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at 1.016 -0.254 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_keywords" "R res resistor" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_description" "Resistor, US symbol" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "R_*" (id 6) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "R_US_0_1" + (polyline + (pts + (xy 0 -2.286) + (xy 0 -2.54) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 2.286) + (xy 0 2.54) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 -0.762) + (xy 1.016 -1.143) + (xy 0 -1.524) + (xy -1.016 -1.905) + (xy 0 -2.286) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 0.762) + (xy 1.016 0.381) + (xy 0 0) + (xy -1.016 -0.381) + (xy 0 -0.762) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (polyline + (pts + (xy 0 2.286) + (xy 1.016 1.905) + (xy 0 1.524) + (xy -1.016 1.143) + (xy 0 0.762) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "R_US_1_1" + (pin passive line (at 0 3.81 270) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin passive line (at 0 -3.81 90) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + ) + (symbol "l1:Resistor" (pin_numbers hide) (pin_names (offset 0)) (in_bom yes) (on_board yes) + (property "Reference" "R" (id 0) (at 2.032 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Value" "Resistor" (id 1) (at 0 0 90) + (effects (font (size 1.27 1.27))) + ) + (property "Footprint" "" (id 2) (at -1.778 0 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Test" "Hi!" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "ki_fp_filters" "R_* R_*" (id 5) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "Resistor_0_1" + (rectangle (start -1.016 -2.54) (end 1.016 2.54) + (stroke (width 0.254) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + ) + (symbol "Resistor_1_1" + (pin passive line (at 0 3.81 270) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "1" (effects (font (size 1.27 1.27)))) + ) + (pin passive line (at 0 -3.81 90) (length 1.27) + (name "~" (effects (font (size 1.27 1.27)))) + (number "2" (effects (font (size 1.27 1.27)))) + ) + ) + ) + (symbol "l1:SYM_CAUTION" (pin_names (offset 1.016)) (in_bom yes) (on_board yes) + (property "Reference" "#SYM_CAUTION" (id 0) (at 0 3.81 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "SYM_CAUTION" (id 1) (at 0 -4.445 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Footprint" "Tedy:Symbol_Caution_Type2_FSilkS_Small" (id 2) (at 2.54 -6.35 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Campo4" "Hi!" (id 4) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + (symbol "SYM_CAUTION_0_0" + (circle (center 0 -1.1684) (radius 0.254) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type outline)) + ) + (polyline + (pts + (xy -0.127 -0.762) + (xy -0.381 1.016) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type outline)) + ) + (polyline + (pts + (xy -0.127 -0.762) + (xy 0.127 -0.762) + (xy 0.381 1.016) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type outline)) + ) + (polyline + (pts + (xy -1.27 -1.905) + (xy 1.905 -1.905) + (xy 0 2.54) + (xy -1.905 -1.905) + (xy -1.27 -1.905) + ) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type background)) + ) + (arc (start 0.381 1.016) (mid 0 1.2906) (end -0.381 1.016) + (stroke (width 0) (type default) (color 0 0 0 0)) + (fill (type none)) + ) + (text "CAUTION" (at 0 -2.54 0) + (effects (font (size 0.508 0.508) italic)) + ) + ) + ) + ) + + (junction (at 63.5 25.4) (diameter 0) (color 0 0 0 0) + (uuid 01eb9bdd-a337-4673-a2b0-d209aebe8932) + ) + (junction (at 63.5 38.1) (diameter 0) (color 0 0 0 0) + (uuid 341059b3-16ac-4fe8-bbe2-921988ba1654) + ) + (junction (at 25.4 58.42) (diameter 0) (color 0 0 0 0) + (uuid 37e4dc66-4492-4061-908d-7213940a2ec3) + ) + (junction (at 50.8 38.1) (diameter 0) (color 0 0 0 0) + (uuid 66154fb2-7455-4e42-b0a7-e0fdebb40a4a) + ) + (junction (at 50.8 25.4) (diameter 0) (color 0 0 0 0) + (uuid e79c0d1b-dd57-46f8-829a-f7a4352235f8) + ) + + (no_connect (at 27.94 66.04) (uuid 2d6718e7-f18d-444d-9792-ddf1a113460c)) + + (bus_entry (at 25.4 25.4) (size -2.54 -2.54) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 46cfd089-6873-4d8b-89af-02ff30e49472) + ) + (bus_entry (at 38.1 38.1) (size 2.54 2.54) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 68b52f01-fa04-4908-bf88-60c62ace1cfa) + ) + (bus_entry (at 25.4 38.1) (size -2.54 2.54) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 9d984d1b-8097-407f-92f3-3ef68867dcfa) + ) + (bus_entry (at 38.1 25.4) (size 2.54 -2.54) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid bb4f0314-c44c-4dda-b85c-537120eaae9a) + ) + + (wire (pts (xy 99.06 92.71) (xy 99.06 102.87)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 0088d107-13d8-496c-8da6-7bbeb9d096b0) + ) + (polyline (pts (xy 25.146 127) (xy 37.846 127)) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (uuid 03d88a85-11fd-47aa-954c-c318bb15294a) + ) + (polyline (pts (xy 88.9 25.4) (xy 88.9 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 0c30a4be-5679-499f-8c5b-5f3024f9d6cf) + ) + (polyline (pts (xy 37.846 139.7) (xy 25.146 139.7)) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (uuid 0dcdf1b8-13c6-48b4-bd94-5d26038ff231) + ) + + (wire (pts (xy 38.1 38.1) (xy 25.4 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 0f3c9e3a-9c59-4881-b27a-d0e982b3ea8e) + ) + (polyline (pts (xy 88.9 139.7) (xy 76.2 139.7)) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (uuid 120a7b0f-ddfd-4447-85c1-35665465acdb) + ) + + (wire (pts (xy 129.54 114.3) (xy 96.52 114.3)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 128e34ce-eee7-477d-b905-a493e98db783) + ) + (polyline (pts (xy 50.8 139.7) (xy 50.8 127)) + (stroke (width 0) (type default) (color 255 0 0 1)) + (uuid 13475e15-f37c-4de8-857e-1722b0c39513) + ) + (polyline (pts (xy 37.846 127) (xy 37.846 139.7)) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (uuid 1a2f72d1-0b36-4610-afc4-4ad1660d5d3b) + ) + (polyline (pts (xy 76.2 127) (xy 88.9 127)) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (uuid 2732632c-4768-42b6-bf7f-14643424019e) + ) + + (wire (pts (xy 25.4 58.42) (xy 27.94 58.42)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 29256b3d-9450-4c0a-a4d4-911f04b9c140) + ) + (bus (pts (xy 50.8 25.4) (xy 48.26 22.86)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 2e642b3e-a476-4c54-9a52-dcea955640cd) + ) + + (wire (pts (xy 96.52 82.55) (xy 101.6 82.55)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 3172f2e2-18d2-4a80-ae30-5707b3409798) + ) + (wire (pts (xy 129.54 82.55) (xy 129.54 92.71)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 417f13e4-c121-485a-a6b5-8b55e70350b8) + ) + (wire (pts (xy 22.86 58.42) (xy 25.4 58.42)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 483f60da-14d7-4f88-8d01-3f9f30784c70) + ) + (polyline (pts (xy 51.054 144.78) (xy 63.754 144.78)) + (stroke (width 0.762) (type dash_dot) (color 0 255 0 1)) + (uuid 48f827a8-6e22-4a2e-abdc-c2a03098d883) + ) + (polyline (pts (xy 76.2 25.4) (xy 88.9 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 4dc6088c-89a5-4db7-b3ae-db4b6396ad49) + ) + + (bus (pts (xy 50.8 38.1) (xy 48.26 40.64)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 5038e144-5119-49db-b6cf-f7c345f1cf03) + ) + (bus (pts (xy 63.5 38.1) (xy 66.04 40.64)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 54365317-1355-4216-bb75-829375abc4ec) + ) + + (polyline (pts (xy 50.8 127) (xy 63.5 127)) + (stroke (width 0) (type default) (color 255 0 0 1)) + (uuid 58dc14f9-c158-4824-a84e-24a6a482a7a4) + ) + + (wire (pts (xy 129.54 102.87) (xy 129.54 114.3)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 67621f9e-0a6a-4778-ad69-04dcf300659c) + ) + (wire (pts (xy 127 102.87) (xy 129.54 102.87)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 68e09be7-3bbc-4443-a838-209ce20b2bef) + ) + (wire (pts (xy 99.06 102.87) (xy 101.6 102.87)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 6a780180-586a-4241-a52d-dc7a5ffcc966) + ) + (bus (pts (xy 63.5 25.4) (xy 63.5 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 7e969d15-6cc0-4258-8b27-586608a21adb) + ) + + (wire (pts (xy 25.4 25.4) (xy 38.1 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 825c70b0-4860-42b7-97dc-86bfa46e06fd) + ) + (polyline (pts (xy 88.9 127) (xy 88.9 139.7)) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (uuid 854dd5d4-5fd2-4730-bd49-a9cd8299a065) + ) + (polyline (pts (xy 76.2 139.7) (xy 76.2 127)) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (uuid 8d55e186-3e11-40e8-a65e-b36a8a00069e) + ) + (polyline (pts (xy 51.054 157.48) (xy 51.054 144.78)) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (uuid 9c8ccb2a-b1e9-4f2c-94fe-301b5975277e) + ) + + (wire (pts (xy 127 82.55) (xy 129.54 82.55)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid 9dab0cb7-2557-4419-963b-5ae736517f62) + ) + (polyline (pts (xy 76.2 38.1) (xy 76.2 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid a501555e-bbc7-4b58-ad89-28a0cd3dd6d0) + ) + + (bus (pts (xy 63.5 25.4) (xy 66.04 22.86)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid ac264c30-3e9a-4be2-b97a-9949b68bd497) + ) + + (wire (pts (xy 22.86 66.04) (xy 27.94 66.04)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid b603d26a-e034-42fb-8327-b60c5bf9cdd2) + ) + (polyline (pts (xy 63.5 139.7) (xy 50.8 139.7)) + (stroke (width 0) (type default) (color 255 0 0 1)) + (uuid b635b16e-60bb-4b3e-9fc3-47d34eef8381) + ) + + (bus (pts (xy 50.8 25.4) (xy 63.5 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid b8c83ad1-b3c9-495c-bdc6-62dead00f5ad) + ) + + (wire (pts (xy 25.4 58.42) (xy 25.4 60.96)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid b994142f-02ac-4881-9587-6d3df53c96d2) + ) + (wire (pts (xy 38.1 25.4) (xy 38.1 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid bbb15673-6d42-42b8-9d51-7515b3ad9ee9) + ) + (wire (pts (xy 129.54 92.71) (xy 99.06 92.71)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid c201e1b2-fc01-4110-bdaa-a33290468c83) + ) + (wire (pts (xy 96.52 114.3) (xy 96.52 82.55)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid c801d42e-dd94-493e-bd2f-6c3ddad43f55) + ) + (polyline (pts (xy 63.754 157.48) (xy 51.054 157.48)) + (stroke (width 0) (type solid) (color 255 0 255 1)) + (uuid cef6f603-8a0b-4dd0-af99-ebfbef7d1b4b) + ) + (polyline (pts (xy 88.9 38.1) (xy 76.2 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid db83d0af-e085-4050-8496-fa2ebdecbd62) + ) + (polyline (pts (xy 25.146 139.7) (xy 25.146 127)) + (stroke (width 0.508) (type default) (color 0 0 0 0)) + (uuid dde3dba8-1b81-466c-93a3-c284ff4da1ef) + ) + + (wire (pts (xy 25.4 38.1) (xy 25.4 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid e83e0227-ac0f-4180-82bd-68d3a7b56476) + ) + (polyline (pts (xy 63.754 144.78) (xy 63.754 157.48)) + (stroke (width 0.508) (type dot) (color 0 0 0 0)) + (uuid e877bf4a-4210-4bd3-b7b0-806eb4affc5b) + ) + + (bus (pts (xy 50.8 38.1) (xy 50.8 25.4)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid f022716e-b121-4cbf-a833-20e924070c22) + ) + (bus (pts (xy 63.5 38.1) (xy 50.8 38.1)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid f1dd8642-b405-490b-a449-d1cc5797fda8) + ) + + (polyline (pts (xy 63.5 127) (xy 63.5 139.7)) + (stroke (width 0) (type default) (color 255 0 0 1)) + (uuid f976e2cc-36f9-4479-a816-2c74d1d5da6f) + ) + + (wire (pts (xy 25.4 55.88) (xy 25.4 58.42)) + (stroke (width 0) (type default) (color 0 0 0 0)) + (uuid fb03d859-dcc9-4533-b352-64830e0e5423) + ) + + (image (at 133.35 40.64) + (uuid 9a9f2d82-f64d-4264-8bec-c182528fc4de) + (data + iVBORw0KGgoAAAANSUhEUgAAAuQAAAGQCAYAAADm/3UvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz + AAArXAAAK1wBfoUIFwAAIABJREFUeJzs3Xl8XHW9//HX98yWZbKvTbrTfaO0tIWyVRabUIq44QpX + wat41YsKsiqKKKLA1QuKKyKIXLl6VSzQwk92aOlCC91purdJk6bZl8nMnHO+vz9CQpe02WbmzPJ5 + Ph552MTJOZ+0IXnPdz7fz1chhBAC/T0y6CQXTSYuslF40XQBLSja8NGivkfI6TqFEEIkH+V0AUII + EWv6VqZhsQjFLGASMBko6+fTLGAvsAPYjuYt3Lyo7uZQdKsVQgiR7CSQCyGSnv4eaXRyGfARFB8A + SiN4+e3AC8Cf+TFvKNARvLYQQogUIIFcCJG09E3MR3ENcCWQF4Nb7gYeBx5WP2Z/DO4nhBAiCUgg + F0IkHX0z56K4Gc1lDpUQRvFnFHerH7HdoRqESE7uy1wolYGiCM1ooAS0D4w2lD6A5gDQgssK0vWs + vGIlEoIEciFE0tC3MA+b/0ZxttO1vMcGnsDFTdJrLsQweT6Uhranovg4cBFwGpAGuOnOMzYQBpqA + t4F/gH4OTS3m07ZTZQsxEBLIhRAJT3+dXNK4E81XAJfT9fShA8V9pHG3TGoRYpC8l7nQahrwbeAS + IAcwlHLhdafhdXkxlIFpmwTNLkwrxHtbOULAAeCXaB7BXNbo2NcgRD8kkAshEpq+lUux+QNQ5HQt + A7Aem0+qe6lyuhAhEoL7sjSUugq4EyhVKJWbUURZwSzKCueSkVFARoYfhUFXV4hAoJn2zhr216+k + tnknwXAngAmsBq5Dqy2Y/5Q2FhF3JJALIRKS/h5uuvg2mu8AhtP1DEIbcJ36MU84XYgQcc2zNBO4 + A/gakJ6Vlsfk8ksYX34R5aMKmTDVQ3EJpGeA1tDRDnWHYM8Om4b6IEead7DjwD/ZW/82lh3WwD40 + n8XQqwhJC4uILxLIhRAJR99AIW6eAhY6Xcsw/ILdXK/+guV0IULEHc/SNOCHwFcVyju6cDqzTvsc + I8vGc8YCN+MngS8N1HEpxrYh2AW7dsDGtdDS1MG+w6+wYef/0BFsAagGPo4y3iT0lKyUi7ghgVwI + kVD0DYzBzXN0H+aT6J4ixKfUTwk4XYgQccP9YQNl/idwDyjfxBFnM3fSFykfncf5lyjyC08M4sfT + GpoaYOVLcOiAxeHGjazc+iAtgSPQPZ60gvAyaR0TcUMCuRAiYejbmIHFCqDc6Voi6FXgcvVjWpwu + RIi44Fk6D1gB5I8pnMXZ029kzPhcFlVAVnb3Q7TuXg3Xmt6juJQCZYBxVANboBNWvgx739VUH1nH + q5v+i65whwZeBP0hwk93xPJLE+JkJJALIRKCvoXxaN4gsqdsxos3sbhY3YeEA5HavEsz0TwHnJOd + XsDFZ9zJuPGjuegyyMyEQAAa6qGpERrrIRgA2+oO4h4v+HOgoAhyciAnD7xeCJvw5suwY4vF1j1P + sm7Xk2itw8BnCS/7X4e/YiGA7tmdQggR1/SNFKNZTnKGcYCzcPNn/T0+rL6H6XQxQjhGsxCYp1BM + G72UkuKRLLigu/1kzetQfwi6OsA6xc4LpcDthUw/jBgFo8fDGQsgHHYRNpdS07Ce6qYdHuAO3B96 + DvMpeXVKOC4e5/UKIUQv/T0ysHgJmO50LVE2CZOSO9/gaacLEcIRrsvcKPVrYEJx9hjmTPoCpWXp + VO+DrRugqR7CwffaVPphW9AVgCO1sLcKDh2EolJob/Fh4Gdv3UpA56F4Bfvd3dH+0oToTyKNChNC + pKIAvwBmO11GjHxJ38zVThchhCMMVQ7MAhhbch4+Tza11XC4BqxhvG5kmdBQB5vWdk9gKcmdSXH2 + GAAP6Otwf1Lad4XjJJALIeKWvoVPAZ9zuo4Ye0jfyjSnixDCATOBArcrjdEl5wEKHcFp4VqDtsHr + 8VNW0Psc/wxUR27k7iLE0EggF0LEJX0LE9D81uk6HJCJzZ/1F/E4XYgQMXYZoIqyyvF5sqN4G0VZ + wfyed0qAEVG8mRADIoFcCBGfND8DMp0uwyEzyeMbThchRMy4PqyAMwByMkpxu9Kjejt/egkuwwuQ + AYyN6s2EGAAJ5EKIuKNv4ePAEqfrcNh39S0SFESKMMw0IAfA68lFqejGE6XcpHl6n++fFtWbCTEA + EsiFEHFFf4N0NP/ldB1xIAPNT5wuQoiY0Higu03L5fJF/XZKGbhdvV1hOVG/oRD9kEAuhIgvXr4A + jHS6jDjxMX0zM50uQogYsN97w7ZjMIpfa2y7d8doMPo3FOLUJJALIeKG/iIeFDc4XUccUcAtThch + RNQZqgsIAJhWBzCAYePDoLEImoGed+uiejMhBkACuRAifuRzFZoxTpcRZz6hv8VEp4sQIqpC/zSB + 3QAdXfVYdiiqtwubnYStTgAT2BbVmwkxABLIhRDxQ3Od0yXEIRcGX3C6CCFi4AWAI20HCYXbo3YT + y+7iwOFX0d1HfjYANVG7mRADJIFcCBEX9K1MAuY5XUec+qz+OC6nixAiyl4BAu1dTeytXU4w1ICO + 5MlAgGkFqGtcyf7Dr/V8aB/KPhzRmwgxBBLIhRDxwebzTpcQx8oYx4VOFyFElO0G9oBmb+3r1DS8 + SGPrhgj1lGtC4Wbqml6jub2KI+2Hee+ifyL0THi4hQsxXBLIhRDx4kqnC4hrik84XYIQURVe1g78 + AdBH2g/THjhMS0cVNUdeoKltC6bVPqQVc9sO0dqxk9rGl+kK1lPdsAXTCgMcAZZF9GsQYogkkAsh + HKdvZBww3uk64priYqdLECIG/geotmyT/YffwbJDmFYHTW2bqTnyLxpa1hEI1mLZQbS2TnoRrS0s + K0B75x4ONbxMQ+t6TCtAR1cDtc0HoXt1/B9otS9GX5cQp+R2ugAhhMCQdox+acboGxmn7mOP06UI + ET1GNdg/Av77SHudO6dpFyPyJ6GUgWkFaO3cRVtgH25XGl53Lj5vIW5XBobygFJo28S0OugK1RMM + N2HZgd5V9bAZYHftOqzuOecHwfgh5lORbVIXYogiFsjHzv56rm0F5fhZIcSgHQ49+tFiX6fTZcS9 + tS0jrhk984p/DOcahsu3a+/bP2uOVE1CRFT4KY136R/RfFhrfdHew5uUz5NOftYolOp+UV9rk7DZ + Tthsp6Pr4HsfV+9dQPfZ1mJaIfbUrqO5sxmgE/gG2Ptj9FUJ0S/V/0P6NnL6tfnK8PwbcCaaeSgm + DOd6QojU9dL5f+Y0v2TE/vxx/3Ru33zecC+jFewAvdbWrLF9+n9q3vrNkUjUJ0TEeJaOobu/e4bb + 5VHji6dTlDsBl+Hp7zNPEAoH2FO3jsMt1Wh0GLgX274T65noDjsXYhCGFKBHz/zyxRr9CHK8tRBi + mNzK5t3Fv8NjyCvH/VnZUM4nVy+N9GXrDK2u3bf5l89E+sJCDIv78iko/b/ADEMZqji7lJFFM0n3 + 5qBU/1NALduktaOOfYc30trVDBAEfgHcQXhZR3SLF2JwBhXIx479XJqZ5fueQn0L2RAqhIiAcRkt + vLLof5wuIyHUdmUy/8WronFprdG/tb36GzVv/UZ6h0T8cC89DcXDwDmA2+f2UZRdSmHOeDJ8uRjK + DUqhUGg06O4g3haop65pJ40d9T09483AT1D8N6Fl8j0u4s6gesjNrLQ/KvhYtIoRQqSecdKqMmAl + aR1kuEw6rYjvx1cK9UVXSOWCjFcUccRctgvP0o8CXwOuC5rB4oON+1RtczVpHh/pXj8edxqGcmPZ + JsFwJ13hTgLh3s2cIWAzcBPwKqFlMnNcxKUBr3KPnvWlpRLGhRCRlucJOl1CwlBArrcrmre4cuSM + 6z4czRsIMWjhZQ1ofgBcWJCv/1yQpzHcJh2hDurb6qhp2sfBxl0cat5HY0c9XWYHaWm27XLxJvBl + 4IMY+kXCEsZF/BrQMsv4uV/MCYfUL6NdjBAi9WS65HfkYGS6o/v3pRS/GD3zyy/v3/TLpqjeSIjB + MJeZwNYzZ1dstiywtY8Z02dQU9tJS3MA07JJ87lxuUzqag+Skam7tM2XX11lvEP4meEe8ylE1A0o + kJtBdTuK8mgXI4RIPZkeGXQwGP7oP4EZYWPfDNwS7RsJMRgXX3yxoRSXuN1QWJjFnDkTmasMbLs7 + bysF7e3tPPvsQWxbpwNlhJ9529mqhRiYgbWsKHVulOsQQqSoNOPkp+2JE6XH5BUFNezZikJEmtvt + zgHGAuTm5uJ2u3G5DDweFx6PC7fbRVqaj/T0dACllJIDx0TC6D+Qf/zjLg2nx6AWIUQKCtr9jy8T + 7+uK/IbOEyiYzcc/Lv8wIt6UAIUAJSUlfT7A6/Xi9/sB0Fqfe8kll8j3sUgI/Qby0VvzJwMZMahF + CJGCOszBH/SRytpj8/eVMWZb0aRY3EiIQZgGZLpcLgoLC/t8gGEY5OXl9bxb5nK58vp8oBBxpv8V + chfTYlCHECJFSSAfnA7LG5P7aMOaHpMbCTFwiwGVnp6O13vy/w6Kiop6/lgIFMegLiGGrd9Abmvl + i0UhQojU1BxOc7qEhNISjs2PZPnZL+JJRUWFF5gPkJ2djcdz8ifyBQUFuFwugHSl1IzYVCjE8Mhp + m0IIR+3pzHG6hIRRH8yIVcuKEPGmEBgBUFhYiGGcPL54PB4yMro7bbXWH4hJdUIMkwRyIYSj9nVk + Y2r5UTQQuzpynS5BCKeUA/kApaWlp3ygx+MhKyur590Fl156qTyLFXFPfgsKIRxlaoP9nVn9P1Cw + q10CuUhZCwHP0VNUTua4jZ0ltm0XRLs4IYYruvOzlEFemYyzFUKcWlX4Hcazyuky4t4e19nklV8w + 4Mc31bwG2o5iRUJEX0VFhQI+COD3+0/ZP96jpKSELVu2ABTQPS6xNpo1CjFcUR9o63KnR/sWQogE + t65zNotzJZD3563AXPmZKlJRFjAJICcnZ0CBPCcnB7fbjWmaPmAO8E50SxRieKRlRQjhuHWdM50u + Ie4dDhewL1jmdBlCOKEYKIKTHwh0PI/HQ2ZmZs+7cmKniHsSyIUQjtsXLKMu3PdBH6Lb6g45MFmk + JqXURCDbMAyKiwc2Vvy4jZ2zKysrZYyniGsSyIUQceH5lnOcLiGu/at1odMlCOEIrfUlDOBAoKMp + pSgo6N3LWay1lmf8Iq5JIBdCxIVlLRc5XULcarRyWNV+htNlCBFzlZWVbuA8gKysrAEHcjimvSWP + 92aYCxGvJJALIeLCzq7R7Oga63QZcWlF8/mY2uV0GULEnNa6gPfCdH5+/ikPBDqe3+/vCfAe4Kyo + FChEhEggF0LEjb81Lna6hLijUfy96RKnyxDCKSPoPqVzwBs6e8jGTpFIJJALIeLGP1ouot7Md7qM + uPJS61nsCo52ugwhnDIf8Hk8HnJzB3cwltvtPnpj59SKioqMSBcnRKRIIBdCxI2Q7eWJhqVOlxFX + fl//UadLEMJJFwNkZmYOqn8cujd2FhUV9bxb9N6bEHFJArkQIq78pbGSRivH6TLiwqtt89jaNcHp + MoRwRGVlZQYwEyA7Oxu3e/BnGZaUlKCUAsgFyiNaoBARJIFcCBFXOu00/rv235wuw3Eh7eGndZ93 + ugwhnFRC96FAFBcX9wTrQTlqVKJLa31eZMsTInIkkAsh4s7TzR9gbUdqn975yJGPysmcItWNAXKV + UpSWlg7pAh6PB7/fD4BS6sKKiorBp3ohYkACuRAi7mgUPzn074S0x+lSHLE/VMYjRz7idBlCOEpr + fRFgpKWl4fMN7aBNt9tNdnZ2z7vjAX+EyhMioiSQCyHi0q7gaH5a+zmny4i5kPZwy4EbCNmD28Am + RDKprKw0eG9U4VHzxIfkqI2dhbzXAiNEvJFALoSIW082LmF5y/lOlxFT99dey/au05wuQwhHaa3z + gJHQfSCQyzX0g7GO6j/PprsNRoi4I4FcCBHXfnToOvaGUmM4wvKW8/lLY4XTZQgRD0oZ4oFAx/P5 + fKSlpUF35lk03MKEiAYJ5EKIuNZuZfDlvd+nLlzodClRtbZjJndWf83pMoSIF2cAGS6Xi/z84R0W + 5vV6ezd2Aos++MEPSvYRcUe+KYUQca8uXMBX991Bi5Wc+7GqgmO5cf8tKbuJVYg+XARDOxDoeC6X + 6+hTPke5XC456EDEHQnkQoiEsCs4mq/tv4MWK6v/ByeQ7V3j+fKeO2mzM50uRYi48MEPfjANOBO6 + DwTyeIb/RPWojZ0FWmvZ2CnijgRyIUTC2Nw5iWv2/IjacHKcgL22YyZf3PsDOZlUiKMYhlFE96FA + FBYWDulAoOMVFhZiGAZ0jz2U429F3Bn8ObRCCOGgPcGRfH7PPTww5i4m+vY6Xc6QLW85nzurvyZt + KuKUKioqXFrrVFs8GwPkQfeGTq31sC/o8XhIS0ujs7NTARctXrz4+WFfNAlorc3nn39++H/BYtgk + kAshEk5duICrdv+E60se41P5TztdzqCEtIcH6q7miYalTpci4tzixYtLgeuVUiOAgSwTJ0uwmsJ7 + +WT37t1UV1cP+4KWZWFZVs+7n1BKDW+naPwZyssItlJqXWVl5e+XL18eiHhFYlAkkAshElLI9nLv + oS+wuXMSt434FZmuTqdL6te+YBm3HryR7V3jnS5FxLmKigoD+BRwM0MLW0mhqqoqGpctA/4tGhdO + QB/WWq8C1jtdSKqTQC6ESGjLW85nbedMri95lCU5LztdTp9M7eIvTZX8vO6zBOw0p8sRCUBrjVKq + GFCGYZCbm9vTA31Kkei3dpLWmnA4HJE2lVPxeDwD+vuMF+FwmGAwGLHrhUKhnlcMfHT31QuHSSAX + QiS8I+E8vnPw6zzd/AG+Vfo7xvsOOF1Sr9fazuS+2ms5EBrhdCkiQWVmZrJo0aJhj/9LFP2FcaXU + sAN7oj1xaW9vZ8eOHdi2HZHrBQIBampqov7ERwycBHIhRNJY3X46V+58gHOz1vHvRf/L9PSovNzd + L43i9fa5/Lb+SjZ3TnKkBpE8lFK43W7cbndvkDxZoBzMx4//2Mkec/Tb0Y87+n97/tyz6tzX+z1v + fX3s6LeekNjzZ9M0CYVCmKZJOBwmHA5jmmZKhcmeeeyhUCgi10ukVwdShQRyIURSsVG82jaP19rO + 5OysDVyR+y/Oz1qLV4Wjfu9mK5vnWs7j/5o+yM6uMVG/n0g9xcXFFBZ2n1p7fFA+Puge/7Hj/7+T + fezo909loI/RWveG554/27aNaZonhO1QKEQwGOz9mGma2Lbd+3k9n5tq3G43fr+fxsZGp0sRUSKB + XAiRlDSKlW1zWNk2h2xXOxfnrOSirFXMzthGutEVsfs0mLms7ZjJcy3nsbJ9DmEtP1ZFdCilyM7O + prg4Ps61OTok97z1hOieleye3udgMHjM6rZlWScE7VRa8R4spRT5+fk0NTXJ31OSkt8cQoik12r5 + +VvjB/lb4wfxKJPp6VXMz9zIhLR9jPHVMMZTg9fo/6XgVsvP/mAZe0PlbAucxpqOWewOjkKn7hAM + EWMulyuq1z8+HGutsSyrN0j3rGL3BO2eP4fD4WNC9tFhW0SG3+/H7XYTDkf/1T4RexLIhRApJazd + vN05lbc7p/Z+zEBT5Gkk22gjw9VFhtFFuhGgw86g3cogYKfRbGbLiZrCcUPp/T2+XaSvlpGeUN3T + MnL8anZfq+GpxrbtE9plju+Ljya32016eroE8iQlgVwIkfJsFHXhAuoocLoUIU7pZCvkPavTlmWd + 0Jfds5IdDAZ7PxbNlpGjV8h73gd6g+tAe9Sd1jOCsaWlhebmZhobG2lvb+8dy2gYBj6fj+zsbPLy + 8sjLyyMzM/OYzbeRZBgGWVlZtLa2RvzawnkSyIUQQogE0ddKrGVZbN68mY6ODsdaRrTWhEIhWlpa + aGpqoqGhgY6ODkKhELZtYxgGXq+XzMxMCgoKyMvLIycnB6/XG3fh3LZt2tvb2bt3LwcOHMA0TXJy + cigqKmL8+PFkZ2eTlpZGe3s7LS0tHD58mJ07d9Le3o7f72fcuHGUl5eTlpYW8a8tJydHxhUmKQnk + QgghRILoK5CHQiHa2tocaWXoCa/79u1j//79mKZJbm4upaWlTJ8+nYKCAtLS0ujq6qKxsZHa2loO + HTrE9u3bcbvdjBo1irFjx+L3+x0fxae1JhAIsH37dvbt20d+fj4XXHABCxYsYPTo0WRmZh6zwt/z + xMe2bZqbm9mzZw+vvfYamzZtYtu2bUydOpXRo0dHdH68z+fD4/FEbPyhiB+OB/LJ43P40bfOxOOO + r2fIyeCN9Ye555cbnS4jJubNKuSOr812uoyU0REw+eWftvPK6lqnSxEiZZysV7mnFSXWAoEAVVVV + 7Nq1i7y8PBYtWtQbXjMyMnC5XMeE154NooFAgH379rFmzRrWrFnDrl27GDduHJMnTyY9PT3mXwd0 + P7E4dOgQGzZswO/3c9VVV7Fw4ULy8vJwu/uPSqWlpZSWljJ37lxqamp47rnneOWVV9i3bx9z584l + JycnIqvlLpeL9PR0CeRJyPFA/u7uFn7xx238+OYzMQwJ5ZFStbeVBx/d6nQZMbNxexPFhel43HLY + QbS9sLKGe3+zicMNkRsdKIQYmL56yFtaWmLawmDbNocPH2b9+vX4fD4+9alPcd5555Gfn99veHW7 + 3fh8PnJzc5k+fTpXXHEFr7/+OsuWLeOll15izpw5FBcXx3S13DRNtm3bRlVVFQsWLOCzn/0spaWl + Q6rB6/UyduxYrrnmGs4991weffRRXnnlFebMmUN5efmwvy7DMPD7/bS0tAzrOiL+OB7IofsX/H89 + vJkb/32m06UkhfrGLv7zzjfp6Iz9iolTgiGLqj2tTJuY63QpSasjYHLPLzfyzEvxcyy9EKnm+ECn + taa5uTlm97csi507d7JlyxbOPPNMrrrqKsrKyoYUNN1uN0VFRVx++eXMmzePxx57jJUrVzJt2jQm + TpwY9RGPAOFwmLfffpsDBw7wiU98gssuu4yMjIxhX9fj8TBt2jRuueUWHn74YVatWsUZZ5zB2LFj + hx3K/X7/MSeaiuQQF4Ec4Il/7mbC2GyuuEROtxsOreGOn66n7kjA6VJirq4hIIE8SrZWNXPrves4 + cKjD6VKESGnHtz30tIDEgmVZbNmyhaqqKpYuXcqVV15JZmbmsK/rcrkYOXIk119/Pf/7v//LsmXL + CAaDzJgxI6qhvGcz7P79+7n22mu55JJLItrv3XOYz5e//GW8Xi8vv/wyXq+X8vLyYbWvpKenYxgG + lmVFrFbhvLgJ5AD3/HIj0ybkMmmczPodqmUv7mf12/VOl+GI1jaZzRoNy185yPcfeJtgSH74C+Gk + vsYF9swQjzbbttmxYwc7duzgYx/7GB/96EdJS0uL6D0yMzP59Kc/TWZmJk888QQej4cpU6ZEpX1F + a82BAweoqqriE5/4RMTD+NH8fj/XXHMN7e3trF27Fr/fT27u0BePXC4XXq83Zk/ERGzEVcNtKGzz + 7fvXEwrZ/T9YnKCxJchPH97idBmOaW2XTS6RZFma+363mdvve0vCuBBxoK9V1a6urpislNbV1bF5 + 82YqKyujEsZ7+Hw+Lr/8cioqKti8eTN1dXVRuU97ezvr169nwYIFXHHFFVEL4z2ysrL4whe+QFFR + EevWrRvWkyjDMKL29y+cE1eBHGDnvlZ+/5cdTpeRkH7+6DZa2lI3lNrSThcxHZ0m/3nnmzzx1C6n + SxFCvOf4FfKe/vFo9xIHAgHWrVvHjBkz+OQnPxn1MJiWlsZnPvMZZs6cybp16yK+EmzbNhs3bsTv + 9/P5z38+Ij3jA1FcXMzVV19Nc3Mz+/fvH/J1lFIxq1nETtwFcoA//F8V+2ukV3Uw6o4EeDrFN9sV + 5vmcLiEpNDQH+fdbX2fVhsNOlyKEOEpfrRvR3tCptWbr1q0opbjmmmvIzs4e9DVs26arq4uGhgbe + ffdd3nnnHXbs2EFTUxPBYLDPJxRZWVlce+21AGzZsiWiTzpaW1s5ePAgS5cupbS0NGLX7Y9Sijlz + 5jBv3jy2bdtGMBgc8rXS09Pj7kAlMTxx1UPeIxS2efDRrdx76zynS0kYf/z7TkwztVt9CvPkJbzh + Oniog//47ioOyuZNIeLO8SvkpmkOK9QNREdHB3v37uXSSy9lzJjBDV2wLIv6+nrWrFnDM888w759 + +zh8+DBdXV1kZGRQUlLC2LFjWbJkCfPnzyc/P/+YJx2jR4/moosu4tlnn2XKlCn4/f5hfz1aa7Zv + 305xcTEXXXTRSUOt1ppwOIxtv/971e12D2gm+an4fD4+/OEPs27dOurr6xk5cuSQrtMTyGXSSvKI + y0AO8OKqGrbvbmHKeNng2Z/m1hB/e26f02U4SqnuQ6bE0FXtbeU/vrOShubo/oIXIhUtWbJkUMuZ + lmWdsBx+fHgMBoNR39C5Z88e0tPTueyyywY18aS9vZ1//etf/OY3v+Hll18+ZdvJ448/zgc+8AGu + u+46Lrjggt7DgVwuF0uXLuWll15i9+7dzJo1a9hfTzAY5NChQ1RWVva5sbKrq4v9+/ezY8cOVq9e + TU1NDZZl4ff7mTx5MrNnz2batGnk5uYOeQLM2LFjmTx5MlVVVcMaGelyuY55wjAMarDfn9D9/fj0 + 00/LM4IIidtArjX84a9V3HPTmU6XEvee+n/76Aqm9qa7CWOyyc2O7qacZLZ9Vwtf/s7KlN6DIEQ0 + LF68OAf4jGVZowb5qQo4/5gPHLdCHggEorqhMxwOc+DAAebOnUthYeGAP6+xsZF7772Xhx9+mPr6 + /qd+tba28tRTT7F+/Xq+9KUv8bWvfa23NaaoqIg5c+awfv16pk6disfjGfLXA/S2yRy/Ot5zONDj + jz/Oiy++yNtvv93n6adFRUWcffbZfPKTn6SiooLc3NxBt46kp6czd+5cnnjiCQKBwJBGRxqGgdvt + jsQTMjfwRcuyKobwuS2LFy9+4rnnnht6Q7zoFbeBHODFVYeob+yiKF9aEU7ludeqnS7BcfNmDfyX + hTjWlqpUk0+HAAAgAElEQVRmvnLHSlrbZWykEJFUWVmptNaVwM+A4SVJju0hj8WBQB0dHbS3t3PW + WWcNuFWjpaWFu+66i4ceemjQx7sfOHCAH/3oRwSDQW6++WYyMzNxuVwsWrSIl19+mc7OTnJyhvdK + aHV1NSUlJeTl5fV+rLOzk7/97W/89Kc/Zf369af8/Pr6ev75z3/y4osv8vGPf5ybb76ZiRMnDnqV + e86cOfzxj3+kra1tyIE8QqMP3cCnh/i5Wik1oaKi4roVK1akzkmEURLXgdw0bf75r/1ce+Ukp0uJ + W/uq29m+S47QvficMqdLSEgbtzfy1e+9SXuHhHEhIk0ppbTWZYAnIyODkSNHDmo1tb6+nsbGxqOv + 1/v5WmtaW1sjXfIx6urq8Pl8TJ48eUCPD4fDPPzww/zqV78adBjv0dHRwYMPPsi4ceO4+uqrcblc + jB07lszMTGpqaoYVyG3bprm5mdGjR/eG4M7OTh566CHuu+++QY1YbG9v55FHHqG6upr777+f6dOn + D+rfNj8/H7/fz+HDh4e0sVQpNexXC3oUFBTg8w18KILWmqamJrq6uhRQrpSKywEhiSauAznAc69W + SyA/BVkdh9FlmZw+tcDpMhLOjj0t/OedEsaFiDIFMGHCBK655poBhyitNS+88AJ///vf379QDDd0 + aq05cuQIxcXFAw5rVVVV/OpXv6Krq2tY925ububBBx/kwgsvZMyYMaSnp1NSUkJDQ8OwrmuaJp2d + nRQUFOB2u7EsiyeffJKf/OQnA2qt6cvzzz/P7bffzkMPPUR5efmAP8/j8ZCfn09LSwta6yFNTInE + 7HSv18sXv/jFQdVuWRZ//etfee2114Z9f/G+uH9Ws3NfK3ur250uI269tOqQ0yU4bulFo5HpT4Oz + +0Ab131b2lSEiJWe0xUH83b8pkHDMHqDWzAY7LPHOVK01nR0dFBcXDyg4BcOh3n00UepqqqKyP03 + bNjAn/70JyzLIi0tjcLCQjo7O4fVM2/bNqZp9k5r2bVrF/fff/+Qw3iPZcuW8cADDwzqiYjL5cLv + 9w/5lQTontgSidGHXq8Xn883qLfhTpsRJ4r7QA6wJkWPgu9PS1uIqj3Rfcky3nk9Bh+6eLTTZSSU + g4c6+PK3V9LcKhs4hUgkR/cpDzec9qcnvGZlZQ0ofDU0NLBixYqI1rB8+XJaW1txuVxkZGScMIZw + sLTW2LaN1+slFArxm9/8hi1bhn+6tdaaxx9/nB07Bn6ooVIKr9c7rK8n2qeLithKiEC+duMRp0uI + S29vbcRO8Rmkl188mkLZ9Dtg9Y1dXPftldQ3Du8lZSFE7PX0kPf08EZTT3j1eDwD2rBYVVXFpk2b + IlrDm2++yaFD3a8Cu91ubNse1txtpRSGYRAMBjl8+PAx7UDDVVNTw5///OcBP0nSWhMKhYY8OhEk + kCebhAjkVXtl02JfNmwZXj9donO7Df7toxOdLiNhdARMrr/zTWoOdzpdihBiCHqCsdaatra2qN7r + 6PA6kFXc9evXR/yQGtM02bBhA9DdEuNyuYbVomEYBh6Ph7a2Nl5++WV2794dqVIBWLVq1YAn31iW + RVtb27BC9XD/PkR8SYhAXl3XSSic2qdQ9mV9igfySy8YSXlJhtNlJATb1tx+31ts3y1PboVIVD09 + 5KFQaFi9xwO9l8fjobW1td9Z19EcwdjQ0IBpmrS3t+PxeIa1oux2u0lPT+fIkSO9QT+SNmzYMOAx + hOFwmMbGRnJycoYcqnueNInkkBD/kpalqa6Vo7yPZpp2Socrr9fgi58e2CguAT/8xTu8uqbW6TKE + EMPQE75CoVBUN3RCd9jLysqirq5uQOE/WsHQ5XLR1dVFfX09fr9/WPcxDIP8/Hz27t3Lxo0bI1hl + t5aWlgG3EtXX19PR0UFJScmw7imBPHkkzL9k7ZFhD79PKgdrOzHN1H3V4KorJlBWLKvjA/G7J3fw + 9+f3OV2GECnNNM1Bvx3fKtKzOtzW1hapI9NPSilFcXEx9fX1dHaeus1NKTWkWdoDUVZWRmdnJ7W1 + tRQVFQ37eiNHjqSxsTFi02CON9AV8rfeegu329078WUoIrVCbts2lmUN6i3a33+pKGHm1shEiGOl + 8ijIglwfn5Pe8QF57tVqfvmnbU6XIUTK27t3L6tXrx7wTG+tNfv2HftE2jCMmJzQ2aOwsBDLsti0 + aVO/K7lnnXVW7/SSSMnOzmbOnDls2bKFcDg87NVkgJycHDIzM6MSKF0u14CeNHR2dvLWW29RUFBA + WtrQhxJEIpDbts3WrVsHNfrRNE327t07rPuKEyVMIG9qkUB+tL0HoruhJ5795+emk5mRMN+6jnlr + 8xG++7P1pPggHiHiQjgcJhQKDbhfWGt9wsQOwzCwbZuOjti0cGZkZJCTk8Obb77J+eeff8oNiGVl + ZZxzzjm89NJLEbv/hRdeiN/v5/XXXyc/P5/09PRhX9Pr9VJWVjasIHwy48ePH9B1d+zYwc6dO1m4 + cOGwA/VwN3VqrQkEArS3D3yRzzTNYR/+JE6UMC0rTS3RO5EsEaXqCvmsKfksuXCk02XEvd0H2rjh + h2tkM7QQScQwjJhs6OzhdrsZP34877zzDjU1Nad8bF5eHpWVlRGb+mEYBkuWLKGtrY133nmHMWPG + ROQwGqUUU6ZMoby8POITShYuXEhOTs4pHxMIBPjHP/5BZmYmhYWFw7pfzxhMkRwSJpDLiYLHOnAo + 9Ta5er0Gd379DAz5AXRK9Y1dfPW7q+S/GSGSjMvlivoJncfrCa7/93//d8onAoZh8JnPfIbzzjsv + Ive99NJLWbJkCX/9619RSjF6dOQOgPP7/UybNo3c3NyIXdMwDC644IJTruJrrVm1ahVvv/0206dP + j8gccQnkySNhAnlXMHY/gBJBY3PqvWLwpU9NYUz50DfApIKuoMX133+T2nrZBC1EMunpF25tbY34 + vO9TSUtLY8qUKbzxxhts2rTplPcuLS3l5ptvpry8fFj3nDhxIjfddBN1dXWsXLmSyZMnR6RdpYdh + GJx++unMmjUrYoH2kksu4bLLLjvl9WpqanjiiScoLCykrKwsIveVQJ48EiiQy0vvR2tIsUA+aVwO + V11xmtNlxDWt4c4HNrB9V+qOwxQimSmlaGmJ7X/fSinGjRtHVlYWjzzyCEeOnPzkbMMwuPjii7nj + jjuGHDhPO+007rrrLiZMmMDDDz+M3+/ntNMi/7M/MzOTiooKxo0bN+xrlZaWcv3115+yBaWpqYlf + //rXtLa2Mnfu3Ii130ggTx4JFMgHdhxtKgiFbTo6U6cdwePublVxuxPm29URv//LDp57tdrpMoQQ + UaK17ncEYTR4vV7OPPNMDh06xG9/+9tTnhLq9Xq5+uqreeCBB5g7d+6A76GU4txzz+XBBx/k4osv + 5ve//z01NTXMnz8/akfEl5eX85GPfIQRI0YM+Rq5ubnccMMNXHjhhScNx83Nzfz6179m8+bNLFiw + gKysrCHfTySvhEk40rLyvqaWYEpNzvjK1VOZPP7UG2VS3cura/nl49udLkMIEUWx3NB5vLy8PObN + m8fatWt5+OGHTxnK09LSuOKKK/jDH/7AN7/5TWbOnHnSaSIul4u5c+dy22238fvf/56FCxfy2GOP + sXbtWubNmxfRPu/jGYbBjBkzuPLKKxk1atSgP3/UqFF85zvf4brrrutznKXWmrq6Oh544AHWrl3L + ggULKCkpidiqttY6pu1LIroSZnacrJC/L5VGQM4/vYjPSqvKKe3c18q3738LW34wC5HUwuHwCaMQ + Y0UpRXl5OXPnzuXVV18lGAxy7bXXUlBQ0GfAdLlczJgxgx/84Ad8/vOfZ9OmTbzxxhscPnwYy7Jw + u92UlpZy3nnnMXPmTMaMGUN7ezsPPfQQa9euZe7cuVGZhHI8t9vNnDlzyMzM5Nlnn2Xr1q39PunJ + yMjgkksu4Stf+QrnnXden6MOg8EgGzdu5LHHHuPIkSOcc845FBcXS4uJOKmECeSWJWGjR1tHarSr + 5GR5+f435shUlVNoaQvxzR+uoTMgryAJkcy01rS1tTm6ImoYBmPHjsXn87Fu3Tpqa2u5+uqrmTZt + 2kkPPEpPT2fGjBlMmzaND3/4w8fUbxgGHo+HcDjM1q1b+eMf/0h1dTVnnXUWZWVlMQuvLpeLqVOn + UlhYyGuvvcaWLVuor68nEAjg8XhIS0sjKyuLkSNHMmHCBC6//HLOPvtsCgsLj1n511oTDAbZs2cP + zz77LKtXryYvL48LLrgAv98fla9HVsiTR8IEctuWb7oeoXBqvFpw23/Morgg8oc3JAvL0tx0z1oO + puAITCFS0WAOb4kWpRQjRoxg0aJFrF+/nnvuuYezzjqLysrK3rDeV/A0DOOYleSe8FpVVcUzzzzD + 6tWryc7OZtGiRWRlZcV8JVkpRXFxMUuWLGHq1Kls27aNhoYG3G43o0ePZtGiRSxcuJDi4mLS0tIw + DAPLsgiHw5imSW1tLXv27OHVV1+lqqoKl8vFGWecQVlZWUQ2cJ6MBPLkkTCB3JJA3itsJv/fxccv + Hccl5w5vdFayu//hzazdePKJB0KI5OJUu8rxlFJkZ2dzzjnnUF1dzVtvvcWaNWuYMGEC559/PmPH + jmXEiBF4PJ5jgrXWmnA4TG1tLXv37u0Nr4ZhMGvWLMrLy/F4PA5+Zd3971OnTmXMmDFUV1ezd+9e + 2traeOGFF9iwYQMFBQX4/X48Hg9dXV20trbS2NhIU1MTwWCQvLw8Zs2aRUlJCV6vV1pUxIAlTCCX + J4HvCyf5Cvn0ibnc8IUZTpcR1/75wn7+vGy302UIIVKYx+NhzJgxjBgxgrq6Ovbs2cNvfvMbPB4P + OTk55OXlkZmZidfrJRwO097eTlNTEy0tLYTDYfLy8pg5cyalpaVxFV6VUmRmZjJx4kTGjRtHZ2cn + zc3NtLS0UF1dTTgcxrZtXC4XPp+PvLw8Ro0aRW5uLunp6bhcrpjUqbXGtmUkdLJImEAuK+TvS+bj + 0LP9Hu65eR5eT8IMAIq5d7Y1cvcv3nG6DCGEQCmFz+dj9OjRlJeX09XVRUtLC+3t7TQ3N9PQ0NC7 + idPn81FcXMy4cePIzc0lLS0tZuF1KJRSvU8ucnJyjgnAWuveOeBOzQOXQJ5cEiaQSw/5+8Jmcv4H + qBR87+tzKC/JcLqUuFVbH+CGH65J6idlQojE5HK5yMzMJDMzEwDbto/pce45bTRRKaXi7gmE9JAn + DwnkCShZJ858/mMTWbSg1Oky4lZX0OKbP1hNY0tqndIqhEhMiRy+E4GskCcX+a8lASXjE+IFs4v4 + j89OdbqMuKU1fPdnG9i+O7bHZgshhIhfskKePCSQC8eVFqVz941zMYz42NATj3735Lv8v9ernS5D + CCFEnLBtW1bIk4gEcuEor9fgvlvnk5fT96ESAl5eXcuvn3jX6TKEEELEEcuyZIU8iSRMD7lITrde + dzrTJuY6XUbc2nOgjTt+uh5bfugKkfBCodCAp3ForeNm7riIT+FwZE7t7uzsPOlJq30xTVO+N6NA + ArlwzJVLxvGhS0Y7XUbcamkL8fW7VtPeEZkfukII55imydatWwc8pUNrzZEjcvCXOLlIBHLbttm9 + e/cxp6j2R2tNZ2fnsO8tjiWBXDhi1pR8OfznFCxLc9M9azlwqMPpUoQQEdJzoMxASX+wOJVwOByR + lhXLsga14i1tMtEhPeQi5grz07j31nl43PLtdzL3/W4TazfK6pgQQoi+hUIhp0sQESSJSMSU221w + z7fOpCh/4C+PpZqnXzzAk0/vcboMIYQQcUprLYE8yUjLioipG78wgzkzCpwuI25tereJH/z8bafL + EEJEmG3bBIPBQR2WY5pmFCsSiUxrHbHvj8EG+0jeW7xPArmImUsXjeTKJeOcLiNuNTQFuemetYTC + 0jcqRBLR0N2nu3Xr1gH36iqlSE9PJyMjI6rFicRk23ZEQrFt2+zcuXNQG0SVUuTk5OB2u+G9728x + fBLIRUxMGpfDt7862+ky4pZp2tz047XUHQk4XYoQIkKeffZZu6KiYjfQCXjD4bAxmM1zPp9PAXJi + mjhBJFepLcuyBxvIdffOThuo0lrLKlIESCAXUZeT5eX+2+aR5hvYuK9UdM+vN7FhS4PTZQghIkxr + /TzwaaAsEAjMNE3TM8BPVX6/fx4wK3rViURl23akZoFbtm0/HQgEBnwUtFLKtixrt8fjOQw8v2LF + CulfiQAJ5CKqDKX44Q1zKS/NdLqUuPXX5Xv524q9TpchhIiC5557rhN46r13/Qxwxbu0tNQ1duzY + 7yCBXPQhFApFZPygUiqcl5f3wLp1614fzOe9++67YaRdJaIkkIuo+urVU1k4t9jpMuLWxu2N3Pfb + TU6XIYSIjfaBPvD00083lFIyRkP0qaurK2LXcrlcJiDfaw6TsYciahYtKOXfPjrR6TLi1pHGLtnE + KYQQYtC6urrkgJ4kI4FcRMXYcj93fXMuSrYj9SkUtvnm3Ws43BC5VQ4hhBDJT2sd0RVyER8kkIuI + y0h3c9/t88nMkI6ok/nxrzay+d0mp8sQQgiRYGzblkOBkpAEchFRSsGdXz+D8aOynC4lbj359B7+ + /vw+p8sQQgiRgGzbHtTccJEYJJCLiPrCJyZz0cIyp8uIW29va+S/Ht7sdBlCCCESVKQOBRLxRQK5 + iJizZhfxpU9NdrqMuFV3JMCNP1xD2JRNnEIIIYZGNnQmJwnkIiLKijO4+1tnYhiyi7MvoZDNjXev + obEl6HQpQgghElggEJBAnoQkkIth83ld3HfbfHKzvU6XErd+9Kt32FLV7HQZQgghElxnZ6fTJYgo + kDEYYthu+4/TmXJajtNlxK0nntrFU/9vv9NlCCHi2JIlSwyOOsXTtm1Da937vtZ60KuiSubOJh3b + tqMx8tBYsmSJq4976eXLl0uPZYxIIBfD8pkPncbSi0Y5XUbcentrAz/7w1anyxBCxKnFixd7lVIf + syxrHkcF8vf+vBC6e4a3b9+O2z3wX9lKKQoKCiguLpZgnkT6Gnlo2zZtbW2DmrximmbPEzwP8FXL + sq7o42HBioqKJ1esWLF+ODWLgZFALobs9Kn5/OfnpjldRtw6dLiTG+5eiymbOIUQJ6GUmgD8N1B4 + sseEQiE2bdo06GunpaVx1llnUV5eLqE8SZimecyEFcuyOHz4MO3t7UPtK3cBHz3F/39uRUXFhStW + rJANUFEmgVwMSWF+GvfeMg+PW7Yh9CUUsrnxR2tpkk2cQohTUEr5tdbpAOnp6fh8vmFfU2tNIBCg + q6uLNWvWsHDhQkpLS4d9XeG8ozd0mqbZG8YBXC4XLtcJnScAgwrrWmssy+r5nEKOfeVGRIkEcjFo + brfBT26ZR2F+mtOlxK27H3qHbTtlE6cQYmBcLhcLFiyISHDWWtPY2Mgbb7xBZ2cnb775Jueccw5F + RUURqFQ4qbOzE601pmlSW1vbu8EzOzubwsJCDGP4i2Raa+rq6nqDvogNCeRi0G65bhazp+Y7XUbc + evRvO/nnC7KJUwgxOC6Xa1B94qdSXFzM2WefzRtvvEF7ezurVq3ivPPOIy8vLyLXF7Gntaajo4Nw + OExtbS2BQAClFLm5uRQUFEQkjPeQFqfYk0AuBuWyC0fxkcVjnC4jbq15p56fPyabOIUQzlJKUVpa + yoIFC1i1ahWtra288cYbnHvuufj9fqfLE0NgmiZtbW3U1NQQDAZ7N+7m5uZGNIwLZ0ggFwM2ZXwO + t3/ldKfLiFs1hzu55SfrsCw5sEEI4TylFOXl5cyfP5/Vq1fT3NzMCy+8QHp6esSuL/oWjYN7tNa0 + tbVhmiaGYVBUVER2drb8OyQJCeRiQHKyvNx3+3x83r43jKS6YMjixrvX0Nwa6v/BQggRI4ZhMHr0 + aEzTZN26dQQCAQKBgNNliWFwuVwUFxfj9/sljCcRCeSiXy6X4t5b51FWnOF0KXFJa/juzzawfVeL + 06UIIcQJDMNg3LhxmKbJhg0bsCwLwASeBQ45W53ohwGcA0wFlNvtprS0lIwM+X2cbCSQi359/fPT + OXPmSUfkprxH/lrF869VO12GEEKclMvlYuLEiZimycaNG7Ft2wUUa62v11ofdLo+cSLDMNzAZ4CP + Acrj8TBixAjS0mTCWTKSQC5OafH55XzmQ6c5XUbcevPteh56fJvTZQghRL9cLhdTpkwhHA6zbds2 + Zdv2fKXU75RSn12xYkWt0/WJ91VWVnq11l8Evg/keL1eysrK8Hq9TpcmokS25YqTmjA2mzu+dobT + ZcSt6rpObv3JOmxbNnEKISLjZAe7RIrb7WbGjBlMmDABpZQBfAD4XUVFRUFUbywGrLKyMl1rfRNw + N5CTlpbGyJEjJYwnOQnkok/Zfg/33zaf9DTZxNmXzi6Tb9y1mpY22cQphIgcn88X9VDu8XiYPXs2 + Y8eO7QnlFcCvKioqcqN6Y9GvyspKv9b6+8BtQGZ6ejrl5eURm08v4pf8C4sTGEpx1zfnMmpEptOl + xCWt4c7/3sDOfa1Ol5Kw0tNcjB2Z5XQZcc22Ne/ulo3Cqcbn82FZVs/Gy6jxer2ceeaZWJbFgQMH + XFrrK4DOysrKry5fvrwtqjcXfaqoqMjRWv8E+Bzgzc7OpqSkRCappAgJ5OIEX/r0ZM6bV+J0GXHr + d0++y/97vcbpMhJaMGTz1aumcvacYqdLiVvtHWHO/+SzTpchYszr9WJZFsFgMOr38vl8zJ8/H9M0 + qampcQOf0lq3VVRU3LRixYrOqBcger3XMvRz4KOAp7i4mHnz5rF///6YfC8I50nLijjG+fNLufYT + k5wuI26tWn+YX//Pu06XkfBsW3PbfW9RXSe/84U4mlKK7OzsmN0vLS2Ns88+m9LSUgAP8AXgOxUV + FTLKI0YqKytLgUeAjymlPCNGjOCcc84hNzeXrCx5JTFVSCAXvUaXZXLXN+dgyMtjfdpX3c4tsokz + YlraQtx49xqCoei+NC9EIlFKkZsb21bu9PR0zj77bIqKigB8wPXAjRUVFbKLMMoqKipGaa3/BCxR + SrlHjhzJwoULyczMRClFQUGBtKykCAnkAoCMNDf33TafrEyP06XEpY6AyY13r6GtI+x0KUnl3d0t + PPCHrU6XIURcSU9Pj/rGzuNlZmaycOFC8vPzAdKBW4AvV1RUSGtrlFRUVJwGPAksUkoZY8eO5ayz + ziI9Pb33MRkZGXg88ns5FUggFygF371+NhPGxO5l0kSiNXzvZxvYtV/2OUXDk8/skc2LQhzF6/U6 + MlUjKyurt1UCyATuAv7t0ksvlXFbEXTppZeqioqKacBfgbMMwzAmTZrEvHnz8Pl8xzzW7XYfE9BF + 8pJALrj6IxO55Nxyp8uIW79+YjsvrJRNnNFi25of/2ojWjqBhAC6Q9jxwSxWcnJyOOecc3r62LOA + +7TWH6usrJS8EAEVFRXKtu3ZwP8Bp7tcLjV9+nRmz57d55xxpRR+vz/mdYrYk5eiUty8WYV89aqp + TpcRt15eXcvvntzhdBlJ7+1tjTz78gGWfGCU06UI4Sitde/GztZWZ0ar5ubmsnDhQl5//XXa29tz + tdY/B6zKysqVjhSURLTWU4DfAePcbjezZs1i0qRJp3xFJDs7m5qaGrSsWiQ1CeQprLQonXtuOhOX + SzaM9GVvdTt3/HQ9tvwQjImfP7aNxeeV43bLQpxIbT0bOw8ePOjY/QsKCnpDeWdnZyHwqNY64EhB + ycUH+D0eD3PmzGH8+PH97hfoOSzKNM3YVCgcIYE8RXm9BvfeOp+8HGdeFo13HZ0mN/xwDe2yiTNm + 6o4EeP61ai6VVXIhejd2RvuAoJNRSlFUVMSCBQtYtWoVwWAwQ2udcarHp7qBrGArpUhLS2POnDmM + GTMGw+h/AcIwDNxutwTyJCeBPEXdet3pTJ8opyT3xdaa2+5bx54Dsokz1v66fK8EciF4f2OnU4Ec + usNjWVkZH/jAB2hpkY3XkdDz6kdubu6An8QYhoHX66WrqyvK1QknSSBPQVdeOo4PXTLa6TLi1i8f + 385ra+ucLiMlvb2tkX3V7Ywpl01MIrX1bOx0+pTGnvaVgoICR+tIZT0r5CK5SbNmipk5OY8b/n2G + 02XErZdWHeL3f5FNnE56dU2t0yUI4bhYn9gp4ltfE1hEcpFAnkIKcn3ce+t8PLJprk97DrRxx8/W + y/g9h63bdMTpEoRwnBMndor4FeuDokTsSTJLEW63wY9vnkdxQZrTpcSl1vYwX79rNR2dsmnGaW9t + bsA0bafLEMIRR28MdOLEThGfBrL5UyQ2+RdOETdcO4M5M6QHsC+21tx+31scONThdCkC6AyYbN3Z + 7HQZQjjOqRM7RfyRKTbJTwJ5Crh00Ug+cdk4p8uIWw/+YStvvCWbOOPJzr3OHIgiRDxx8sROEV9s + W141THYSyJPcpHE5fPurs50uI269uPIQj/19p9NliOPUHO50ugQhHCcbO0UPJ8dfitiQQJ7EcrK8 + 3H/bPNJ80oPYlx17WvjOT9+STZxx6NBhORBQCNnYKXrIoUDJTwJ5kjKU4gc3zKG8NNPpUuJSS1uI + G+5eS6BLVh3iUWu7nJAqBMjGTtG90Tcclp+JyU4CeZL6ytVTOWduidNlxCXb1tx+/1tU18omznjV + 1iG/fIQA2dgpuvvHJZAnPwnkSWjRglI+99GJTpcRt376+y2sfOuw02WIU5BALlKVPq6HTjZ2Ctu2 + CYVCTpchokwCeZIZW+7nrm/ORSYk9e3Zlw/yp6d2OV2G6EdnQPolRWrSWh8TymVjp7AsSzZ1pgAJ + 5EkkI93NfbfPJzNDXt7sy7u7W/jBz992ugwxAJYtO22FgO5AnpeXh8fjweVyYRiGzKROMZ2dnSe8 + ciKSjyS3JKEUfO/6Mxg/KsvpUuJSS1uIG+9eQ1dQVhkSgZzUKcT78vPzmTt3LqZpEg6HCYVCvf8b + DJzFXVUAACAASURBVAZ73zdNE8uyelfZj34TiaulpUX+DVOABPIkce2Vk7j4nDKny4hLlqX51o/W + Ul0ns60ThWXJLx8hehiGQXp6+gkfPz5wa62xLKs3uB/9FgwGCQaDve9bloVt22ite/9XQl/8sSyL + zk753ZUKJJAngbNmF3Hdp6c4XUbcuv/hzazbdMTpMsQgSCAXon9KqRPaV062CbSvVXPTNE8I7z0r + 7sevuh8d2iW8x45pmnR1dTldhogBCeQJbkRxBnd/60wMQ3oK+/LMSwf487LdTpchBsm0pGVFiEjq + K7x7PJ4THnf8ivvRq+59hfejV91N0zwmuPf8WQxdW1sbti0/D1OBBPIE5vO6uP+2+eRme50uJS5t + 393CD37+jtNliCEwZYVcpKhQKERra6vTZZxAKYVhGPh8Pnw+X5/tMlrrY1bXe96O/phMCxk4rTVN + TU3ypCZFSCBPYLf+xyymnJbjdBlxqaE5yDfuWk0wJD/8E5Fta2ytMWSahEgRtm1z5MgRdu7cSVVV + VVJNUpFAOTSWZdHU1OTIDHJ54hR7EsgT1Kc/dBqXXzTa6TLikmna3PLjddQdCThdihgGy9IY7uQJ + JUKchAa01ppNmzaxZcsWp+s5QTI9OXDaYJ+cOPVk5qg2GXk2FSMSyBPQjMl5XHGJhPGTufe3m3lr + s2ziTHSWpfHITyiR5LTWh4CDwGjbtvvrF06mcJQOGIZh4HK5nK5lwI46wj4IJNIJZkN5VqWBNYAs + l8eA/LpLQFPGS5vKySx74QB/eXaP02WICJBJKyJFVCullgDlDC00OWXItWqt3cAjwKiSkhJOP/30 + yFUVRcFgkNdeew3TNAH+Syn1XD+fktA/xLTWYWD7ihUrwv0+WAybBHKRNDa928QPfyEncSYLmbQi + UsGKFSs0sPu9t5Rw8cUXe91udwdAeno6hYWFTpc0IIFAAMPoPeB8x/Lly19xsh6RXIz+HyJE/Gto + CvKtH60hFJYQJ4QQQojEIoFcJDzTtLnpx2s53CCHJwghhBAi8UjLikh49/xqIxu2NDhdhhBCxIUl + S5YYlmV5lFIurbVBdy+zrZQyly9f7lg/8OWXX64syzLC4XDvLs4BbGSNG5ZlHT31xFiyZIlLa43P + 57P//ve/R7Vf/KKLLlJer9dt27YbMJRSSmttG4ZhKaVCzz77bEL3qwsJ5CLB/eXZPfztuX1OlyGE + EI5ZvHixWynlB0YqpeZYljUVmKC1/v/s3Xl8nFd58P3fuWef0TLady+yvDuxY0de4iWxY0e3QgoU + aNkppVDe0pY1QKGULaxP+0BpgfI8UN4uT9l5eQrBkhMgi5MYx06ceInteJEsWfs6+3rf5/1jNBPJ + km3JljSSdb6fjz4fj2bmnnOPxtJ1n3Od6yokVc3EBEJSyk5d188Dx4UQJ4A+KWV4JI99Rum6XhyP + x/8cKNU0zQKUAvT29nL48OGZfvlpke5GOuJNhmHcDhCNRtsaGxu/29TUFJiu13rVq14lDMPwACXA + 7cDtUso6IUQF4CYVlEeklANSynO6rp8GnhdCdEgpg83NzaoyyjyjAnJl3nrx9CD/8N2T2R6GoihK + Vui6nksqWHsDsA+ollK6Ads1niaBmJQyAJwF/lvX9V8KIVqbmppmsgPNO4GHuCJVNhwOc+HChRl8 + 2Rmzb+QLKWVSCPEy8PDNHlTXdbsQotYwjNcArwZWADmAg2tXtkmQuuhqBx7Rdf1nwMnm5ubgzY5J + mR0qIFfmpf7BKB/7yhESyfmx1KkoijJdGhsbc4F7pZQfBjaQCtiEzWbD6XSSk5NDTk4OLpcLu92O + aZrE43FCoRDBYFCEQiFnLBZzGoZRAmwDPiql/LWu698wTfPUI488MhP1tctJzeqSm5s7ulrJvGWa + JoFAACmlVUpZejPH0nXdRuri6oNSygagELBYLBYcDgc5OTl4PB48Hg8OhwNIzdhHIhECgQChUMgW + jUa9iUTCC6wD/hw4ouv614AnVGA+96mAXJl34nGTD3/xWfoG1SZORVEWDl3XLcAGKeXngd2AS9M0 + 8vLyqKmpobKykry8PKxWK5qmZb4g1fHRNE0MwyAWizE4OMilS5fo6emxRCKRUinlO4EHNE37N13X + v9bc3Nw9E+fgcrnYs2dPJqicz6LRKE1NTTfV2r6xsVEAlVLKjwJvAwqFEMLtdlNeXs6iRYsoKCjA + 4XBgsVjQNC3TOTWdf2+aJslkEp/PR2dnJ+3t7SIQCOSaprkH2Ao82tDQ8BkhxEmVyjJ3qYBcmXe+ + 8p3jnHx5KNvDUBRFmTUNDQ1u4K3A54FyTdMoLCxk5cqVVFZWYrfbsdlsuFwucnNzcbvdmSBOCIGU + kmQySSwWIxgMUlhYSGVlJaFQiNbWVs6fPy9CoVAJ8GHgXl3X/0JKefTAgQPTugwphMBms2GzXSur + Zn4YlU9+Q3Rd16SUW4F/AdYClpycHOrq6liyZAlutxuPx0N+fn5mZtxqtY75ecbjccLhMIFAAI/H + Q0lJCatWraKzs5MzZ84wNDTkllK+WghRD3xS1/WfNDc3R6bh9JVppgJyZV754a8u8n8fVZs4FUVZ + OBoaGgqEEA8BfwY43W43q1evpra2FqfTidvtpqSkBK/Xi8PhQAiRmUWFV2bHk8kkI1VBcLvdxONx + cnNzWbt2LYsXL+bEiRO0tbVZDMPYCPy3EOIjDQ0NPzlw4MB8ahE/LzQ0NNiklG8XQnwZKLVarSxZ + soS1a9eSk5ODEAKLxZK5sHI4HDidzszqx0Q/33g8ztDQEH19fbhcLiorK7lw4QJnz54V4XC4Evg2 + cHtjY+NDTU1Nw9k6d2ViKiBX5o0XTg/yj98/le1hKIqizBpd10uBfwZeL4SwlJaWsmnTJgoLC/F4 + PFRWVuL1erFax/45l1JiGAaRSASfz8fw8DDRaBTDMMaVGUynvWzZsoWqqiqOHTtGKBQqB74thCjW + df07zc3NM7nhc0HRdd0BfAD4FJCbk5PDxo0bqaqqwmLJVITEMAwGBgYYGBhA0zQsFgtOpxOv10t+ + fj5utzsTnFssFlwuFy6Xi9LSUoaGhujs7MThcFBeXs7Ro0fp6+tzA++XUpbouv6h5uZmVS94DlEB + uTIvdPdFePCLz6pNnIqiLBiNjY0FUspvkgrGtcWLF7Np0yZyc3MpLy+nvLx8XOqHlJJYLJYJ5NJB + +GRYrVYWL15Mbm4uzzzzDD6fLx/4IpDQdf1/q/zjm6fruhX4S+AzgLugoIBt27ZRUFAwZtb7Sulc + 8UQiQSAQoLOzE6fTSXFxMYWFhZmVEUj9HNMrJp2dndhsNnbu3MnRo0dpb2+3SinfCsjGxsYPqJny + uUMF5MqcF4+bfPTLzzLoi2V7KIqiKLNC13WXlPJzwOuEENqiRYuor68nPz+f2tpa8vLyxqUtRKNR + urq6GBwcJJF4pf+PYRh0dXURi03ud6iUkqKiInw+H6QquHwZWK7ruv8mTukuSFUGaWlpuSVyyOPx + +OiLnVfrur5oEk/zAu8C3EIIioqKGBwcZGho6vuiCgoKCIVCdHV1UVhYSHl5OU6nM/O5sNlsLFq0 + iLy8PFpaWti8eTNSStrb2zXgLVLKnoaGhr87cOCA+uM6B6iAXJnzvvQvL3LqnLqIVxRlYWhsbNSk + lK8H3g1YSktLufPOOyksLKSurg632z3m8YlEgp6eHrq7u8cE4mkDAwMcPHhw0jPlE8gHPnSjTx4t + Ho9z9OjR6TjUXPOaka9Jk1Jy/vx5zp8/f0Mv6PV62bt3LwDd3d0MDg5SXl5OaWlp5oJHCJGp0nLu + 3Dnq6+uJRqP09fVZgfcJIY40Njb+rKmpSXX6zDIVkCtz2v/5vxf45W/asj0MRVGU2VRLKlXE5fF4 + qK+vp6ioiOXLl+NyuTIPklISCoVoaWkhFAqNbus+xui0FY/Hc83UCGXuSyQSxGIxYrHYmIuseDxO + e3s7Q0NDLF26FLfbnflZu91uli9fjmma1NfX8/jjjxMOhz3AV6SUR4DWrJyMkqECcmXOevbFPr7x + b2oTp6IoC8f9999vN03zU0CNpmmsXbuWkpISli1bNi4YHxgY4NKlS5Oug22329m7dy9Op3OGRq/M + hosXL151lUFKSSAQ4MyZMyxZsoTCwsIxQXldXR3JZJI1a9bw/PPPY5rmUuCjuq5/sLm5efzyijJr + VECuzEldvWE+8ffPYRhqFU1RlIXDNM11pFIfRFlZGbW1tVRXV5OTk5N5jJSS3t5eLl26NKU0lFup + BvhCNroSy9XE43EuXLiAYRiUlJRkgvKcnByqqqqIRCK0t7fT09MjgDcC3wFOzOjAlWua/71rlVtO + LG7w4JePMKQ2cSqKsoCMVOB4H+C1Wq2sXbuWoqIiSkpKMo+RUtLf3z/lYFxZeAzDoLW1lYGBgUw6 + kxCC0tJSCgsLWb16dTq4LwLe3djYqCZps0gF5MqcIiV89hvHOH1ebeJUFGVhEUKUATpAcXExZWVl + 1NTUjJkR9fv9tLa2qmBcmZR0UB4IBDLfs1qt1NTUUFFRQVFRUfrbr5FSFk14EGVWqKshZU75j//v + HAee7Mj2MBRFUWZVY2OjkFJuB8qFECxZsiTTMj0tHo/T0tJy0y3bJ2KaJoZhYBjGVTeHKrMj3Y1z + Mqkpk5EuNbl69WrsdjuQSl3xer0sXryYvr4+pJSVwBbgl9PyosqUqYBcmTMOv9DHP//H6WwPQ1EU + ZdZJKS3A6wGLw+GgqqqK4uJiNE1L3097ezuRSGTaXzscDvPSSy/R1dU1YdlEZXZZLBaKioq47bbb + yM/Pn5ZjhsNhOjs7Wbx4caazZ1FREdXV1Rw/fpxYLGYDXqvr+v7m5ubpv+JTrksF5Mqc0Nkb5hN/ + fxTTVDMziqIsSDnAnQD5+fm4XC68Xm/mzlAoxMDA9Hc6j0QiHDx4kL6+vmk/tnLjAoEAQ0ND7Nq1 + a9qC8r6+PkpKSjKrLgUFBbjdbnJzc9NNo7YDLiBwjcMoM0QF5ErWhaNJPvjQYYb9kyvdpSiKcguq + BAohFSh5PB6s1tSfaNM0uXz58rTnjUspOXPmDH19fWiaxrq7trFh+10ITW0vyx7Jy8dP8NxvH8Pn + 8/HCCy+wc+fOzErJzUgmk3R0dLB8+XKEEFitVtxuN4WFhfT39wMUA+WogDwrVECuZJWU8LlvvMD5 + 1pvpyKwoijLvVTDSTj03NxeHw5EJwqLR6JhNedPFNE16e3sBWLbhdt7y/r/Ck5s75jEacK02QjfS + YujG2hJN7Vk32vpoOs9n4vVeiRy5TwLmqH+n3b55M8l4nCOP/paBgQGi0ei47qw3yufzEY1Gcblc + WCwWHA4HOTk5CCGQUrpJBeTnpuXFlClRAbmSVd//6cs8+pTaxKkoyoJXCtiFELjdbux2ezpIor+/ + f0Y2ciaTyXSqAuU1i8YE41YgF4EbgRVxwwHufHZlQD36tjkSWKcDajPzJa+4Pf5rdAA+UdBudzop + q65GCEE8Hp/WvP5kMsng4CBVVVWZuvTpjp5SSgepEohKFqiAXMmqYFjtHVEUZWHTdV0ABfBK8570 + 7LhpmgwNDc38IEZF3A6gFA3bPA7D5VX+nb599YD6lcB6okA6/bzRx73Wa92odCOfmah4MzAwQEVF + RaaSy6hGUQLw6roumpub1YauWaYCciWr/urtq3n+ZD8nzs7CHxxFUZQ5SNM0pJT2dPA1Ol84Fotl + ZrFngwUomQPB+NWC3NTsshwTSI8PqK8dTF+ZIjITAfVclv5MuVwuIPV5S18AMLJKo8w+FZArWWWx + CL704Cbe9IHHCanZckVRFiDDMBBC+CE1I5pMJjNpCqFQaFabADkQ2G8yGJ/K7PSNBNSjj7vQgunp + kEwmCYfDOJ1OEokEyWRy9Ey8r6mpSb2VWaACciXrqso9fPqvN/Dxrx7N9lAURVFm3YEDB6Su6wOk + Yk8tHo8Tj8cxTROfzzerY3Fd47504GxcM90jFUwbUmIKMWrzopqdnkv8fj9er5dEIkE8Hk8H5ElA + VVjIEhWQK3PCvh1VHDzSw8O/a8/2UBRFUbKhB4hKKd3BYJBYLJaZyZxNV9u+GUMyjCQ2EnDD1YPp + oUiYpy6+zPKyClYWl83jTPRbVzAYxDAMYrEYwWAwHZBHSH0OlSxQxUaVOeMTf7GeJVU52R6GoijK + rBNCdAFBKSV+v59YLEY0Gp2R6ipTFUXSg0kISZLx1ULGBuaSn75whAdPPMe3jz5DOKH6S8xFyWSS + aDRKLBYbvQoTArqzOKwFTQXkypzhclr44oObsFnVx1JRlIVD13UNWMLIqvXAwACxWIze3l5M07zm + c2eaBAZHAvHJCMXjHBvoxQSOBv3E4iogn4vSNejj8fjoKj4WYMlrX/tataiRBSryUeaU1XVe/vId + q7M9DEVRlNl0t5TyR4x06gyFQgSDQQYHB7M+Q24AiSlkd/cF/BwOBwEYShr0hIIzNLKZkzAMErO4 + kTYbEokEg4OD+Hy+0WlRJcBPY7HY9iwObcFSAbky57z9tXXsrC/P9jAURVFmnK7rpcA3gfJ0M6Bk + MklLS8uV1S+ywhyVM349Evht63kCI7P6BpIT/fMrJTkcj/OdZ5/iu0efJjKNDXnmmnQ1n9bW1nSV + n3Q98kop5bcbGhqKsz3GhUYF5MqcIwR85gMbKC50ZnsoiqIoM6axsdECvAdYJYRg165dLF++HID2 + 9nYikUhWxwev5IpPRjgR53hPZ+a2BDr7ezGzfFExFWf6e/h22wW+03qBgWAg28OZUeFwmMuXLwOw + cuVKduzYka5HvlYI8ScjqVTKLFFvtjInFeY7+NwH70BTDQoURbl1rQbeD2jV1dXce++97N69G03T + CIVCXLx4Mesz5FOZI+4P+Pl9KIAAqm12AM6HAkST82OmWQLPtreSlJKINHlpsD/bQ5oxUkrOnz9P + OBzGarVy7733snfvXioqKiAVG34EWJHdUS4sKiBX5qxtd5Tyttcuy/YwFEVRpp2u6y7TND8LlNps + Nvbt20deXh51dXUsWbIEKSXnzp0jGMxuDvZk88cl8FjbRYYMg1UOJ29dtgqA05EQsXmS+hFJJHhp + sC9z+/yof99qAoEAFy5cQEpJbW0tS5cuxev1snfvXqxWK0AF8KmGhga1VD1LVECuzGl/9Y7VrFtZ + kO1hKIqiTCshxB4hxP0At912G+vWrQPA5XKxceNGLBYLoVCI48ePZ3Vj52RD6UgiwYtdHQBsLyxm + T/US7EKjM5FgIDK7tdRvVDAa4cioNJVB3zDGPEq3maxEIsELL7yQmR3ftGkTTmcq7l6/fj1r165N + P/S1wI5sjXOhUQG5MqdZrRpf+sgmPG7Vw0pRlFtDQ0NDsZTyS4ArLy8PXddxOBxAKlhyu91UV1cD + 0NbWxvnz52ctdeXKJMHJXgoMhAL8PujHiuDORbXku90ss9sxpOR43/wobf18bxf9xitn3BYN33J1 + 1E3T5OWXX87kji9atAiHw5G56HM6nTQ0NJCTkwPgEUJ89b777ivM3ogXDhWQK3NedYWHj7/39mwP + Q1EU5abdf//9mhDibcA6IQRbt26lvPyVqlLDw8OYpsnGjRspKCjAMAxOnjxJR0fHrOeTpxoAXf81 + JfBkWwv9RpJau4M7yirx2B2sdLqRwOX+vikUTswOQ0pOdlwa870L8ei8SbeZDCklly9f5qWXXsI0 + TYqKitiwYQOGYYxuDkR1dTVbtmxJb/Bcr2namx944AEVL84w9QYr88IDe2q4f3d1toehKIpyU0zT + XAF8DNAqKiq45557sFgsABiGQXd3ajbZ4/GwefNmPB4P0WiUZ599lp6enlkNyiVMquRhNJnghc52 + ALYXFJHrdOKwWqnIzQOgJeib8xs7Q/EYLwynGuTcledFE4KORIJwLJrlkU0PKSVdXV0cOXKEWCxG + Tk4OW7Zswe12Z+4zRmqvWywWdu/eTVlZGaSaBX3cMIyl2Rz/QqACcmXe+OT71rO4Kifbw1AURbkh + uq47hRCfACqsVit79+4lPz8/c38wGBxT6rC4uJitW7fidrsJh8M888wztLW1ZQKnmWYiJzWzPRgK + 8vugDwuwqWYJNs2CAGpLygB4KTz3N3YOhUK8EAlhEYJ3rrqNKpsNQ0pO3QKVVgzDoLW1lUOHDhGJ + RPB4PGzdupWCglf2Z4XD4dENgvB6vezZsyd9sVgDfPT+++93zPrgFxAVkCvzhttp5UsPbsJmVR9b + RVHmpe1SytcDrF69mvXr12fukFLS3d2Nab4yJy2EoLy8nO3bt5Obm0s4HOb3v/89L7744qzUKJ9M + DXIJPNV+ie5kkiV2B5sqXlnJ3FBchlUI2hNxfNHs11S/lmc6LhGTktUOJ7VFJdQ5XABcnOcBeSQS + 4dixYzz77LNEIhHy8vLYsWMHZWVl6ZQUIJVb3t3dnVmBEUKwceNGVq1KVcuRUr7FNM2tWTmJBUJF + Nsq8srrOy/vetirbw1AURZmSxsbGAuB/AJ6cnBwaGxszlS0AotEofr9/3POEEJSWlrJz505KSkpI + JpOcPn2axx57jLa2NhIzOPOc5PoBeTyZ5NhI7vVd3kLynK7MfTlOF0vsDpJScnwOd+yMGwZnRhoa + rc/Jpywnl2UuDwAD/vlZaSUej9Pa2srvfvc7zp49SzKZpKysjF27dlFcXDwmGE/z+XzEYrHMbZfL + RUNDA263GyAX+GpDQ0P+uCcq00IF5Mq88/bX1bF1Q0m2h6EoijIpjY2NmpTyTcB6IQRbtmzJVFGB + 1Oz4wMDAVcsbCiEoLCxk165drFy5EqvVyuDgIE8//TSPPfYYLS0thMPhMbPr02Eyof5gOMjhwEi6 + SvUS7CP58AAeh4OVDhcSaOvrvWpwH00meXmwn1CWKpqEYlGOBFKbGldXVOG0WCn2ptI5LkUj16y0 + MhyNcGF4kOQ0v/c3wjAMwuEwFy9e5LHHHuPQoUMMDQ1hs9lYs2YNO3fuxOv1ThiMQ6rCz+Dg4Jjv + LV68mPr6+vTNTcAb9u3bpzr2zQBVS06ZdzQh+MKDm3jjXz/GwFDs+k9QFEXJItM0lwgh/gawlJWV + sXv37sxGToBkMklf3/Wb0LhcLu644w5qamo4duwYg4OD9Pb20t/fj9vtprS0lPLycnJycnC73dhs + NjRNu+Gc88k0BTrU0cblZIIlNjubK2vG3Oe02qjKyQX/EJcCPmLJJE7r2LDDlJKfnzzGDy6c4Q+q + FvPuzTuwarM7V9jiG+J8LEqOpnFX5SIAlhQUAXAxFiWWiJNrH58+HY7F+Icnf8OJkJ/PbtnFHVec + /0yTUhIMBgmFQgQCAbq6uujv789cnGmaRmlpKXfccQeFhYVjPnNX09vbS2lpabo5EOm9Di+99BJ9 + fX1WIcSnrFbro0DbDJ/egqMCcmVeKsx38PkPbuSvPnuIebiaqCjKAqHrul0I8TEp5SKLxcKePXvw + er1jHuP3+8ekClyLxWKhpKSElStX0t/fT29vbyYou3jxIi0tLVitVqxWK5qmoWka8fiNzTxfb4Y8 + ZiR57vJIukp+AXku15j7BbCkuBQ62zgVDhFNxMcF5F1+Hz++eJaXE3F+2dnGGyIhij25NzTeGyGB + Z9tbkcAdLg9edypVZVVBMRYh6EwmCEVjE44pGIvyy6E+IlJy4MxJ1ldUo11l9nkmRKNRnnzySUzT + JJlMIqVECIHVaiU/P5+ysjJKSkooKipCm+RFTjQaJRAIjNnwWVBQwO7du/nZz36GaZqLpZQfvO++ + +z7+yCOPzO2duvOMSllR5q1tG0t562uWZXsYiqIo17JFSvlmgBUrVrBx48Zxm+m6urqmVM4wHo9j + miZer5e6ujrWrFlDbW0tRUVFCCFIJBJEIhEzFArFAoFAPBaLTbnVpwSM68yQD4VDHPYPYwE2Vi/G + YRk/x7expBxNCFriUUJXXHQkTIOfnHiO0/HU98/FYxxsa5nqUG9KJBHnpYFeANZ4C/HY7QC47Xaq + bXZMKTkxOPHqxfH+HuIjP7czQT+BSV5UTadYLCYTiQRCCIqLi6mtrWXt2rXU1dWRn59PMpmc0gVZ + ugTilZuL6+vrqaurg9R11p8KIe6c9pNZ4FRArsxr7/+TNaxbWXD9ByqKosyykQ1w/wPIc7vd6LqO + 64pZ5CvLzV2PlDLTPAhA0zScTifFxcUUFBSkA3sJ/AZ4M/Au4PtTHftkKqwc6ergUiJOpdXG1qrF + Ez4m3+1hkc1OUkpOjAS+aa2DA/x392UEUKCl0imeaWshMos1y4PRKEeCASB1UZGe4bbbbNSNbFBt + maDSiiklL3VeJp0MdCwaZigUmJUxjxIEXgKklJKCggKKi4txOByZGXHTNPH5fFO64Luy/CbAFZ9f + r6ZpX2loaJi9pYwFQAXkyrxmtWp88SObcLtU9pWiKHPHfffdJ4QQrwfuBKivr2fJkiVjHiOlpKen + Z0o53olEYsIAPh6Pj+7m2SOE+Ovm5uZfaJr2AyHEs1Mdv8m1mwLFDYMjbRcB2JZfQL7LPeHjXHZ7 + ZmNnS98rlVaiyST/dfwoHckkm10ePrhmPRrwuG+I3gmqzcyU53s66TeSVFltrCsuy3zfabVRO1Jp + ZdDvw5Bj341wIs4J3ysbIMOmyVMds55WHRupa98vpaSjo2PCqjuhUOiqG4YnYhgGfX1944L42tpa + Nm3aBICUcpsQ4tW6rqsNntNEBeTKvFdT4eFj770t28NQFEXJ0DStGvgUYC0pKeHee+/NbJRLi8fj + DA8PT+m4wWBwXACfDuxHZjUNKeW/CCHO3cz45XWaAg2FQzzrH0YDNlYtGpcbnua22qjxpBq6tfuH + iRmpwPBkTycP9/dgEYLXr1hDQ+0Kbne6GTYNDpw/PSsdSQ0pOTkSRG/y5JI7avXCIsSoSithQvGx + gW4wGuF4OIgAXCOz0We6O4jPUtOmUU6TWgExwuHwhIG0YRgEg8EpHXRwcHBccG+z2di3bx9FV/C1 + yQAAIABJREFURUUANuAzQOVNjF0ZRQXkyi3h1fcu4v57qq//QEVRlBnW0NBgAz4ELEm3IS8sLBz3 + uOHh4Snl9xqGMWGt8kgkQm9vJh3klKZp396/f/9NRbQG105ZeaGnk4vxGOVWK9url1z1cUIIaopL + gVTHzmgiQTAe479OPIfPNNmb62Vv7QoKXG62j3T2fKq7A/8stKwPxWO84BsCYEVxKS6rbcz9S0cq + rVyIx4hdUfrw+Z4uhg2DRTY7r61ZggYcC/rxRSeffjQdZCr6/jpwFqC7u5todPx75/f7p7QSE4vF + JrxYLCoq4u67706nxNQB79N1XS1RTwMVkCu3jE/+5XoWV+VkexiKoiibgD8FxLJly6ivrx9X+zmZ + TNLd3T2lg4bD4XGzlqZp0t7enk5JiACfaGpquun2ktfK4k6YBr+/dAEJbM3z4nVPnK6StrG0HAGc + j6U2dh68dIFHfEN4hMab191BrsOJJgSNy9fg1jSejYQ40997zWNOh6FwiBciYSxCsGPR0nH3ryoo + wiIE3ckEwVGdRg0pOdN1GRPY4Mnh7cvX4tUsnI/HuDQ0OO44M625ubkH+DQQTSQStLe3j6tJP7LR + d0rH7e7uHhfECyHYunVrOv1KAO+VUq6f4OnKFKmAXLlluJ1WvviRTdis6mOtKEp2NDQ05AghvgR4 + r+h0OMZEG+euxTTNCWcsfT4fPp8vffO3I1837Vo1yIfDYY76hlLpKhU1OK+YWb5SkTuHSpudmDT5 + TftFfnLmJHEpeaCohI0Vr6xsVnsL2ZmThyElvz1/hsQkm+1IKYklE0QT6a840UScSDxOIBplOBJm + IByiJxigM+Dnsn+YluEhfnn2JDFpssrhpCJvfANKl93BopFKKydHVVoJx2O8ODKzXltYQnluPus9 + OZjA020ts5JucyXTNPcDT0LqM3HlSoqUkqGhoSk1j4pEIoRCoXHf93g86Lqe7jRbBDzU0NDguYnh + K6g65MotZs1yL//PW1fxz//+UraHoijKAjOywe3VwHaATZs2sWzZ+NKspmnS3d09pcAtFouNq1We + SCS4fPly+jj9wN80NzdPS+29a20BPNXXzdl4jDKLlZ0TzCxfyWV3sNLhpCMR53+dPk6/YVBmsfDW + 9fW4bK8E8267nW1VizngH+aJgV7eEw5RknP9Qh4ne7v5z+NHiSQTmKZEShNpmkgpSSIxZKqEY1JK + kqRmuJNA18hqwx05+eQ6XOOOa7NaWe500xKP0TI4kPm+PxrhZCSEBmyvXoLHbmd9QRGPBXycHUp1 + HM2ZoJHQTHrkkUciuq5/DLjTNM3C9vZ2PB4PtlHvbzweJx6PpwPp60qX5MzNzR23wrNixQruuOMO + Dh06hBBiD6ADP5++M1p41FSicsv5k9fXsXVDSbaHoSjKwlMBfBawFxUVsW/fvjEBUVq6+cpkpUsd + jg7gpZT09vamK64YwPetVuvpGx24YUoShoEpU5s5I6ZBwhj/FUkmONhyDglszs2nwH39NEG3zcaS + kY2dvYaBCbymvJplhcVjHieAPUvrqLHauJiI8+RIFZdriRlJfnLiOX4x0Euzb4hHAsM8GvTzm3CQ + 30ZCPBkJ80wswrOxKC/G45xOxLmYTNCZTKJpglqbnd11K7FN0DjHZbWxdKRR0GDAR3JkdvlI12UC + pkmt3UFVvhdNCG6vXoJNCJ4PBxkI+InG49f/Slz9K3Fjm0NPAD8AzHA4TH9//5jPTHqVZSoXgoFA + YMKc9PQGz5EGQg5Ss+Rl4x6oTJqaIVduOZoQPPSRTbzp/Y8xMDT7jRoURVl49u3bJ4D7gTpN09i1 + a1e6GsUYUkoGBgamVIZuovzfaDRKT0+mjODLwNcefvjhyecjXOH53k66Dj/JH9Wu4vaCYv79xBF6 + 4+MDsUgySXN/70i6SvWYGe6r0YSgsqgEejoBWG6z8+bbNmGfoJV7kSeXXQVF/FdfN0+3XeT+5Wuu + +RpD4RBPDafytv+krIp1xaW4LBasQsNlsYCmgRAIoSE0AUJDEwJN0xCahtvuoK5g/M8pPe5ibwF0 + X6YlGiGUiOOx2Tnb3YkENnhyyR2ZbV5bVJK5kPjbJx8hR7t+m/priVw6T94Un9Pc3Gzquv5loAFY + 3tXVhdfrHVP7Pr0PwT7SAOl6EokEg4ODVFZWjpslLykpYefOnfzqV79CSrlSCLEX+K8pDlsZoQJy + 5ZZU5HXwuQ9s5K8/d4gspPMpirLAWCwWG/BHgCguLmbLli3jAhhIbebs75/anssrK2SkN3KObPCM + Ap8Z2dh3wy4HfDza3sI95TX4PLkcuHyJw9eoGLLIauXuxZPvlLyhpBx4EYDXLaqlIn98zjaA3WJh + 97JV/LCvmyf8ProDPpZeMZM+2sG2Vi4nEyy22Xn3ndsozclDQCoIn/Torm5pQeq1L8ajxBNxhIQX + /CP548Wlme6kHqeTnYUltPZ2cngaKsQsTyamHJADNDc3d+q6/hDw3UQi4bh8+TLLli3LNAoyDINA + IDDhxeLV9Pb2UlpaOm61R9M0tm3bxtNPP83AwIAGvEHX9Z82NzdPvnSQkqECcuWWddemUt786mX8 + 4L8vZHsoiqIsDAakKlFcrcScz+cblwt+LclkclwNab/fP3oj55NSyl/f0GhHKXZ5eKCkAq/DiQCW + FxSxyJg4aNYQbCyroCxv8iHjEm8hr/MWIYTgdWs3YBFXz5i9vayCO1xunouEaT53mvdu3pHpoDla + NJnk6OVWAHZ4Cyl050z4uJuxwluIVQh6Egn80QhWS4KXIpFUZZZR5R4dFit/Xr+dPd0dMIWNk1dz + zJ/gzA0+VwjxCynlu4B7hoeHCQQC5I+6AAoEAni9XiwTrFBMJBaL4ff7JwziDcMYfeGZEEKoKbAb + pAJy5Zb2/j9Zw/Mn+jlz0Xf9ByuKotwgIURCSvkjoKGnp0f7j//4D3Rdp7a2NtMQyDCMKW/mvLLU + YTKZ5PLly+lqGYNSyo8fOHDgpotfb6us4Q279lGuWbELwSe277lmHXKrRbtmUH2lPJebT+9pRCBw + XSddIt/p4q6Scp5ru8jTPZ28JRYl3zl+0+VAKMBT/mEEsHVx3YQpMDfLZbez2O7gQizKiYE+4skk + EWmy2uGkNHfsBUlpTi6ldaum5XWDL76UKix+A5qamoIjGzwfMU3Te/nyZTweT+ZzmO72mpt7/Q2z + kEqz6u7upqCgIDPTnkgkuHDhAs3NzekVH0NK+bPm5uZrVcxUrkFt6lRuaXabxlf/ph63S117Kooy + c5qamqQQogUIA5w9e5bvfe97/OIXv8hsrguHwxOWkbuaK0sdSinp7+9PH8MEfmia5vHpGL9V07Bb + rVg0DVMI7FYrjmt8TSUYh9SGTY/dgdtuv24qiSYEjSvWkqNpHI2EeKlv4nrtj7deoNdIstzu4M6K + qimNZ7LsVhvLRy4GTvX3cK4nlT9+e04eeY7JVSvJBk3Tngd+ApihUIiBgYExF4LDw8NTKoEYCoUI + h8OZzcQ///nP+dd//VfOncs0hA0CrdN3BguPCsjnoYNHuhn2qxStyaqp8PDR99yW7WEoinIL03Xd + LaX8KJADYLfbCYVCPP7443zrW9/iiSeeoLW1dUpBUDQaHdPJMxaL0dXVlb55Afjyo48+evP5EVeY + C1OcVfledubkj6pJPjYFKJxIcLSzHYC7Corxuq7dnOhGOa1WlrhSlVae7u3m8Ej98WUl5dhmYEZ+ + uuzfv98AvgC0SSnp7Owckyo1URnNazEMg9bWVh577DG+9a1vcfDgQcLh8Oi88nwhxId1XR+/lKFM + igrI56Ge/iif/vrzarPiFLxm3yIa766+/gMVRVFugBDiPmAfgNfr5Z3vfCf19fVYrdbMjOJPf/pT + 2traJlVh5cpSh6Zpcvny5XSAHge+2Nzc3DET53KtpkCzxW2zs61mMQBPDvYzdMXKQn/Qz1MBHwLY + Ubsc6wRlC6eDJgQlBYUAnItFOR2LYhOCHdWLZ+T1ppOmaZeBvwcS8Xiczs7OzOdpolKaV5NIJGht + beXHP/5xZsXHarWybds23vGOd5D3yl6CVwO7Z+h0bnkqIJ+nnjraw48evn6NVuUVn/iL26kqm5lZ + FEVRFq6GhoZSKeUXAKcQgh07dnDbbbfxmte8hrvvvpuioqJMucOnn36aZ555hoGBgWvOlsfj8TGl + DoPBIENDQ+mbh0zTnLEmLJMvyDizdi+pY7HNTksizuOXXtmcL4HfXDzHsGmw1unitpLyGR1HbUHx + mDSbNQ4XhZ7r11/Ptv3790tN0/4P8CzA4ODgmA3CkUhkzP6EK5mmSX9/P8888wyHDh1icHAQKSXF + xcXs3r2bBx54gPXr13PXXXelN3a6gC/run71sjjKVamAfB77xv97ijMX1GbFycrx2PjKx+uxWtXH + XlGU6aHrukUI8S5gNUBNTQ3bt29HCMHQ0BAVFRXs2bOHTZs24fF4MAyDtrY2HnvsMV588cV0Y58x + pJT4/f5MwJ5MJmlvb0/fHgY++sgjjwTHPXEaSFJdLeeCIncOO0dqhB9qbyWcSKXvhONxjnanFge2 + FRST75rZLInl3kLso3Lmb5vj+eOj7d+/3w98FPAbhkF7e3umAlC6BOJEwuEwx44d4/HHH888x+Px + cOedd7J7927KysoYHh4mXXO/srIy/dR1wNt1XVd/aKdIvWHzWDxh8vGvHiEUnivzGXPf2uVe3vvm + ldkehqIot45VwAcBzW63s3fvXvLy8ojH45kZbYfDwcqVK7n33nupq6vDarUSjUY5deoUv/3tb2lt + bR0zU2kYRmYmU0rJ4OBgeiOnBH5mt9ufn6mTMUdeZC6wWSzcW7cKixA8ERimy5+agOoJ+Hgm5Mci + BPfUrZzyBtOpcthsLBpVGWZ5WcWMpcjMBE3TjgK/BGQwGGRwcDBzXyAQGJNCla6e8pvf/IbTp08T + jUax2WysWLGCvXv3smLFChwOB5CacU8kEuTl5XHvvfem88k14EEhxPLZPMdbwfz5RCkTau8K8dA3 + X8j2MOaVP/2j5WzZUJLtYSiKMs81NDS4gL8DygDWrl3LunXrABgaGhqzIVMIQV5eHvX19dxzzz2U + lpYihMDn83Ho0CEOHjxIb28vpmkSCoUyQdIVub9tQoiHfvnLX95QX/XJMJBM+y7Rm7CupJyNTjcB + 06T53EsYUvLIhbOETJMNThcrCmf+d3mq0koq3dEhNO6qrJnx15xO+/fvTwCfBjqklHR0dGQ2dKZL + IBqGQU9PD08++SSHDx/G7/cjhKCsrIx77rmHTZs2kZubO6bZVSwWY3h4GCEE69evZ/Xq1em7KqWU + f9PQ0DA/lhHmCBWQ3wIeOdjBrx9rz/Yw5g1NCL7wkU0UeR3ZHoqiKPPbPcAfAOTn59PQ0IDD4SCZ + TI5uaz+GxWKhvLyce+65h/r6epxOJ4Zh0NnZyRNPPMFzzz2Xea5pmqODpwTwVdM0Z/SX/VyaIQfI + c7q4q7QCgKd7uujwDXOkN1VpZktRKXkT1Cefbk6rlcUjr7PW6STf7Znx15xumqa1Sim/ASRjsdiY + evjd3d0cPXqUJ554gq6uLkzTxOVysWXLFu6++27Kysqu2kSou7sbwzBwOp00NDSMrm3+BiHE9lk5 + uVuECshvEV/69ou0Xp6RlMJbUpHXwWc/eAfT3NRNUZQForGxsUgI8WXALYRg69atmTzaYDBINHrt + 9ul2u53q6mpWrVqVCXhisRhnz57l+PHjdHV10dnZycDAQPopR4D/OnDgwIzGy3MtINeEoHH5GnI1 + jeciIX559iSHQwFsQnBv3epp78x5tTFsWlzLdpcHvXIRec75N/G7f/9+KYT4V+AYQG9vL52dnXR2 + dnL8+HHOnTtHPB7PXDCuWrWKqqoq7Ndp4hSJRDLpVTU1NWzZsiU9i54DfLWxsbFgZs/s1qEC8ltE + JGrwsa8eIR6fS4uNc9v2TWW86YHabA9DUZR55oEHHtCklO8AbgOorKxk165dWCwWTNOku7v7uvXG + pZT4fD4cDgeLFi1i5cqVuEY2J0ajUdra2ujo6Egfpxv4UHNzs39mz2xu1CC/UkV+Prty8zGBb7We + IyYl9W4PS7yFszaGHUvr+Pp9r+atG7fMeM76TGlubh4CPgz0pctotre3Zy4ePR4PK1euZNGiRdjt + dnw+33XLIpqmSU9PD6ZpYrFYuOeeeygvz1S92SClfNO+ffvm5xs2y9SbdAs53+rnn/79VLaHMa98 + 4E/Xsqo2P9vDUBRlHjEMYxnwEUCz2Wzce++95Oenfo9Eo9GrVq4YLZFIZMoaapqGy+Uak58LhEhV + VHkBeAepGfIZl5xT8+MpqZrkSwFIjgSIm0vKyXHMXtqhRWgUuNzYLfO+6/PTUso/A06Q+nyNKfA+ + +nMYDoevWRYxze/3Z3LSvV4vu3fvxmq1AliAv7FYLHO/aPscoALyW8wPf3WRxw9P3GZYGc9u0/jK + x+txu+b9L1lFUWZBY2OjA/g4UAWwatUq1q9fjxAiU2t8Mo1/AoFApvxc+nmj6o5fBl4LbBNC3C2E + +E1zc/OsRMpzNSi4Z/EyltpS6RMOobF32apZSVe51Yx8jh4Gdkgp75JS/iHQBakAPF1rHMZW+7mW + RCKReZ4Qgo0bN7J8eabIyiLgQV3Xr537oszZ/3vKDZISPvuPz9PdF7n+gxUAFlV6+Mi712V7GIqi + zANSyh1SyjcC5OTk0NDQgHMkpziZTNLf33/dYySTyTGz6LFYbHQllYSU8uuapv22ubn5TFNTk7+p + qWnWpq015maQW+jxcPdIRZXtOblU5XuzPKL568CBA7K5udl/4MCB00KI3wDfBJJSSjo7O8dUB/L7 + /ZkLx2vp6+vLXIi6XC50XcfjyWx+fZuUcuu0n8gtRgXktyB/MMHf/s/nMM25t/Q4V/3hfYvRd1Vn + exiKosxhDQ0NBcBXgJz0Rs5FixZl7vf5fJml+2sZnQqQrqQyKgh6Hvj+/v371S/wUWyahTetv5M/ + rVzEuzdsxmNXVbKmQ3NzsxRC/C/gOIy7OCSZTE7YvOpK0WgUv/+VLQ5Lliyhvr4+fTNPCPElXddV + fug1qID8FnXs1ADf/fHL2R7GvPLJ991OVZk728NQFGUO+oM/+AOhadobgDuATH3mdDk4wzDo6uqa + 1Ca44eHhzO0rGrUEhRAfP3DgwPCET54Fc/kqoLawmAe372FTZc0cncefn5qamgaEEJ9iJJ98YGBg + TGOq4eHhSW1SHr2Z2Wq1smfPHkpLS9MP2SKEeM0f/uEfqh/dVaiA/Bb23R+e5cjx6y+fKik5Hhtf + /tidWK3qv4WiKGMlEgm3lPIDgMVisbB792683lfSJsLh8KRnEtOz4clkkvb29nQQI4GHk8nkoRk5 + gUmaywG5AOwWi8odnwGapv0OOABIwzBob2/PpKrEYrFJrfyEQqEx/wcKCwu5++670xetVinlhyKR + yMwXjp+nVORxCzOl5O++9hzD/vj1H6wAsG5FAX/+ppXZHoaiKHNEQ0ODVdd1L1DPyEZOp9OJ1Wrl + 5ZdfprOzk3A4POlSh8PDw5lZ9MHBQUKhTJGLbuDTjz76aFZ/Yc/lgFyZOb/+9a9jwKeAPkit3AwN + DQHjP7dXk+72GQ6H6ezs5OzZs9jtdhyvVMOpAW5vbGzMb2homLjT0AKmSkvc4noHonz668/zjU9v + VU1wJuldf7ycoyf6efbFvmwPRVGULNF13QWsA94ENJCqFpELqZnAH/zgB1gsFux2O3l5eeTk5FBd + XU1JSQk2m23CY8bj8UwllStydZPAt+Px+PmZP7NrkyokX7AMwzijadr/FkJ8Qkpp6ejoIDc3F4fD + QSQSIZFIXLVRUDwep6+vj8OHDxMMBgkEAsTjcQzDGL0ptAg4IKVsE0I0NTY2/khK+VJzc/O1u2gt + ECogXwCeOtrDD391kbe8WjXBmQxNCD7/oY286f2PqdUFRVlgGhsbraQamnyUVCCeDyCEwGKxYLVa + M3WaDcMgHA5n8m0vXrxIYWEh69atG9duXEqJ3+/HNE3S1SxGpQEcB/7ld7/7nYqGlax59NFHZWNj + 4z9LKV8D3BaNRunp6aGmpgbDMAgEAhQVFY15TjKZpLu7m1OnTjE4OJgJvjVNw2q1ZgJ4KSXJZBLD + MPKklOuAtVLK9wC/1nX9H4CTzc3N168XegtTAfkC8U//doqNa4tYtUxtcp6M0iInn//QRj7w+d9z + nVU6RVFuEY2NjQVSyr8EPgAUCyFwOp0UFxdTWVlJfn4+LpcLq9WKlJJYLEYwGMy0IQ8EAvT29nLw + 4EGWLl3KunXrcLtTG8VH13QOhUIMDAykXzYkhPhUU1PTwERjmm3q193C1tTU1Kvr+ueA/wRcfX19 + FBUV4fF4CAQC5Ofnp5v+EAqFOHnyJC0tLSSTSTRNw+v1UllZSUlJCbm5udjtdoQQmWotfr+fjo4O + BgYGRDQa9Uop3wrsBb6u6/p3mpubfVk8/axSAfkCEU+YfPyrR/jBP96Dx61+7JOx484y/vhVS/nx + wy3ZHoqiKDNM1/UqKeU3gQcAq9vtZvny5dTV1WWCC4fDgcViQUqJaZrEYjGi0SiRSIRgMEhHRwen + T59mYGCAc+fOMTQ0xJYtW/B6vYRCofQMIW1tbemZRAk8Cvwum+euzEEjV0YiC7mmQoj9UsrfAa9K + JpO0tbWxYsUKILV5OS8vj8HBQQ4fPszAwABCCEpKSli9ejVVVVV4PB5cLhculwu73Y6mpbYrpv/P + pC9cz507x/nz54lEImXAQ8AGXdc/1NzcvCC7G6rIbAFp7wrx0Ddf4CsfuzPbQ5k3PvSudbzw0iBn + Ly7Yi3ZFueXpul4OfB+4TwhBRUUFmzdvZtWqVZSUlGRm+a4MjqSUGIZBIpFgeHiYvLw8ysvLefnl + lzl16hR9fX089dRTbNu2LTM7PjQ0NLr7YR/wt01NTdcvYTEDRqcU9Hd2EQmFcXlU6ddsSyYS9Pf0 + IKXEZrNlZqRnS1NTU6ShoeGTQogtQHEgEGB4eJiioiKGh4eJx+McOnQIn8+HzWZj3bp11NXVUVBQ + QHl5OXl5edhsNiwWy4T/Z6SULF++nOXLl3P69GmeffZZenp6bCMNtzyNjY1/1tTUtOA2camAfIF5 + 5GAHO+4s44E9Ndkeyrxgt2l88cFNvO1DTxCNXb9bmaIo80tjY6NHSvlVYJ8QgmXLlrFz507WrFmD + y+WacIbSMAyi0Sg+n4+hoSEikQiGYWCaJg6HgzVr1pCTk8ORI0cYHh7m0KFD1NbWIqWko6MjvZHT + AL5nGMbpWT7lDE3TKCoqor+/n5eff56ff+97rN64MVvDUUa0n7/AsSeeBFKlA12u2a8UaLVaT5qm + +Z9Syg9IKbX0Bs94PM6LL76Iz+fD4XCwefNmampq0DSNcDhMa2srFosFl8tFYWEheXl5OJ3OzH6K + 9IWt0+mkpqaGoqIiCgoKOHjwIC0tLUJK+Sop5ed0Xf9Ic3Pzgmo5rgLyBejL//Ii61YUsKQ6J9tD + mRdqa3J58N3r+MK3Xsz2UBRFmUb33XefJqX8Y+CNQgixdOlSdu3axbp160aXasuIx+MMDQ3R29ub + CcInYrFYWLx4MVJKDh8+zPDwMO3t7WiaRjSaKShxWkr5jUcffTRradtCCNauXUt/fz8DAwMcbn6E + wwcevbFjTfPY5qNp+0GObFzKyclh/fr1mZSP2fTrX//abGho+HshRCOwKhKJ0N3dTSKRwOfzYbVa + xwTjaaZpYpomiUQCv9+PxWLB7XZTWlpKQUHBmApEQgg8Hg+33347kJo9b2lp0YB3Ak/df//9P1xI + HWtVQL4ARaIGH/vqEf7zf+7CYVelQCfjdfoSjpzo58CTHdkeiqIo00TTtGpStZcdxcXFbN68mZUr + V44LxhOJBAMDA3R1dRGLxa5bj3nk2CxevBifz8epU6fo7x/TpC0ipfzsgQMHeqfzfG6E2+1m586d + vPDCC/T395NIJLI9pAXPYrHg9XrZsGEDBQUFWRvHgQMHuhobG78opfwu4OzuTqV2py/kqqurr3ux + kK7OEgwGcTqdVFRUUFRUNCYNx+l0smrVKiKRCH6/n4GBARfwGdM0nwAWzB9dFZAvUOdb/fzTv73E + R//8tmwPZd745PvWc+LMEJ291+/GpyjK3KbrugV4N7DUbrezceNGampq8Hg8mcekSxW2tbURCoUm + FYiPZrFYWLVqFV1dXQwODqa/bQLNQoj903QqNy0nJ4dt27aRTCYzddInMtXzV14xlc2ZDocjK7nj + V/ELUrX475dSCoDi4mKWL18+pqzn9UgpiUQitLS00Nvby+LFi8nNzc28L7m5udTU1LBhwwaefPJJ + EolEHfCO+++//6v79++/dsetW8Sc+Gkr2fGjhy9Sv76Ee7aUZ3so80Kux8YXHtzEez7xFIah/jAp + yjxXCrwDENXV1ZSVlVFeXj6mxnhPTw8dHR0kkzdeHtnlcrF27VqeeuopZCqifRp431zLj7VYLFgs + lglTdZSFq6mpKdTQ0PBeIcTPgS3p2XGn03lDx5NSEgwGOXv2LNXV1ZSWlmY2f5aXl1NRUUFFRQVt + bW0a8Gemaf4rkPWVpNkw+4lJypwhJXz2H5+nS834TtqG1YW8500rsz0MRVFu3g6g0mq1snTpUvLz + 8zMVR5LJJJcuXaKtre2mgvG00tLS0TPvp5LJZM9NH3QeM00z08Fxvn0t0FWCLuAMIHNzcykpKbnp + A6b/j7W3t2f+jzmdTvLz86mtrU3PvlcDm2/6xeYJNUO+wPmDCT71tef57pe2o2lqW85kvPuNK3ju + RD9Hjvdf/8GKosw5uq5bSTUjsXk8HoqKisjPz0fTNJLJJK2trfT1TV/VNYfDQWFhIcFgUAD1Vqs1 + BwhM2wvMoHT1GNM0EUKgadqE5ewmwzRN+vr6uHTpEpFIZN4FtxaLhdLSUhYtWnRTlU/yz6EMAAAg + AElEQVTS76dhGJn3NP01FwkhcoE7AFFUVJS5cL1ZUkq6u7sxTZPFixdjsVjIz8+npKQEt9tNIBBw + AHsaGxubm5qabvkuniogVzh2aoDv/ugs733LqmwPZV7QhOChD2/ijX/9GL5APNvDURRl6mzARoB0 + gJGXl4dpmnR2dl65AfOmpWubt7W1AVQLIeZ0QJ7O9+3p6aG9vR2fz5fpxOjxeKioqMh0Lp1sEGma + JmfOnOHEiRPzeuNoW1sbLS0t7Nixg5ycqVUqi8fj9Pb2cvnyZQYHB4nHU38/nE4npaWlVFVVUVhY + OKYSyRyRS2q2msrKymm9cJBS0tvbi81mo6qqiry8POx2OwUFBQQCAYA7TdO0ASogVxaG7/7oZTau + K6b+9uJsD2VeKC1y8vkPbeSDD/2eeTbJoygLxute9zoRiUScUko7qb93BUKINVLKlUAdgNfrxWaz + YbfbM5VUpnvmVghBfn4+QgiklHlSytkvLD1J6U6iJ06cIBAIjHsvAoEA3d3dnD59mkWLFnH77bdP + Kp84GAxy8uTJeR2MQyqA7O/v5/jx42zbtm1SKwXp5xw7doyBgYFx5TKDwWCqFvzLL1NWVsbGjRvJ + y8vLSpfOq8gD3JqmkZubO+0Hl1LS2dmJ2+0mNzcXm81GQUFB+gJ2tRDiLxsbG8+QKhU6BBhCiJjF + Yok9/PDDt8xfYBWQKwCYUvJ3X3uOH/3Tbrx507McdavbWV/GHzUu5Sf7W7I9FEVZUBobGwVQKqWs + B/KBw8AAoGmaVmqa5hpgSTgcLgQ2ALVAAeCUUjpJzZBrmqbhcDiw2+3EYjHa29sxzZkp6GCxWNA0 + DcMwNCnlnGyHmUwmOXXqFKdPnyaZTOIyTWrjcWojEQoNg4gQtDscvOxyMRiNcu7cOfx+P9u2bRtT + nWYinZ2dmRnhW0FfXx/xePy6m2CllLS3t3PkyBEikQhWKalNJqkLhShLJjGFoNNm45zbTSfQ0dFB + 4P9n783j3DrLu+/vfSSNNPu+2LN4POMlXmMbjxMnkABNPGccJ7yFlFJKn6fsSyk7oawFSiG0Jew0 + BfrA8/I20LQUSPBIIoQlJpA4duJ9mdiz2DOefdeuo3O/f2iOkD2LJHs0Gtnn+/noj5nRnHNpOdLv + vu7r+l3T0+zevZuKiorlIsoLAGE0/qYDXde5cOEC69atw2az4XA4jAVsBfBFKWUYCMzcxqSU5yOR + yDFVVUeBbiHESSnlCKALISqklLcAY8ChcDg8/OSTTy574W4KcpMYQ6MBPvnQ83zt729leXwGLH8+ + 8ObNHDk9RkfXZKZDMTG5Ibj77rutUsr7gc8DK4maE3gBP2DVdd0OOIh+v83aWzcmBcYLb4vFwqVL + lwgG0zfB3jgvIIUQy277Xdd1zp8/z8mTJ5G6zsZgkL/o72dDcTH25mZEWRlyaIhIZyeDFy/yPytX + 8uuiIgYGBnjmmWd46UtfuqA4zfbM+JXoup7UTsrw8DAHDx4kEAhQo2n8xfAwt1gs5K1di1JfD8Eg + kTNnmLpwgScLCvhpWRkTU1P8/ve/584776SkpGQJHs3CCCHCS1HvHwgE6O/vnyX6FUVRpJR2KaWd + 6AK8GtggpdxH1EY0LKUMAkFAm9mByic6DbfPZrN95L777vvJY489tqztE01BbnIZTx8e5IePd/L6 + +5oyHUpWkJOj8PkPv4Q3vP+3BIJzT+0zMTFZPBRFuQf4JlBmZA+llCVATLkYjXKGl7PNZqOgoICq + qqrYGO9Dhw7h9/sJhUL4/X48Hk9a4w6Hw0apQoRolm9ZMTY2xtGjR5G6zu1eL2+fnKS8rQ2xfj3k + 5ICigK5jDYVo6Ojg7b/4Bc1+P/+nupqBgQFOnTrFtm3b5s3orlixguPHj6dtB2KpMWqdF8Lv98fE + eHM4zPt6e2m6/XaUHTsgLw8sFpASy803UzE8zGt+8xvWdHfz9fp6BqenOXz4MHfccUfGa8p1XfcK + IfRIJLIorkMLMTo6isViiQ3gKigo4CUveUnMI39oaAiv10s4HCYcDqNpmqLruiHWY8xk121AM/Bw + OBz2Ac60Bn+NmILcZBZf+d5Jtq4vZfP6zE0Iyyaa6gv5wJs38/lvHc10KCYm1zWqqu4Avg6U2Ww2 + NmzYQEFBAV1dXQSDQQxLNrvdjt1up7S0lOLiYhwOB3l5eeTm5mK327FYLAwMDNDR0cHk5CTBYDCt + DhdSSkZHR42M6gTRbP6yIRKJcOLECUKhEM2hEG8Ph6n4sz+DqiqYngaPByKRqDAvLISbbiK3uprW + /fu5ODHB46WlnD9/nnXr1s1bulJSUkJtbS29vb1Z565yJQ6Hg82bNyd8z5w/f57JyUkKdZ2/GRyk + ed8+RHMzeL0wOBh9ThUFcnOhtBTrvfey49ln+d/Hj/Pl6moGBwcZHh5m5cqVS/TI5kYIMQ1M67qe + OzExkdZSGl3X0TSNycnornNDQwOqqhKJRAgGg/j9fnw+H36/n8nJSSYmJggGgwSDQYaGhmITQRsb + G5mamuLMmTNomlYhpfyWqqr3uVyu42kJfBEwBbnJLDRN5+NfOswjX3k5+XnmWyQZ7m9r5NDxEX5x + 4IaZ8mtisqSoqloHfAeoF0KwYcMGNm/eTE5OTmzcfX5+fkx0G9MODYu+uJIRdF2nvr6ejo6OWJNd + OgW5ruv09/cbP/awzBxW/H4/w8PDWKTk/5mYoHzzZnjhBejqgrGxqCDXNLDboagISkuhqYmczZt5 + zR/+wLORCEOBAL29vaxfP/ecBqvVyq233srp06e5ePFiVpawCCEoKipiy5YtCb24w+FwbPFx+/Q0 + a1etQvT2wm9/C8PDMDEBoRBYrZCfD2VlUFODWLeOW2pquDkY5JDdzrlz51ixYkVGa8mFEB4p5QWg + qq+vj+bm5rTGo2labLLtqlWrKCgoiF2fUsrYLRKJEAqFCIVCBAKBmFg3sutGCdrJkyeRUjYCD6uq + er/L5eqf59QZxVRbJnNysd/LP3zjCA8+sDPToWQNH/+bmzl+dtwctGRissi0tbUVSyn/hRmrwqam + JjZu3EhNTQ11dXVYrdZZonshFEVh48aN/OY3v8Hj8TA9PU1ZWVna4vd6vYyPj0O03vWAy+VaVh8S + 09PTBINBqiMRdvb1Ic6fh8l5+mKGZoYmPvcclJRQCdzscPBEcTGDg4OsW7du3tfAbrezdetWNm7c + OMtpJBsQQmC1WpMaaR8Oh5mcnMQqJff092M9cyYqwufaHZiehoEBOHUKfvtb8srKuKOigudXrWJi + YiKp5tF0ommax2Kx/AF4ydjYmPD5fClbPqbC5OQkXq8Xq9XK+vXrL1ssx1/jFovlsrKheLFuLIh0 + Xcfj8dDd3Q2wG/intra2v3E6nVNpewBXiSnITeblFwf6uP0l1dz7J/WZDiUrKMy38Y8f3MFbPvo0 + up7dW7ImJssFVVUdUsqPAPdDdOrltm3bqKqqYtWqVUmJo7mora2lqqqK/v5+uru7KS0tTUvWz3DZ + CAQCANNCiP9Y9JNcI4bveo2m4Rgbg2Sz1xMTKMCaqSmeKC7G4/GgadqCNc+KoizaYJnljM/nQ9M0 + SiIRiqenIbogS0wkAsPDrLXbsc5keTMtyJ944gmpqur/Bf7a5/MV9vX1LbjwuhZ0Xae7uxtN06iv + r0+pXOdKsb5q1SrC4TA7duwwrCUF8Dop5bm2trYvOJ3OZWX7szzHQpksGx58+Cjdveltdrqe2Lax + nLe+bu4tWxMTk9S4++67FSnlXwDvASyFhYW0tLRQXV3N6tWrkxLjUsrYVMRgMIjH42F0dJSpqSka + GxsB6O7uZmoqPQkzj8fDiy++aPz4W0VROtJyoqtEShlr1LNLibiKpsvcmWz3DTxafhZGSY4VUK5i + N8AhJYLk3VyWgFPA7wHOnj2Lz5eeTZ6JiQnDf5zGxkYmJycZGxvD4/EQDAZjk2OTeU5sNhtNTU1U + V1fT0tJiZPWtwAeB+1/96lcvKz85M0NusiD+QIQHvvgcP/jSHdhz0uM/er3x1tet4/kTIzx3bHGn + /ZmY3GhYLJY7gQeBfIfDQUtLC7W1tTQ3N8+ZZTXqSoPBIIFAgGAwiM/nIxAIEAqFYoLR+EKvqamh + sLCQ6elpjhw5wu7duxc1exsOhzly5Ijh4DIGfGb//v3p81a8CoQQsTHw00IQsVqjWdoUGJt5znJy + cpKqxTdep2zEcPBJlB02ntOAEGhX8Z6asFjQiWZ60+X9nQoul8vf2tr6aSHELVNTUyXHjh1j586d + i+oAEwwGOXLkCH6/n+LiYqqqqujp6bnsObdYLNjtdhwOR6xfJDc3l5ycnFi/SDx2u53m5mY0TWPn + zp384Q9/IBgMFkopv+Tz+S4CBxbtAVwjpiA3Sci57im+9v1TfPhtWzIdSlagCMFn37+D173nN0xO + L6sdMROTrEFV1bXAw0CVxWJhy5YtNDY20tzcPGsypK7rsVHvExMTaJqWVBYtLy+PzZs38+yzz9Lb + 28vJkyfZsmXLVZfBxKNpGmfOnDGyfRrwA0VRjl3zgdNAZWUliqLQZ7MxVVpK3sBA0v8bstk4XRp1 + 5CouLk743Pn9fs6dO8fQ0FDaLfTSgd1up6Ghgfr6+gXFqMPhwOFw4PH76SktpdqovU8CKQQvVFSg + CUFRfn5Gy1XikVIeFkL8CHhrV1eXpbi4mPXr1y/KgkHTNE6cOEF/fz+KorB58+bYdR6/gNM0jWAw + GNvRMsS61WqltLSUqqoq8vLyLhPmubm5MVE+NTXFkSNH0HW9Bvg3VVX3uVyuzmt+AIuAKchNkuJH + P+9k59YKXnHrikyHkhVUV+Tyqb/dxgc/fzDToZiYZB2qqlYS9RpfJ4Rg3bp1bNiwgebm5lnNZMYw + kZGRkZQFnhCChoYGBgYG6Orq4syZM7GGz2vJ/IXDYc6cOcPx48eR0VXB76WU/9je3r4sFWheXh55 + eXlMezy46uv5q6EhLEmWrvSsXMlxux0hBHV1dQve1+fzceDAAUZGRpZLGcZVcenSJQYGBti1a9e8 + CxCbzUZZWRl9fX08tmIFmy9eJC/JMo/xsjIOlJYiiS6WlkOGHOAXv/hFWFXVTwM367q+++jRqNXv + 2rVrr/l6OXHiBGfPnkVKyZo1a6ivr0+qRt0Q65FIhIGBAUZGRqisrGTFihWXLWQKCwtjotzr9XL2 + 7FmADcDX29ra/pfT6Ry96gewSJg15CZJISV85qsvmA4iKfCK3Su4v60x02GYmGQVbW1t+cDngLsA + 6urq2LZtG01NTRQXF8fuF4lEGBoa4tSpUwwMDFx1ttVms7F9+3ZWrFhBJBLh5MmTHDp0CK/Xm7Jo + lFLi8Xg4ePAgx44dM4bgHBNCvMXtdg9fVYBLgMPhoK6uDgm4S0o4tWoVMgkxNFFayvdWr8anKBQX + Fye0Ajx9+jTDw8NZLcbhj42HRjPsXFgsFtauXYuiKBy12/nV2rVoSey8BHJy+O81a+i22cjJyUm7 + xWCquFyuQeDNwOlIJMKRI0c4fPjwNV8vp0+fRtd1amtrufnmm696l0rTNPr7+zl16hTDw8OXDaIq + KSmhqamJ7du3xzeLqlLKT6uqmndVJ1xETEFukjRTnjCfeOh500EkBT70li2sbSzKdBgmJlnBnj17 + bFLKdwH/GxClpaW0tLTQ1NR02TCSUChEV1dXbCDQtZKXl8fu3btpaGhASsn58+d58sknY81riaZL + RiIRfD4fL774Ir/61a/o6upCShkB/gD8udPpfHHBA2QYIQQbN26kpKSECYuFrzU1caSpidA8WU9d + CAarq/nmpk0ccTiwWq1s3bp1wdIKTdMYSqFsY7mj6zo9PT0L3sew5dSE4PvV1fxy40Z88wxOksB0 + cTGPbt1Ke0kJCMGaNWsuW4QuF1wu12ngz4DndF3Xz507x69+9SvOnTuHz+dL2B+g6zper5czZ87w + 5JNPGtcLq1ev5tZbb51VknY1BAIBOjs76erqIhSKlo4KIaisrKSpqYldu3YZz60CvAV4y7333pvR + rQizZMUkJV44Ocp3fnSWt7/+pkyHkhXk5Ch8/sM7ecP7f0swlJ1NTCYmS4UQYh/wMcCel5fHLbfc + QnNzMzU1NTEx7vF46OzsxOv1Luq58/LyuPXWW6moqODUqVNMTU1x+PBhTp8+TXV1NStWrKCwsBCH + w4GiKEQiEQKBANPT0/T39zM0NITP5zOyhJPAfwKfXq5DSK7EePxPPfUUvT4fDzY3c0dVFXf19VE7 + NYU1EkEqCuMOB0dranisooIemw2hKGzYsCFhuQqQ9ZnxK0n0eKxWKzt37owNXvrWihU8W1LCvkuX + aB4bwzHjxOKx2+morOTx6mqO2+1EhKCutjapaaCZwuVynVRV9U+J7ma9enJysujgwYPk5+dTVVXF + ihUrKCgowOFwYLFY0HWdQCDA1NQUly5dYnh4OHa95ObmsmnTJpqamha1qVrX9dh12dTURH5+PkII + ampqYg3fBw4cwO/3O4C/1zStE/j5ogWQIqYgN0mZ7/yog+2bytl188LbkyZRmhsKef+bN/Hgvy7L + fi4Tk2WBqqo7ga8BJTabjR07drBu3Trq6upQFAUpJRMTE4uWFZ+LnJwcbrrpJqqrqzl58iT9/f14 + vd5Yps1qtcacHAwrxSus/jxEs+IPSil/53a7s6qru7y8nN27d3Pw4EGmpqf5eXExTxUWUqrrOHQd + TQgmLRbGhEAXApvNxvr169m0aVNC4Wi1WikvL49NYMx2kqmZh+hC57bbbuOZZ55haGiIZ/LyONLc + TPnq1eRHIkjAY7EwqiiEZhoU62tr2bVr17L3a3e5XH1tbW3vlFL+J/CAlLLF4/EUeDweurq6sFgs + saFdRq23pmmx6yUnJ4eVK1fGdmfStfjweDx0dHTQ1NREUVERFouFhoYGgsEg09PTPPfcc2iaVial + /IaqqhddLtfRtASSAFOQm6SMLiWf+vLz/Ohrr6CkaHl/YCwXXrt3Nc++MMyvn8mKZJmJyZKiqmod + 8G2gziifuOmmm2hsbMRqtSKlZGxsjK6urrSPXFcUhfLycm677baYJ3JPT0/MAzleUABhwA8MA78G + /kMIccjpdGbl8AYje/iKV7yCM2fO0NvbiycQYCquZEfMCPGysjI2btxIdXV10k2HGzduZHh4mImJ + iXQ9hCVBCEFtbS3V1dVJ3b+wsJCXvexldHZ2cu7cObxeL32RCMQ9b1arldLCQtavX09DQ8OyF+MG + TqczALhUVX1aCHGLlPIvgTuklBWapuVpmmaFPw7tMWwLGxsbaWhooKSkZEmaVgOBAOfOnWP16tWU + lpZitVpZvXo1Pp8Pj8fDiRMnkFKuAh5WVfU1LpfrUtqDugJTkJtcFUOjAT750PN87e9vZRn1myxr + /v692znTOWk2xpqYxKGqahHwT8B2gObmZrZu3cqaNWuw2+1LKsbjsVqtVFRUUFhYSGFhYWxiotfr + 5eLFi+i6LqWUPxVCfE4I0SulnHK5XMvSRSUVhBAUFRWxc+dONm7cyOjoKGNjY/h8PqxWK2VlZZSV + lVFUVJSys0ZhYSF33nknJ0+eZHR0NCu9yG02G/X19Sk7izgcDjZs2MDq1asZGxtjbGyM6elphBAU + FxdTXl5OSUkJOTk5y6qJM1lcLtc08EtVVX8LFAL1QojPSCnvs1gsor6+nry8PHJycnA4HBlZdIRC + ITo7O2lqaqK0tBSHw8GaNWti13VnZyfALUKIz6uq+m6Xy7WkC2tTkJtcNU8fHuSHj53n9a9qznQo + WUFRgY3PfWAHb/3Y02ZjrIkJcM8991gikcg7gfshavG2fft2GhsbY/aGk5OTSy7G4zE8joUQOBwO + 7HY7ly5dQtd1hBBjLpfruqxFUxSFgoICCgoKqK+vR0oZ83y+FgoLC9m1a1dWinEgluW9GtFsDGGq + ra1l5cqVsZ2W+JHv2Y7L5QoTHYI1pqrqCCAsFgtlZWUxAW6xWDJWGx8Oh2PlNMXFxRQVFbFq1SoC + gQCTk5OMjo4KKeVfSClfuPfee7/++OOPpz669ioxBbnJNfGV759i601lbF5fmulQsoLtm8p5y2vX + 8e0fnc10KCYmGScSidwKfAiwFRQU0NLSQl1dHZWVlQghYg2cmRLjwCzhECcmBDC3ZcZ1xmKLJ0VR + lm2z4lJxPYnwudi3b5/QNC0Poq93fFlKph+7kSlft24d+fn5VFdX4/F4aGlp4amnnsLn8+UIIT4a + iUSeBg4tVVw39hVhcs1oms7HvnQYry/rd2qXjLe9fj07t1RkOgwTk4yyZ8+eEinlg0CFxWLh5ptv + ZuXKldTX12OxWGJfmulq4EyWK8XDFWKyvK2tLTuKfU1MlpBQKOQAVgKxsffxZHoxYtgihkKhWJNn + bW0tW7duNa7val3XPz9TUrckmILc5Jrp7ffy2a8fyXQYWYMiBP/wgR0UF5rf4yY3Jvv27ROKovy5 + EOIWgMbGRlatWkV9fT12u51IJMLFixeTsjaUUhIIBOjt7aWnp4fJycmEvuGpEi8ehBDxQ0tWSilz + F/VkJibXAYqiOIBqiNbdX7moXUxBHolEmJiYoKenh76+PgKBQFL/5/F46O3tRdf12HCs1atX09DQ + YNzlTuBPFy3QBJglKyaLwhO/6+OlO6u590/qMx1KVlBdkcsn372ND33hYKZDMTFZcsLhcJUQ4gOA + LS8vj40bN1JRUUFpabT0bXR0dMEpiAZSSvr6+njhhReYnp5GShlzcNiyZcuCg2qSZa7t9bhmvjLA + XFmbmFyBlDJHCFEMzGp+XUwxHggEOHbsGBcuXCAYDMaaknfs2MGKFSsSnmt4eJjCwkIqKyspLy+n + oqKCTZs2MTg4iN/vzwEeaG1t3e92uxN/IF0jZobcZNF48OGjdPdmpdtXRnjlbSt4tdqY6TBMTJYc + RVFeBTQDrFmzhvLycurq6rBYLPj9/ljWKhGDg4M8++yzRlZcl1KGA4EAZ86c4Xe/+x2Tk5OLFe9l + P8e5Q+QDqVmNmJjcAAghrEAeMMtNZbH6B8bHxzlw4AAdHR0EAgGklGFd1/WJiQmeeeYZhoeHEx5D + 13V6e3sJBAJYLBZqa2spLy+nqanJuMtaIcQ9ixJwAkxBbrJo+AMRHvjic+ZEyhR44K1bWNu4ZCVq + JiYZR1XVQinl2wBLXl4ezc3NVFRUkJeXh67rXLp0Kam68YmJCQ4ePIjf7wfwAV8B/gY4BdDf389T + Tz3FwMDANU+IXECQ55BF36NSSjRNiw00Mm/ZeVvskqw0oTBThWG322eVrFwLUkouXbrEU089xeDg + oPHr48A7gW8Afp/PFx1wNTWV8HiBQID+/n50XSc/P5+KigrWrFlDbm4uRBfcb2ptbc27pqCTwCxZ + MVlUznVP8dXvn+KBt23JdChZQU6Owuc/vJM3vP+35kLG5IZASrlGCLEGoL6+nqKiIqqrqxFCMDU1 + xejoaMJj+P3++C9bDfiOoigfb29vD7S1tf1SSvkVYN/k5KTyu9/9jm3btrF69eqrHkASLyCEEPGl + MBYpZdq/qBeLcDjMM888E18Db5KFTExMXPMiM90IIaqklBZY3Ay5pml0dnZy7Ngxo1Y8AvxUSvkB + t9t9QVXVXMAOvGViYsJy8OBBXvrSl+JwOBY87sjISGzuQHV1NcPDw9TW1nLu3DmALUA9kFZ7NPOq + NFl0/vPnnbRsreAVt67IdChZQXNDIe974ya++G/XpZ2xicllCCFeCRRZrVbq6uooKSnB4XCg6zr9 + /f0J/ak1TePYsWMMDQ0BSMAJfKa9vT0A4HQ6u1pbW/9aCPEp4O2BQCD30KFDTE9Ps2nTpqsaRnKl + gIgbB25VFGUn0JHyQZeImTi9gJRSioGBgUyHlDLG6HWTWYSBUKaDmAspZQtgNXzb47laQR4KhTh+ + /DgdHR3G54QP+CbwebfbPQHgcrn8ra2tHxdCrALUgYEBTpw4wbZt2xZciGqaRn9/P/n5+eTl5VFS + UkJdXR1dXV1EIpFi4G5MQW6SbUgJn/nqC9zUVMyKqqxJHmWUP9+3mmePDPGbZ7Pvy9LEJFna2tpy + pZR7AOFwOKioqKC8vBxFUZienk64vRyJROjo6DCyVgBHhBDvdjqd4/H3c7vd46qqfozoF+jnNE0r + P3XqFF6vlx07dpCXl/zn0lzDcKxWK4qiEIlEbFLKd6qq+thST/VLlv3798u2trZfA/+HaJZvPoqA + nczoAmMn4EqHDIOZmt1Fi3O+Y+m6fmWJRhB4BkjOSmN+SoEWon7yKIpCTk5ObLEVzxXOOteM0Xg4 + 16RPTdPweDxXTjL1AweJPnYDXUr5hJRycNZBMszevXuLdF3/a8BqDNaK52pcVrxeL4cPH+bixYvG + e2UY+DvgEZfLddl7we12j6qq+i7gMWDz2bNnKSgoYN26dQsuBiYnJ/H7/eTn51NeXk5VVRUOhwOv + 16sIIV7e2tr6HbfbnTYfVlOQm6SFKU+YTzz0PN/+x9uxWK7f4QeLyafft4PXvefXDAz7Mx2KiUla + kFLmABsAioqKcDgcFBUVIaVkeHh4wey44ahy/Phx4wu5TwjxNqfTeWGu+89kyr6jKEqXlPJfpZSr + u7u7CYfD3H777UlnyqWUs+LKzc2ltLTUcILZDtQBZ5I6YAZwOp2Dra2t71IUZc6aHSllA/BfgEUI + QVVVFbfddltsYuqV4ikYDHLy5Ek0bfHmT4yNjc3qHZBSEg6HmZiYYGRkxBgQZZNS+oQQbxFCTFzN + uaSU1cDjgBBCUFhYSG1tLfn5+XO66jgcjqQcO1Khvr6elStXzvm3YDDI8ePH+eUvf2nUSNuFEC8A + n+FyUR5yu93LrtZRStlMtMyDsrKyWeUiuq7HJr8mQzAY5A9/+ANxuzvngHcIIX7tdDrnLKh3uVxd + bW1t75BS/reUsubYsWMUFBRQW1s773k1TWNkZIS8vDyKi4txOBzk5+cb9qvbhTD6NNAAACAASURB + VBAOLn/+FxVTkJukjRdOjvKdH53lHX95U6ZDyQqKCmx87gMv4W0ffxpdN7dnTa5LCphxXqiurqag + oACLxYKmaUxMLKytRkdHOXz4sCHKJoUQH3I6nQtO0ZsRK25VVe8Dvg3svnTpEhcvXqS5uTmpgIPB + 4Cw/dEVRqKysZHR0FClljpRyA8tYkAO43e45Sxv27NlToCjKQ8Bmi8Uidu3axd69eykpKZk3m9jX + 10dJScmixpefn8+lS5fmzJQXFRVRWVlJd3c3U1NTihBiD/B3UsoPuFyulFYFd999t8VisXwO2Ggs + Purr6+fNgAshKC8vnzObfS2Mj49TW1s753FzcnLYvXs3zc3NPPLII5w7d06RUr4d+A3wmMvlWtZf + EFLKHUCOcZ1c+T7yeDwUFRUlbUt64cKF+ObN3wLvcLlcCa83p9P5tKqqHwG+EQqFCg8dOkReXh5l + ZWXz/s/Y2Bi1tbVYrVby8/OprKw0yuMKSbPFadZ0h5tkJ9/9zw4OHk1sPWQSZcfmct70Z2szHYaJ + SbqoI9pwhc1mIz8/H0VR8Hg8htCeE4/Hw8GDBw1hHBRC/LOiKP+V7EldLtcJKeUbgVEpZdJNcbqu + Mzo6OsvVIhKJMDIyYhwjJIRY1mJ8Pu6++24hhFCBu4UQoqWlhde85jWUlZXNK8Y1TTMEyqJilMfM + hRCCvLw81q5dS2FhIYAFeLMQYkeq57FYLBuA+wBRVFREQ0PDguUoVqs1YUPg1RAMBpmenp7370II + qqured3rXmcIyFzgM1LKgkUPZpFRFOUwEFro+pnr93NhHCOuTOVNyYjxOH4IfA0IeTwenn322QUH + joVCIbxeL0KIWD35DHYpZU0K500ZU5CbpBVdSj715eeZmFqWfSfLkrf/xU1s2zD/Ct7EJFuRUuYT + FVMIIcjJyUFKicfjmffLORQKcfjwYcbGxgB04D+Br+7fvz+lrfqZISVWIGm3FY/HM2vqn5SSoaGh + +MFFB4UQF1OJZbmgKIpDCPFRwFZRUcG+ffsMq7d58Xq9SdlSXkUshtieF5vNRmNjoyGg86SUn1BV + NaU6EiHEu4ACY1x6ovdCbm7uVbvzLISUMilLzpqaGm6//XajzGK9oiibFj2YxacTeAFgaGiI4eHh + WY/T7/cnNYn3ivp9m6IoC79JrsDlcoWllP8E/A8gR0dHeeGFFwiF5tYkuq7j8Xhin09x5S2KECKt + U3lNQW6SdoZGA3zyoecxm+STw2IRfOGBnRQXmgMATa47NKLOKMAf3TPmyxRGIhFOnTrFxYsxvfuU + EOIBp9OZUgNlW1tbLfCvQLHFYqGsrCxh/aqmaYyPj88SEhMTE/T29hq/vyCEeE+q8SwXFEVZDawR + QtDS0pJUGcrQ0FDaHE+MGu6FyMvLo6goNrvhZqA82ePv2bMnR0q52zhOosUHQEFB+hLSfr9/wZ0h + iF4ju3btMjK1DmD3Pffcs6wbs9rb26eklO8GeqWUXLx4cdaQLikl4+PjCfsQhBBUVFQYOzYluq5/ + q7W1NaVMtdvtngI+ADwN0N3dzZkzZ+btWZmenkbX9St3iaSUcvGaJubAFOQmS8LThwd55LHzmQ4j + a6iuyOUT774502GYmCwqUspholZtMfcMKeWc2Spd1+ns7OTUqVPGr84JId7hdDpTcpVoa2srAv4Z + 2AHQ2Ng4bzNdXJyMj4/PEkter5fu7m7ji3wC+Fun03kilXiWE1LKFUChxWJh27ZtCcWwruv4fL60 + xWOxWBJmo4UQ8TXANTO3pFAUpdy4f15eXkL7vcV2V7kSTdOSaow1mp8BpJR7dF1f/JT9IuN2u48I + IT4ATGqaRldX16z3TigUSqp8rLa2loaGBuPH24QQD6qqmmqmvB94B9AFcPLkSbq7u+c8dygUijVz + x4n2MLD4tVpxmILcZMn46vdPceLseOI7mgDwJ7et5E/3rMp0GCYmi4YQYpAZu7qxsTH8fj+6rs+Z + qRocHOTo0aNGKcsI8DdOpzMlH2BVVe1Syg9LKV8LUFlZmdCPGKKZyyuz9sFgkM7OTqNcww/8o6Io + P08lnuXEXXfdJaSUdYCwWCwJy0UgumOxmM4qVzKXxeRcxNV05xCdpJjs8e3M9DAkU4Yyl+PKYiKl + TKqOWggRX19fmCWTOhFC/JjoYjhgXD9XLr6npqZmlYVdic1mY/v27ZSXxzZD/hJ47969e1PaRna5 + XCeB9wBjkUiEI0eOzNkPoWkaUkp8Pl/83wNCiLTuhJmC3GTJ0DSdj33pMF5fWnd9ris+/LYtrK5P + KRFgYrJsEUKEgUGICvLJyUkikcicZSHPPfec8UXtFUJ8QlGUJ1I51969exXgtcD7AEtBQQEtLS0J + yxTmajjTNI2enh6j5jUC/IcQ4pvt7e3ZoYzm4Je//KVUFMUHyQvD5UJcrJK4Eqgk/s8HeIGkFhZS + yrQPJEpG8Esp40XrkBAiKwpAZ66PrxC11NQ9Hg8XLly4bAFuNG0mGgiWn5/Prl27yM/Ph2gvyANS + ylen2kNgsVjaidpH+oyJv3OV00QiEaampuJnI1yc+fxKG6YgN1lSevu9fPbrRzIdRtbgsFv44kd2 + Ys9Z9juUJiYJsVgsXiGEC6JZ6PHxcXw+32VZUeNLcuaLUAO+LYT4fnt7e0oiREr5MuBfgAK73U5L + S8uCdmcz/8PU1NRlTYvGBNGZplKAXwN/53Q6s35gwMxQmUgkEom3lZsXRVGuaex5EvEktTCIK33w + Ed2tSAq73T4K9EG0/CiRCJRSpnVHIJkSHeDKoVk/lVJmzerJ5XJ5pZQfBJ6CqH1pf3//Za9zIBDA + 40mcfC4vL2fnzp3GDIFCKeVDQojdqcSzf/9+XUr5HeD7QGRycjJ+8Q8Qc34aHR2N/73b4XCkr14L + U5CbZIAnftfHY0/OOcvDZA7WrCriPX+9MdNhmJhcMzNfhs8BoWAwSF9fH0NDQzFREg6HOXr0qLFN + LIGfA59tb29PydZDVdU1Usp/A6osFgtbtmxhxYoVCf8vGAxe5ocupYwJiBlOKorydpfLNZpKPMsV + KWU3MBKJRDh48GBC8akoSlosAA00TUsokg3LyRkuWCyW3mSP/9hjj0WIvqfw+XwL2g4aJCMUrxa7 + 3Z5wQFUkEuGpp54yhKEHOOp2u7MiQ27gdruHgbcBZ6WUXLp0aVbD9FyDoeaitraWTZs2GQvDFVLK + 76iqujrFePxSyk8CLoCBgQGOHz8ee/9brVYGBwe5dOmSEVMAeO4nP/lJWp93U5CbZIQvPnyM7t6s + NCbICK/b18TLb0mrBaqJyZIgpTwADEkp6ezsZHh4mHA4TCQSoaOjg/PnY83fzyuK8h6Xy5XSNMa9 + e/dWAN8C1gOsXbuWNWvWJMzsGkIvXhBOT09z4cIFI5s3KIR4W3t7e2cq8SxzLgkhjgAcO3aM3t6F + ta0xSCddddXT09MJS0QmJibi7fLa9+/fn9g773L+AxiWUnLhwoV57e8MfD5f2rLk1dXVC74vpZSc + O3eO5557zvjVkUgkklIfxXLB5XK9KIR4JzCs6zrd3d2XLXbmuv7mQlEU1q9fz5o1a4xfbQS+pqpq + Sl7Bbrd7DHg3cBygo6ODF198EV3XCQaDjIyM0NXVZdx9AHgmleNfDaYgN8kI/kCEB774HMHQspv6 + uywRAj71nu1UlqUvO2VishQoijImhPg5RKcVDg0NEQqF6O3t5cSJE4Yg6wXe3t7enpK/t6qq+bqu + fxa4C6Curo4tW7YkbOI0hgXFb1v7/X66uroMpxWPEOIjTqfz96nEs9xxu90a8Alg0ufz8eijjya0 + NSwuLk7KLjBVNE1bMBtt+NX39PQY8fUJIb6R6nkURekGvgFoPp+P8+fPEwgE5n3MmqbNqjFeDBJN + jNQ0jbNnz/LII48YC5BR4INPPPHEwh2Qyxin0/lrou83bzgcpqura9Y1NzU1lXBRZrVa2bp1a/yu + 117gU21tbXkL/NssXC5XtxDiHUC/lJLjx4/T19dHKBRiYGAgfrfsJ0DaHSlMQW6SMc51T/HV759K + fEcTAEqKcvj8h1+CoixrC1oTkwVxOp1hIcT3mbFDO3PmDAMDAzz//POG+J0UQnzA5XIdTuW4ra2t + VqLb4m8CRElJCTt37kxqPLfX671MdBliwe/3Q3QS59cVRfmPVOLJIo4IIf4Z0Hp6evjud7/LiRMn + CAQCc9ZzW61WGhoaFrWW3CgNmisTbdRxDw8P09HRYWS0fUKI9yuK0pPqudrb26WiKA8RLV2JTE5O + cubMGQYHBwkEAjGru/jb2NgYXq+XcDi8KLdIJEJNTU0sGxt/CwQCXLx4kZ/97Gd873vfM8pzvMCH + ZiZgZjvfB/4NCPt8vvhFL0CsryQRDoeDlpYWiouLIapl3y6lfOO+fftS8qmcWWR/GJgyhpANDQ3F + +5SPCyF+4HK50p49TJ/BpolJEvzo8U5atlbwilsT13eawEs2V/DG+9fy7492ZDoUE5OrRkp5FHgC + uN9omJzJlAWALxKdqpc0M04L9wCfBOx5eXns2rUrqaEuxva0IT4jkQi9vb1GE50EfgY8uH///uvS + HsrpdGqqqn4ZqADe1dfXl/O9732PVatWsWnTJkpKSmaVqOi6zsWLFxPa1SWL4WxzZWZUShmr6/f7 + /cbfp4HPCCF+sn///quq6W1vb/e0tra+RQjxEPBXgUBA9PT00NfXh8VimbMk59SpU/OW6qTqxKIo + CgUFBbMaOo3Fx/T0NF6vN35c/EeBR9rb27N+S9nlcoVaW1s/K4RoBu6bnJwUfX19sUWeruuMjIxg + s9kS1tcXFRXR0tLC008/jd/vdwCf1TStC2hPMaxHgbXARz0eT86BAwfi39v7hRBLkjk0BblJxvnM + V1/gpqZiVlSltNt0w/KO19/EoeMjHD09lvjOJibLEKfTGVBV9SHgT6SUpTNffjrwQyHE15xOZ0rC + QwixQ0r5daDU8CyurKxM+H+apjE0NBTLzEopGRoaivcefkYI8V6n0zk170GuA1wul2/v3r0f03V9 + FPhkMBjM6ejooKOjY9FE6GIhhGiXUj7c3t5+TQukGevAANFFl5BSxjLYS0GSZTCSqKvKo263e+Fi + 9yzC7XZPtrW1vVtKuRJoGRwcJDc3N9afEA6HGRoaoqamJmG5WXV1Ndu2beO5555D07Qy4JttbW2v + cjqdx5KNx+VyhVtbW79EdGrt6wOBgPGmHwG+nGpT+dViCnKTjDPlCfPxLz3Pdz5/OxaLWY6RCItF + 8OADO/nzv/01U56l+fIwMVlspJSHhBD/F3gvIIQQvyFqJ5hSk15bW1vdjI1ZvRCCDRs20NDQkLDx + UNM0BgcHY84OxnTO3t5eQ2x2CyHe6nQ6+xc80HVCJBIpE0LcSdygHcOW78rn0vBpXmzmE/nxfuBS + ynuBv1dV9TMulyvVhk4A2trayqWU/y/QykzprpGRVRRlVhwWi2XRJ3ba7XbDUzuGMbV2fHzccIAR + wF8JIcZbW1v/3u12Z239+JU4nc7e1tbWtwohHpdS1l+8eBG73U5JSQkQtUIcHh6mqqpqQWtIIQSN + jY1MTU1x6tQppJSNUsqHW1tbX+N2u5O+dt1u97Sqqh8C6oE7iC6G/j0SiSQt7K8VU5CbLAuOnBrl + Oz86yzv+8qZMh5IVVFfk8tF33sxH//lQpkMxMbkq3G53eO/evf+i63ojkEt0EmdKo6nb2tqKiXqN + bwdoampiw4YNCb2djZrkmRpxIFpH3tPTE6sbBf7W6XSeTCWebEVV1XLg/wPuBEReXh6bNm1i27Zt + czZwDg8PJ+VbngrBYDDe6z2GMRRnZGTEKOPIA94nhAirqvppl8uVUlaira3NLqX8F0AFFKvVSlVV + FVVVVfHTMGMIIaiurp4lnq+V3NxcNmzYMOucUkpGRkY4cOAAhw4dMkox3iOE6FRV9btLUcu8VLjd + 7qNtbW3vk1L+u6ZpJV1dXaxbty72XHu9XoaHh6msrFzwmrZYLGzatAmjJh3YLYT4J1VV3+VyuRJ7 + W87gcrkGZhYJ3yT6GfDlJ554YslK1UxBnoVcrz193320g907qrh5Q0ruRTcsrXfU8syRIX72hOnp + bpKdtLe397W1tb1e13XhcrlSGrqhqqpDSvkR4H6AyspKtm3bNqeoiscoU4lvHAsEAnR2dhrZcr8Q + 4h+EEPtTfkBZSFtbm2XmebwDEHV1dbz61a9m9erVc9bwhkIhfD4fK1euXNQ4dF0nJyfnskVSPBUV + FYyMjNDb24umaTYp5fuA3wK/SOU8UsrbgdcBit1up7m5mcLCwnl3VHJzcyksLFz0gUjhcJiJiQlW + rlw569y1tbW85jWvYe3atTz66KN4PB4H0emSvwGy0vZwPhRF+WkkElkPfCoYDDo6OztZu3ZtzO/e + 4/Gg6zpVVVUL7lLk5OSwfft2pqenjUbY1wHn9u7d+2AqJSdut7tDVdVXCSF0p9O5pDsSWeOyYrle + VehVYLVmzcuWErou+cSXDuP1XZe9U2nhgbdtpbEuceOaiclyxel0+t1ud0pifO/evQrRL9z3AJbC + wkJ27dqV0I4vEAjQ398/S4yfO3fO+F0Y+HeLxfKvqU4GzVaklGuANwJKdXU1b3zjG1m3bt2cYlxK + SX9//6I1c8ajKArl5eXzCmOr1Up1dTWNjY2GOM4DHmxra0v6A3Dv3r05wGcBh6IoNDU1UVRUNO85 + hRCUlZWlbTrpwMDAvDXrNpuNbdu2sWfPHuP81cCbVVW9rgTAzLCwrwI/ADSv18v58+cvGxLk8/no + 7+9PODgoLy+PlpYWo5nbCnxQSnn/TNN30rhcLt9Si3HIIkEuTEEe43oV5AB9gz7++dvHMx1G1pDr + sPBPH2khJ+f6fU+YmFyJlPLlRN1Y8h0OBzt37qS0tHTe++u6ztTU1KwvdZ/Px4svvmj4X0eAHwsh + Pvnzn//8uqnVXYjW1lYBvAqosFgstLa2Ul1dPa9ADYfD8VMyFx273b6gTaUhkI06Y2DTzIIiKXRd + rwc2Q9RPvbCwcMH722y2pGwzr5ZQKHTZZNgrsVgs3HrrrTQ0NBi/uo9oedd1xcyC/O+AxwB9enqa + F1988bLdkmAwSH9/P1NTU3PacRqUl5fH250WzpQnvTS9j2BxyJpvcTND/kdybFnzsl0Vjz15gV8c + 6Mt0GFnDmsYi3vO/NmY6DBOTJUFV1XVSyoeBKovFwpYtW+YtnzBs8wYGBhgeHo41Iuq6ztjYGB0d + HcbQlTDw30Tr2FOaDJrlWJgp+Vm5ciWbN29esBnW6/UmnGx5LQghElpVKopCXV2dkTXOISpSk0JK + WQcUQfTxJsp82+32tGXHDUZGRhZ0rMnPz2fr1q3G61IDNKY1oAzhcrnGpJRvJ2ozqnk8Hs6ePcv4 + +HhMgBu9H0Yz9nzP28qVK9m0aZPx2tUA/6aqatMSPZSrJmuUnTkM5Y9c74Ic4Av/eozRiSVxGrou + +Iv7mnlZS3Wmw1hUbvRFuLkrOJu9e/dWAt8i6hnMunXraG5untMnOxgMMjQ0RF9fHz6fL+bUEQgE + 6Onp4dy5c0bphR/4NvAOl8t1Q3mJCiHyiPqPs2rVKvLyFraeXSibu1gYtcMLkZOTE19Sc0cKh78V + EBaLJaHHNZDW7LhBKBRaMOMLUFNTY4jLfKA87UFlCLfbPSKEeDPR4UEBo5zswoULMQEupcTr9XLp + 0iWGh4fnFOaKorBu3TrWrl1r/GoD8PWZ5uVlS9YoO/O76Y/YruOSFYPJ6RBffHjJ3IayHiHg0+/d + TlV54i+zbOF6Ls1KBqtpAXoZbW1t+bqufw54JUB9fT1btmzBarUipUTXdcLhcKw0pa+vj+npaXRd + R9d1AoEAly5d4vTp0wwODhoiaAh4APiQy+W6kTLjAAgh8gEHROtvE1lFLoVHt6IoCeNQFCXedSMV + +5OF7XeuYCm81pM5xxUOI9f1B4PT6RwH3iuE+DgwEolEGBgY4NSpUwwMDBAMBtF1nUgkwtTUFH19 + fbFSlnA4jK7rSCmxWq1X7p6pwKdVVV22A0+yxmXFzJD/kRulXviXT1/iV7/v55W3mVM8k6G02M6D + D+zkrR97mkgk+/vRbnRPeqvlxrjOk0VKeQ/wv5nJcJaUlDA5OYnNZiMcDuP3+y/7QjYGvXi9XsbH + x5mamoovtwgCTwMfsdlshx9//PHsv2CuDi/R4ThJie1EdpKLgfH6LYSxAJshaS9yRVGeM/43UVYa + SGt5joHVak1YFjMxMWE8J37gul84ulwu36te9aovBwKBZ4UQXwBuCQaDOT09PfT391NcXExpaSl5 + eXnYbDY0TcPr9aIoCjabjdzc3NjnQmlpKQMDA+i6rgBvBn5NipOAl4qsEeQ3erYsnuLCxFtt1wtf + ePgoO7dWUFSwsJWZSZRtG8t5919t4KvfX5JJv2nlRhfkFotACMjQQMTlSDEzGc5IJMKJEyc4c+YM + Vqs1djPQNI1wOIymaUQikXiBFwBeBL4M/Njlcl3XEzgTIYTwSSlHgNV9fX0Eg8EFyzSKi4vjp5im + hZma/gUxXt8Znkr22FLKHsAjpSwYGxujtrZ2wfsHAgEikUhaFyJlZWUL7giEw2HOnj1rLCAGpZSd + aQtmGfGzn/1MAk+3tbXdJ6V8LfA+oCkUCtmHh4cZGRmJDWyy2Wyzrv/4W9z1b2Wmh2A5kjWC3GFP + /8o8WygrSX9d23JhdDzIQ/9+gk+/d3umQ8ka/ter1/L8yTEOPDeQ6VCuGkUIlATb1jcCiiKui92O + ReI/iTpMvB5YI6UsCofDtgSZXWM8+jjwOynlfwFPut3u8bRHmwXouh4BHgVaenp6uHjxImvWzG9a + UlRURE5OTtoyx5FIJClBPjw8jKZpACEhxGPJHl9RlAu6rp8Bdg4NDVFRUbHgAkTTNPx+f8JG06vF + ZrNRXr5wWXNPTw+nT582fvyVEOKqppNmKzNN1t9ubW39b0VR9kgp7wduk1KWappm1zRNJLDhDAOT + wFkhxCNSyh8vRdxXQ9YI8lyHKcgNSgpzUBSBrt8YX9SPP3mBV93VwPZNy7ofY9kgBPzDB3bwl+/7 + DX2DKdk7LxusVlOMQzRLbgryKDPZ7K+pqvp/hBBlMwNe1hK1sVtDNPOlELUvnALOAKeAFxRFOaTr + +oTb7U5/DUIW4XK5pKqqPwMeCAaDle3t7bzxjW+c1w7QZrNRXV3NxYsX0xLP9PR0QrHv8/nip4Qe + I7rjkRTt7e2B1tbWTwkhfhoMBnO6u7tpbm6ed+CMlJLR0VEcDseCQ2muBiEEK1euXHBBMDIywv/8 + z/8Y9n/DwNdcLlfiWpvrELfbPQb8qK2t7X+klKVCiBYp5c1Er//1QCHRHbQIMCWlfFEIcRLoAJ4W + Qow7nc5lvZjJGkFuzzEFuYGiCIoLcxifvDFcSKSEf/nuCX7w0B1m1jRJigpsfOHDO3nLR39HKJx9 + n983ermKgVVRCJF9r186cblcHsADXADYu3evPRKJ5AghLDNb01IIEZFSBt1ud/q7ELMcKWWnEOJf + gY93dHRYfvzjH/OqV72KkpKSWaUUQghqamqYmJhgejrpieRJEQwGGR+ff+NCSonP5+P8+fNGuco0 + 8KFURZYQ4tdCiB9LKf98YmJCOXfuHA0NDTgcjjlrucPhMENDQ/FOJ4tCSUnJnJ7vUkpCoRBdXV08 + /vjj9PT0QDTL+wWii8wbGqfTGQIGgZ8DP29ra8uRUtqllAoghBBSSqnruh584oknsmoBnjWC3CxZ + uZyy4htHkAOcPjfBz564wJ/uWZXpULKGzetL+cS7t/GpLz+f6VBSxmI2NALmTkEyzIzFvnE+DBcZ + t9sdUVX1IeBmKeW9hw4dUvr7+3n5y1/O2rVrKSgomCUa6+rqOHPmzKKVrkQiEfr7++c8niFQR0dH + GRoaMsR4EPiclPJ3qZ7L5XIFVFV9L1AhpXzlxMSExev1xgYFzVXPLYRgfHw8KUvGZLBYLOi6Pmd5 + TigU4tixY/GDcYJSym8KIR52uVyRRQngOmJGoGeV8J4PU5BnKZVlDs5fWNwMxXLnG//vae66fSWF + +WaDZ7Lse2U9x8+O81/tXZkOJSVMy78o5sLEZClwuVyTqqq+VQjxdSnla3t7e8UPf/hDioqKsNvt + c2Zx/X5/bNDStSKlNGrC5/ybruvxfw8Bnwa+4na7ryoAl8s1rKrqO4HfAHXGBNJ0TiG9kvkaOeMd + ZoQQSCmfVhTlc06n0z/nP5hcN2SNIC8tunGcRZKhYWUBzxwZznQYS8r4ZJAf/OQc73rDhkyHklV8 + +K2b6bwwzeETS/dlc62YJStRzOfBZAmxSikLZ/b8iUQiC5aQZBABFJCip3g8bW1tpTMj1WtiBxUi + 7VM547nCSz0WA0TdXQzrTmC3ruvvVVX1Cy6Xy9wJuo7JGkFeUnTjOIskw6q69HR9L3ce+Vknr7u3 + ibJi8/2QLFarwoMf2ckb3v9bBkeyI8lienBHudGnlZosDaqqlgLfA/ZIKVEUhYqKClatWkVhYeEs + z26v18vo6OiixhCJRGJC9EoCgQA+n8/IktuADwshAq2trQ+63e65U+vzsHfv3hxd1/8RuBewCCEo + KCigsrKS3NzcWecXQlBaWprUZM9UcDgcNDc3Y7P9ccfXEOSXLl3i6aefpre3F13Xc4UQHwa6VFX9 + wY3a1HkjkDWCvLTYzJDH03iDCnJfQOP//vgc73/TpkyHklWUl9j58idv4U0PHCAQXP5liLlmiRpg + ukuZpB9VVS3Ae4C7AFFQUMArX/lKbrnlljnrx4PBIKdPn+ZKq7lrnWoppWRgYMCom571N7/fT19f + H+Pj40gpc6SUDwghniY66CVpdF2/heiAKYvFYqGuro7Kysp5XVRyc3NZsWLFomfPjYVAbW3trOd4 + 9erVbN26lSeeeIKnnnoKTdPygM/PPN5zixqIybIha9JQJWbJymU01t6YMh2wHAAAIABJREFUghzg + 0f1djI6bO3epclNTMZ/4m5vJBqOaAnMQFIDZL2GSdqSUjcA7AUtBQQFveMMbuOuuuygpKcFqtWKx + WGI3RVEYGBggFAqhKMplt/j7Xc3NarVSWVmJxWJBCHHZTVEU8vPzaW5upqamxhCwhcCDqYxCV1XV + BnwGyBNCUFdXR01NzbxiXAhBeXl5WkpZjAVIMDj7u0wIQVFREfv27eO2224zHu8KKeVftba2Zo1u + M0mNrHlhV1Qlfc3dEFRX5t6w2bNgKJJ1TYrLhb2vqOdNf7Yu02EkpDDPFKIABaYgN0kjbW1tQgih + AlVCCO688042bdo072TKUCjE2NhY2uLJyclZ0JfbyGjHDerZCjQne3wp5UrgZoCCggKqqqoWnJJp + s9kWjOdaCYfDCz6fdrudPXv2UFlZCVFLv/stFsviWL2YLDuyQpDbrAorTUF+GYoQbF5XmukwMsZ/ + ObsJhcxSuqvhXW/YgHpHXabDWJCC/KyppksrZobcJJ3k5uZa7Hb7XwKivLyc22+/fcFs8PT0NAkm + o14TRhnHQlgsFurr6w0h7RBC7EnhFPVAKUBNTc28Cw8Dh8OxoGBfDGZKcOb9e0lJCVu2bAFACLGy + qKjI9P69TskKQV6/It90G5iDHZsrMh1CxhifDOI60JvpMLISIeDT793OlvXLd0FXWZ6b6RCWBVXl + ZjLMJH0EAoHcSCRSDdDc3DzvhE6DxR4GNBfJZKRzc3NjTZZSyruTPbYQYhcgjBKYRCQS7ItBOBxe + UJALIWhsbERRFKSU+V6vtzLtQZlkhKwQ5Dc1F2c6hGXJjht8lPxP3T2ZDiFryclR+NLHdlFdsTyF + 78rK5RnXUmOW6pmkk0gkUqBpWi5AcXFxwlrpa23cTIZkMtJG3fkMqQiEXOMcyZznSneZdJBMLIYX + vJRShMPhrNBtJqmTFS9sy1ZzQTgXW9aXYrNmxUuYFo6eGaN/yJfpMLKWijIH3/jM7mVZp1y3InH2 + 6kag3nweTNKIEMLPzJTDZIb8LNakyoWYq8nxSq5YGATmu98cHDP+P5nFRTAYTPsiJC8vL6Egn56e + NuIICiGm0hqQScZY9mpOCLh1uynI58Jht7B5GZcdpBsp4cnf92c6jKymuaGQf/zgjmVXErbpBu6P + iGfT2pJMh2ByfeMBxiDqfT3X6Pp4ksmiX3NAHk/C+0Qikfha9oMpHP5FwKfrOhMTEwnvHAqF5p0g + uhgIIYyGzXnRNI2Ojg4jWz8opexMW0AmGWXZC/LN60qX7bb6cuCu21dmOoSM8utnTEF+rbyspYaP + vmNrpsOIUbcin/ISc/ATQGmx3dwtMEknEeDHAN3d3QwODi54Z4fDQV5e+sqowuFwUhny8fFxQ5CH + gUeTPb6U8gJRUc7g4GDCBtVkhfvVkpubm7CJdXBwkJMnTxo//h5IfyG/SUZY9oK8dZm7QWSau29f + iZINxtJp4uSL44Q1023lWnm12sibX7s87BBfurM60yEsK8znwyRduFwuCfwUmPD7/TidTny++csA + DdvBdPlyj42NJSydCQQCXLp0yfjxLDMCOxncbrcP+CdA8/v9XLx4MeH5pqenk1okpIqiKDQ0NMzr + gQ4wOTnJT37yE2PXYBL4qsvlWv6T3UyuimUtyB12C/e8whTkC1FR5mDH5hu3uTMU0jl7fjLTYVwX + vOsNG7jvTxoyHQYvazEFaDx37KrJdAgm1zdngUcA/cSJEzz++OPxNcuzKC4uprh48Y0WAoEAXq93 + 3r9LKQkEApw/f94QyAHgoy6XK6WaaiHE48CvADk8PEx3dzeBQGDex6vrOsPDw4ve4FlaWjrv8xgO + h+nu7uYHP/gBZ86cgehOxreklEcXNQiTZcWyNvu95xX1FBeaEzoTod5Ry6HjI5kOI2OcPj9xQ9fS + LxZCwCfefTNDo36eOTKckRiqyh3ccrPZMxLPrpsrqK7IZXBk9khxE5NrxfX/t3fvwW1d953Av+fc + e/EiAAIkQfD90lu2JdmWYufheGxZIkC7SbPrxKnjxqlbZ+x6t82sXfe129hOm6TptrNpXm7Gmd02 + adJsXGemWVmUknYmrpM6STtNbCumqlgyRfEtiG8AF8C9v/2DuFcgCZIgRRAg+PvMYAgSwMXBhSh+ + 78Hv/k5vbyYSiTwF4IBhGO98+eWXxeDgIO644w50dnbC6XQuCaOhUAixWGzDepIbhoHh4eG8NexC + CGQyGUxMTOSubJkG8AUAp9f6XCdPnpyJRCK/DuAFIrp5fHxcTk9PIxgMwu3OXx4rhMDU1NSGndQq + pYRhGJieXnosYRgG+vr60NfXZ92eAfANAJ8+depU8ZrAs5Ir20CuqhIP/qedpR7GltBzRyu+8LU+ + TExtz+Xkr0xuz9ddDKoq8Wd/8DY8/Hsvo+/85n/y8J672iDl9i3BykcKgV862ornvvkfpR4Kq1C9 + vb3j3d3d9wshvmKa5rE333wT/f39qK6uhqqqS2aPrdnqjZo1JqIVT560bs+OwwDwWQBP9fb2rnwW + 6jJ6e3svRSKRBwH8I4BGXdcxMjKynk2t2w9+8IOC7qcoyo8Mw3h8rZ8EsK2nbAP5e4628slMBXI5 + Fdx3Tyee/du+Ug+lJCam1vV/MltGlVvFZz9+K37td/4ZQ5vYVtKhSXygp3PTnm8r+eAvdeGr334T + eorLR1lxuN3uFIB4Op0mwzBEJpNBLBYr9bDyMQHMCiHW/csQjUariegpIUTIOtiQUha9g0wuVVWX + LDxktT9MJpP2AYqmaYccDsfD9957758///zzPPtUwcoykHurNDz6oX2lHsaWct/dnfibv/8F4sni + tWgqVxmz+ItVbDehGhe+8qfvwiP//YfoH1y9DdlG+OXj7air4ZUp86mpduJ93e34u+9wxzO28T72 + sY8FYrHYcxMTEz2GYQhFUdDc3Iw9e/bA7XYvKSXRdR0DAwMb2qN7uRaDUkokk0nMzMxY49CEEL9P + RIloNPoXJ0+eXNMfvWg06lAU5ZlMJvOfiUiRUsLv9yMcDsPpdOZ9TU6nE4HAxrYgraurQ3t7+4Ie + 5NYiQWNjY3jppZfw5ptvIplMVnm93j9sbm4e+sxnPvPVJ598ko/KK1RZBvLHHtiH2iC3PVuLap8D + H7inE//n+YJPOK8YQT+fZ1AM4To3nvvUu/DoH/0Qv3iruJ+WetwqHv7gnqI+x1b38H278f/+aQCz + c1xGyjbO008/raiq+vsXL16MZjIZGQgEcPfdd+PAgQNwu93WCpELHnPx4kU0NjZu6Dh0Xcfg4GDe + QExESKVSGBoawuXLl2GaplNK+YdE9AqAl9byPER0xDCMXwegqKqK9vZ21NTULJmttggh0NTUtGx9 + +Xo5nU40NDTA4Vj698s6GPr+97+P06dPY25uzqPr+qemp6f/BfMn4bIKVHZdVm68rhbv7+ko9TC2 + pI9+cA+aG7ZfmQ8H8uKpDTrx3KfehRuKfNLsI/fv5d7jqwhWO/FRPmhhG6yvr6/jtdde+0g8Hlf8 + fj8efPBB3HrrrfB6vVAUBVJKe6l6RVFgmiYmJibsEo+NujidTnuJ+MUXKSVcLhc6OjrQ1NQEIQRM + 0/QT0We6u7sLTsp33323BuAZIqoSQqCtrQ11dXXLhnFgvrTE6dz4/5t0XcfMzPItxT0eD44ePYp3 + v/vdAICBgYGGM2fO/EokEim73MY2Rlm9sX6vhk8+cTOf1LVOLqeC33vkhlIPY9MFqjnIFZPfq+GL + z7wDtx4qTveT63cHcf97uoqy7Upz/3u7cGhfTamHwSpEd3e3mJ2dPT41NRWSUuLOO+/Erl27Vqyl + jsfjq67ouR5SSlRVrTyhJKVEY2Mj/H6/9aODQogdhT6HaZpNAA4BgM/nQ21t7arL1judzg2pLTdN + E4ZhIJPJ2Jfh4WHour7gkkqlkEqlkE6noaoq7rzzToTDYWt10ntVVeU/eBWqbEpWpBT4kydu5lU5 + r9E7bw4jensLTn7/UqmHsml2dfhXvxO7JlUeFZ976u34i6+8jm9sYB2zt0rDM//tJj4IL5AUAh// + 7Rvx4cdfwgyXrrBrpCiKYhjGA0QkAoEAbrjhBoyOjmJ6ehq6rtudTXLLSC5fvowrV67YM9eKosDh + cNgXa7Y5d3Z7tdBr8Xg8uHLlympjRktLC6anp0FELgDdAF4vZPtE1AIgCACNjY0rzoxbVitVMU0T + pmna+0nXdcTj8QX7zzAMzM3NYXZ2FqlUCoZhwDRNCCHg8Xjsxwoh7P1ZVVWFcDiMUChkH6hkMplm + ANdFIpEzmqYlv/Od7/AJVBWkbAL5b31kP955My8IshH+4LGD+EX/NM4Vue63HLhdCrpafaUexrag + KAK/89EbsLPDj09/6dVrXiFVCoE/efwmdDSvvHQ0W6i92YtP/+5h/NenXoHJJzSzNTh69KhQVdUD + oEpKuZeIbgWwB5hfkfLZZ59FMpm0T7BcHMYXyw3dVkmLVYKiaRrcbjcCgYBd/uJ2u+Hz+aBpmv24 + 3Nln6/GrtVN0u91wOBxWT/JjAP68wF1wKwAhpSy4JtxaSdMK3qZpYmpqCnNzc3Z/9MnJSSSTyQUz + 4LkhfQNVA/gHAD9Lp9M/jEQir0gpf2YYxsypU6d4oYItriwC+X33dOLD7+Oe4xulyq3i80+/HR9+ + /KWKX0xkT1cAisKzq5vpfcfb0dXqwxOf/DFi19AD/tEH9uK2I7wK5Xq8/cZ6PPar+/C5v/55qYfC + ylw0GlUA+IloNxEdFULcBWAvEfkBuJEtXc1kMhgfn18QbKXZ7dyQSUR2SF1ukaCBgQF7m9bsr1WX + HQqFEAgE7OBubXM1UkqoqmoF8rUsG+rOfX0rsV7X6OgoiMj+ZMAqLcnpi75E7kGK1d4wd59al9zv + s3XxME0TmUzGnkU3DMOeVSciAaAxe+kGkDRNc1II8W+RSOS0aZovSilHent7l1/ylJWtkgfyPV3V + uP2WRvyoRCsDVrL77u7EX1b4H2y/V+N/OyXy2If34X9++fV1tdrsavXhut1Bfu+uwb6dAexs9+MX + /ZX/SRhbm2g0KojIT0QHiegeAO8F0CSEqAIggPnQaAVjh8MBr9eLUChkl51YQVJVVTu85gZwqxTD + Co5WUJ+bm8Pk5CQSiQTS6bQdMNPpNAzDQDx+dW2D8fHxBUHd4XDA5XKhqqoKXq8XDodj1YMCAMlC + 9wsR/dTqGrN4Ft4Kv7Ozs0gmk5iYmLCDt2Es7DRoBWlN0+yL1+tFbW0tXC6XfZvL5YLL5YLD4VjS + 3nDx9nKv5x7wpFIpzMzMIJFIwFrAKFtSJHRddxORG8A9AKJSyo8DeDUajX6diE4AGOvt7eU2iVtE + yQP52fNT+M3/8cNSD4NtUS/9eAQv/XhzV1hj1+78wAz/3jO2wY4fP65KKRsB3AvgV4UQuwF4kA3h + DocDHo8HoVAIoVAIPp8PwWAQqqpCSmmHcStwAlfDrxW+rTCbL9Ra919crmF1FLEWvLl8+TKmpqbs + 2eZ0Oo14PG6HdSuka5oGn8+H6upq+Hw+e5zWrHH2+X5U6P4RQpwDEDdN0zM5OQmn04lMJoOpqSlc + uXLFLkPJfV1CCLsDjNvtRjgchs/ng9PphM/ng8vlWlO9vBBiSVi3Dn5yH7/404dUKgVd15FIJOyQ + HovFMDw8jLGxMcTjccUwjFoAdxDRbQCGAHwzGo3+tZTy3IkTJ3gFvTJX8kDOGGOMsfWLRCKqlLLD + MIyHAdxPRI0AFGA+hPv9fnR2diIUCqG2thZerxc+nw9ut9ueIbfCrmVxMLS+6rpun6A4OztrlY0s + eNzikyWtGWTLjh077LA5Oztrh/XBwUF7NtiqxU4kEhgfH7e3UVdXl7uSZRrA/y10PwkhLhLRfwA4 + NDIyYj93Op22Dx6klPB4PHC73WhsbEQwGEQgEIDH47FfW6EnqeZjfRqgaRpUVYWmaXA4HHA6ndA0 + bUF5S+7zWAc41icOyWQSs7OzmJ6exuTkJIaGhnDp0iUMDw9jbm5OJaI2AE8Q0UOmaX47Go1+zjTN + N06dOsVng5epVf9VtdzwyIcE8LX1bV2iru34uh7KGGPs2ly+eBqg9Z18S8ADl1579m83eEhsA911 + 111CVdVWAI8C+AiAMAAhhIDP50NHRwdaWlrQ2NiI2tpau17bKkPJVwpiBT5d15FMJpFIJOwTPa2y + EyscbuRJi9YsvNXnfGZmBgMDA4jFYkilUvastXXQkP2+D8Atvb29BddtRaPR3ySiL+T+zOqDHggE + 0NzcjNbWVrvd4Ua0PFxNbj25qqpwuVzweDz2gcFKY7Fm0GdmZnDlyhWMjo6iv78f586dw8TERG65 + TQzAV4UQnzUMo//06dN8RniZ4RlyxhhjbIuJRCLVRPQrAJ4E0IFs95BgMIg9e/ags7MTDQ0NqKur + g8fjyTuza9VNJ5NJe9Z7bm5uSfDeDFZNOwCEw2GEw2G0traiv7/fDpuTk5NIpVK5Y4opihJfdqN5 + ENGd1nWHw4Hq6mrU1dWhqqoKiqKgtbUVLpdrw15XIayDjWyvcSQSCUxMTCwI6W632y7dcblcCzra + WCU1NTU1aGtrw44dO7B3715cuHABfX19GB8fR7ac5beJ6JeFEH/c09PzzRdffHF2U18oWxEHcsYY + Y2yL6OnpkYZhHADwZ0KI2wFoQggEg0Hs378fXV1daG5utk/QXBzCDcOArut2qUM8Hs974mI50DTN + nh32+/1Ip9OYmprC4OAgkskkAOwxDKMJwMVCttfT0+MzTfN6AKiqqsKuXbvsE0eBq91bykVu7b6u + 65icnLRr/b1eL4LBIPx+v11uZK1o2tTUhFAohJaWFnR2duL8+fM4c+YMYrGYIKIOIcQXTdO8JxqN + /q7b7T73wgsv8Gx5GSiff3mMMcYYW1YkEnGbpvmAEOJpzLe+Q1VVFfbv349du3ahtbUVDQ0Ndp9v + i2maSCaTmJycRCwWs3tmb9bs93pZrQPT6TSEEHA4HAiFQtA0DX19fQBQA6AWBQZy0zRDyO63YDC4 + ZCbcmnUuZ9Z7mUwmEYvFoGka/H4/6urq4PP57E9CNE1DQ0MDampqUF9fj+bmZpw7dw4///nPMTc3 + 5wDwXiI6mEgkfqu7u/sU15aXHgdyxhhjrMxFIpEQgKcBPATAqSgK2tracPDgQbS0tKC9vR1ut3vB + yZhWB5GxsTG7g8hW43A4rNlwm9Va0DRNCWAXgH8vcHNVmO86A4/Hs+TGtawqWg6stohWj3SXy2Wf + uGt9OuJwONDa2oqamhpUV1ejoaEBP/3pTzE4OChM0+wkoq8B+GQkEvl8b2/vmsp/2MbiQM4YY4yV + sUgk0klEXxZC3AlAejweHDp0CF1dXWhpaUFTU5Pd2cQKabFYDGNjY0gmk2U/E76SfMvbWzPn2drr + d6PwTiseZHNPvjrxQhYMKlemaSIej6O/vx/Dw8Oora1FOBy22zJ6vV7s2bMHHo8HXq8XZ8+exZkz + Z6DrerUQ4hMAmqLR6B+dPHmSFzYoEQ7kjDHGWJmKRCJ7AXxdCHEIgAiFQjhy5AgaGhrQ1dWFQCBg + h8hUKoXx8XGMjo4uPvlxy8pXQrKo40j7Gja3O8/jK04qlcLw8DBisRhCoRDC4bDdVrGjo8O+HggE + 8JOf/AQzMzMOAP+FiKp6enqeePHFF6dK/Rq2Iw7kjDHGWBmKRCL7AHwLwHVCCLS1teHw4cMIBoPY + tWuX3ds7k8kgFothaGgIuq5XRBC35Ft8aFGv8+pCtyWE2ElEy5amWF1ltuos+WKpVAqDg4OIxWJo + ampCbW0tVFVFU1OT3frS7XbjlVdeQSwWUwA8ZJomRaPRx0+ePDlT6vFvN5V7iMgYY4xtUZFIpAvA + NwBcJ6XEzp07ccsttyAQCGD37t3wer0gIszMzODs2bO4cOHCli9PySdf95dFM9xLi8GXQUStABas + RJrLWgCp0iSTSVy4cAFnz57F7Ox8p8P6+nq0traitrYWt912G+rr64H5TPgQET3d3d3tLuWYtyMO + 5IwxxlgZ6enpCQH4CoADQgjs2LEDN910E7xeL3bu3Imqqiqk02lcunQJfX19mJ6ersggadXDL7Zo + hlw9duxYoVmmGshfBgPAbjFYiYgI09PT6Ovrw8jICEzTRDgcRmNjI3w+H97xjnegtrYWmF/h9TEh + xMPRaJSrKDYRB3LGGGOsTGRbG34CwO0ARFtbG2688UY4nU60tbXB5/Nhbm4OZ8+exeDg4JbsnFIo + a9XQfHJCtVMIUehKPl5g+ZM3TdPMewBQSdLptL2SZyqVQlNTEwKBALxeL2655RarDMoB4Ckiur3E + w91WOJAzxhhjZSAajUoAHwDwEWRP4Dx8+DCcTidCoRCCwSAuX76Mvr4+zMzMVOSseK5UKrVsIM+Z + IXepqlpoIHcBK7c3nJycrPj9SkSYmJjAG2+8gdnZWbS3t9srfR4+fBgOhwMAggA+H41Gm0s83G2D + AzljjDFWBohoD4A/BuB0u904cuQI3G433G43GhoaMDg4iPPnz1f8LC5wNTQuJyeQOw3DcBa4TQ1Y + ub2hruvQdX1tg92ikskkzp07h+npaTQ2NkIIgaamJuzcudPaP3uI6MloNOoo9Vi3Aw7kjDHGWIl1 + d3e7iOgpAC1SSlx//fUIBoOQUiIUCtn9pfN1HalEyWQSiURi2dtzSlZUFNgxTgihZL8uex/TNBGL + xbbNfs5kMnjrrbcQj8fhdDohpcT+/futenIB4EEiOlziYW4LHMgZY4yxElMU5e1CiHsAoLGxEV1d + XXY3kJGRkW1RSmHJZDIYHx9f8fXmhGpFFt5U3L7fSqE8kUhgYmJi2+xv0zQxNjaGdDoNYH7RpIMH + D0JVVQCoFkI8FYlEuOtKkXEgZ4wxxkqou7vbY5rmMwA8DocDBw4cgKZpAObD6XYpoQDmO52MjY2t + WpaTE6glES1dzrOwxy5rcnJyWx0EAQtbTNbX16OlpQUAQETvBHCkRMPaNjiQM8YYYyUkhLgRwI0A + 0NzcjGAwWOIRlUY6ncbo6Cji8fiq982dIUfhWUZYj10tlBMRrly5gsuXL1dsK8SVKIqCffv2WQeG + HgCPRqNRrcTDqmgcyBljjLESOX78uEpEvwagSlVV7N27t6KXdc+HiBCPxzE8PFxQGAcW1JBLFJBl + jh8/bteaF7oSJxFhamoKQ0NDiMfj22q2HAACgQDC4bD17R0Amko4nIq3vX7rGWOMsfJSI4Q4DgCh + UAjV1QWvBL/lERF0Xcfo6ChGRkbW1D0mN5AT0apZRgix5kBu0XUdIyMj9gHDdjnhU1EUtLe3W/s6 + ZJrmraUeUyXjQM4YY4yViJTyJgANQgi0tLRYJ9JVLCKCYRiYm5vDyMgIBgcHMTs7u+aQm1tDLoQo + JMusO5AD8yc+WrP4g4ODmJychK7rME2zomfOGxsb4XJZ7dvlh7gFYvFU9m8+Y4wxVqaOHTumENFR + IYSmaRpaW1tLPaQNR0R2CNd1HfF4HIlEAplM5pqCbE6oFqKAhK2qqmIYhgrgmkqCrFl9XdchpYSm + aXC73XC5XHA4HFBVtaAa9a3C4XCgvr4eb731Fojo+uyqqJXfCL8EOJAzxhhjJaAoigqgGwD8fr/d + WWWrsYK1Fb6tJe9TqRRSqRSSySQymUzFzSabpmmHcyuEK4oCTdPgcDigaRpUVYWqqlAUZcGBQG5g + L+fwLqVEdXU1hBAgohAR7Qbwr6UeVyXiQM4YY4yVRjWAWgCora1dEsiLHV4L2b4VsoH5AJp7MQzD + Dt+ZTAaGYdgz35sYvgURlTzR5h6MpNNp++RUK6hbFymlfVEUxQ7qubcvfoy1ndyvK1ntPisdDOR7 + zkAgYAVyDxG1gAN5URQ9kJOZLvZTMMYYY1tRB+YXXoGU0l6MJt8l1+J66/UE39zH5M5wW1/zPXe+ + +5VKzmyzyF7KUr73bzUrBepizqbn27YQAqlUyrpNCiFqjh07Jr773e9WzkcdZaK4gZxMxAb+sahP + wRhjjG1RNQCcwHxwi8ViJR5O5crOoovs9RKPZmUrjW+zx05EyGQykFJa/dgPZFdG3X7N2YuMS1YY + Y4yx0nAi2+0skUjA4XDYJQyLTzzciFKFzbTW4LiW8hnTNNfUIhEATNO0u6zE43EMDQ1BUZQl5SH5 + SkQW/zxf+Ugh13N/ttzP12Pxvlvtk43c++Tu09zrVklSKpWCruvIZDLWQ+uzXW04kG8wDuSMMcZY + 6QgiwsDAAAYHBxeENSsw5qsrzhcQc0O89RjrPhshX2jOVyueGwhzb8sttcl3n8U/y/e9dT1n9cyC + kr8QIkNEaQBIJpO4ePFi7m357l/Qz1a7bS37fj3v03pm0/O9X4uvL/NYIqJ+Itoejdg3GQdyxhhj + rDReB/AzADtM03RmZ3HLuia6jFD2Mg5gerU7SymnDMP4BoCHMJ99rP2sZMtZZPZ7CQA5iw1ZXwWW + vjeFXM9nM97ffIma8lwnACau7k8T87Pf1iUDIA5ghIhOAfjy6dOneXa8CFYN5BIiRYUdgDLGGKsQ + EoJ7DRdZb2/vm5FI5A4hRAeA64goBMBLREq233OYiAJCCC8AN+ZLXByY/9utZDej4mpotP6mi5zb + BRYuAngtf9CtwLbY4oBGmA9ywNWAZ93Pup7O2VYq+5gEAIOI4gAMKeVsdjtzRJQAkCIiEkKY2ful + hRA/IKKB1QZ+4sQJikQinxBC/C/TNOfPUJRSAeAVQrgMw3ABUIQQzuz+d2e/OoUQGgAtG9ythXEU + ItIAQAih4Or+VpDd39nSjiVNz03TVBb/TAhxrd1irEANIYS1j4D5/WS95xnrftl9ZwJICSGSRJTE + /P6fMU1zWko5JaWcMQzDes/ThmHEv/e97/HseJGs+ua3HXzsOjKN1zdjMIwxxsqDJLm///UvvlHq + cWxXx48fF4qiqIZhSCGEtRqlEELIRcFNzGdUAeT/m17IujkFWaE71XVmAAABg0lEQVQ8YskNVgjM + Prc9G2uNJXt77iwtsqUQZJomASCn02lmH0OmaZonTpzg2UFWsVb/LX3/+5XWvtppAJ7iD4cxxlgZ + iA/sjfnxrW/xR9OMMbYJVl8/dv4/5DPFHwpjjLFyIICfcRhnjLHNs3ogBwCIfy7uMBhjjJUNopdL + PQTGGNtOCgrkmsN4BsBgkcfCGGOs9EYg5KdKPQjGGNtOCgrk5//ty1NC0MeKPRjGGGOlRUSPXXzt + SxOlHgdjjG0nBZasABdf/avnAXy7iGNhjDFWQoLw95de/6sXSj0OxhjbbgoO5ABAXveHSOAvcW19 + TBljjJUZEviqLuceLPU4GGNsO1pXc9LWg490w8T/BtC4weNhjDG2ucYhxG8MvPqlfyj1QBhjbLta + 92oBndf/RjgD9QEIvA3A2wB0bNioGGOMFZG4AKIfQeDHKmW+fuH150ZLPSLGGNvONmb5LgDhA4/U + q4a8TpG0ZElYxhhjpWeYwsgo5pnRV58dK/VYGGOMXfX/ARD6Y1WuLYYhAAAAAElFTkSuQmCC + ) + ) + + (text "Text box B" (at 81.28 57.15 90) + (effects (font (size 1.27 1.27) italic) (justify left bottom)) + (uuid 2f3deced-880d-4075-a81b-95c62da5b94d) + ) + (text "Text box A" (at 67.31 59.69 0) + (effects (font (size 1.27 1.27)) (justify left bottom)) + (uuid 3cfcbcc7-4f45-46ab-82a8-c414c7972161) + ) + (text "Text box C" (at 92.71 59.69 180) + (effects (font (size 1.27 1.27) (thickness 0.254) bold) (justify right bottom)) + (uuid 4d609e7c-74c9-4ae9-a26d-946ff00c167d) + ) + (text "Text box D" (at 81.28 60.96 270) + (effects (font (size 1.27 1.27) (thickness 0.254) bold italic) (justify right bottom)) + (uuid 786b6072-5772-4bc1-8eeb-6c4e19f2a91b) + ) + + (label "L1" (at 22.86 66.04 0) + (effects (font (size 1.27 1.27)) (justify left bottom)) + (uuid f144a97d-c3f0-423f-b0a9-3f7dbc42478b) + ) + + (global_label "L2B" (shape output) (at 39.37 55.88 90) (fields_autoplaced) + (effects (font (size 1.27 1.27) italic) (justify left)) + (uuid 6199bec7-e7eb-4ae0-b9ec-c563e157d635) + (property "Intersheet References" "${INTERSHEET_REFS}" (id 0) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + ) + (global_label "L2A" (shape input) (at 38.1 58.42 180) (fields_autoplaced) + (effects (font (size 1.27 1.27)) (justify right)) + (uuid 71c77456-1405-42e3-95ed-69e629de0558) + (property "Intersheet References" "${INTERSHEET_REFS}" (id 0) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + ) + (global_label "L2C" (shape bidirectional) (at 40.64 58.42 0) (fields_autoplaced) + (effects (font (size 1.27 1.27) (thickness 0.254) bold) (justify left)) + (uuid 7f3eb118-a20c-4239-b800-c9211c66847d) + (property "Intersheet References" "${INTERSHEET_REFS}" (id 0) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + ) + (global_label "L2D" (shape passive) (at 39.37 60.96 270) (fields_autoplaced) + (effects (font (size 1.27 1.27) (thickness 0.254) bold italic) (justify right)) + (uuid d2de4093-1fc2-4bc1-94b6-4d0fe3426c6f) + (property "Intersheet References" "${INTERSHEET_REFS}" (id 0) (at 0 0 0) + (effects (font (size 1.27 1.27)) hide) + ) + ) + + (hierarchical_label "L3B" (shape output) (at 55.88 55.88 90) + (effects (font (size 1.27 1.27) italic) (justify left)) + (uuid 909b030b-fa1a-4fe8-b1ee-422b4d9e23cf) + ) + (hierarchical_label "L3C" (shape bidirectional) (at 57.15 58.42 0) + (effects (font (size 1.27 1.27) (thickness 0.254) bold) (justify left)) + (uuid 936e2ca6-11ae-4f42-9128-52bb329f3d21) + ) + (hierarchical_label "L3A" (shape input) (at 54.61 58.42 180) + (effects (font (size 1.27 1.27)) (justify right)) + (uuid cbc539d2-6a10-4052-9b7a-f10326dcac67) + ) + (hierarchical_label "L3D" (shape passive) (at 55.88 60.96 270) + (effects (font (size 1.27 1.27) (thickness 0.254) bold italic) (justify right)) + (uuid ebadd2a5-21ab-4a7e-b5bc-6f737367e560) + ) + + (symbol (lib_id "l1:Resistor") (at 33.02 87.63 270) (unit 1) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f33ec02) + (property "Reference" "R1" (id 0) (at 33.02 82.3722 90)) + (property "Value" "R" (id 1) (at 33.02 84.6836 90)) + (property "Footprint" "" (id 2) (at 33.02 85.852 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 33.02 87.63 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Test" "Hi! \"quoted text\"" (id 4) (at 33.02 87.63 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid 7e177dab-d792-4f03-9143-3cc95615e0d6)) + (pin "2" (uuid c7c08868-5b26-40ca-94ba-cdb1cda09dbd)) + ) + + (symbol (lib_id "Device:L") (at 39.37 80.01 0) (unit 1) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f33f73d) + (property "Reference" "L1" (id 0) (at 40.7162 78.8416 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Value" "L" (id 1) (at 40.7162 81.153 0) + (effects (font (size 1.27 1.27)) (justify left)) + ) + (property "Footprint" "" (id 2) (at 39.37 80.01 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 39.37 80.01 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid f71826d8-34d8-4930-98c5-11e184143d2a)) + (pin "2" (uuid e65300a0-fc18-4db7-b27f-2d7614c69ac0)) + ) + + (symbol (lib_id "Device:C") (at 45.72 87.63 90) (unit 1) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f3401d2) + (property "Reference" "C1" (id 0) (at 45.72 81.2292 90)) + (property "Value" "C" (id 1) (at 45.72 83.5406 90)) + (property "Footprint" "" (id 2) (at 49.53 86.6648 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 45.72 87.63 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid 636ec398-3d70-4359-98b8-4ebd9a3143be)) + (pin "2" (uuid 15129e2c-3876-4c0d-83a8-7e8db04bdace)) + ) + + (symbol (lib_id "Device:R_US") (at 39.37 95.25 180) (unit 1) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f3409f7) + (property "Reference" "R2" (id 0) (at 41.0972 94.0816 0) + (effects (font (size 1.27 1.27)) (justify right)) + ) + (property "Value" "R_US" (id 1) (at 41.0972 96.393 0) + (effects (font (size 1.27 1.27)) (justify right)) + ) + (property "Footprint" "" (id 2) (at 38.354 94.996 90) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "~" (id 3) (at 39.37 95.25 0) + (effects (font (size 1.27 1.27)) hide) + ) + (pin "1" (uuid 779dda81-116c-4228-bf2c-ec4cdaf096a5)) + (pin "2" (uuid e09d9b91-6abd-4b89-9714-db4f9256657c)) + ) + + (symbol (lib_id "l1:SYM_CAUTION") (at 69.85 87.63 0) (unit 1) + (in_bom yes) (on_board yes) + (uuid 00000000-0000-0000-0000-00005f4ece1f) + (property "Reference" "#SYM_CAUTION1" (id 0) (at 69.85 83.82 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Value" "SYM_CAUTION" (id 1) (at 69.85 92.075 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Footprint" "" (id 2) (at 72.39 93.98 0) + (effects (font (size 1.27 1.27)) hide) + ) + (property "Datasheet" "" (id 3) (at 69.85 87.63 0) + (effects (font (size 1.27 1.27)) hide) + ) + ) + + (sheet (at 101.6 76.2) (size 25.4 12.7) (fields_autoplaced) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (fill (color 0 0 0 0.0000)) + (uuid 00000000-0000-0000-0000-00005f342deb) + (property "Sheet name" "Sub Sheet" (id 0) (at 101.6 75.4884 0) + (effects (font (size 1.27 1.27)) (justify left bottom)) + ) + (property "Sheet file" "sub-sheet.kicad_sch" (id 1) (at 101.6 89.4846 0) + (effects (font (size 1.27 1.27)) (justify left top)) + ) + (pin "OUT" output (at 127 82.55 0) + (effects (font (size 1.27 1.27)) (justify right)) + (uuid 0f41a909-27c4-4be2-9d5e-9ae2108c8ff5) + ) + (pin "IN" input (at 101.6 82.55 180) + (effects (font (size 1.27 1.27)) (justify left)) + (uuid 632acde9-b7fd-4f04-8cb4-d2cbb06b3595) + ) + ) + + (sheet (at 101.6 96.52) (size 25.4 12.7) (fields_autoplaced) + (stroke (width 0) (type solid) (color 0 0 0 0)) + (fill (color 0 0 0 0.0000)) + (uuid 00000000-0000-0000-0000-00005f34e267) + (property "Sheet name" "Sub Sheet 2" (id 0) (at 101.6 95.8084 0) + (effects (font (size 1.27 1.27)) (justify left bottom)) + ) + (property "Sheet file" "sub-sheet.kicad_sch" (id 1) (at 101.6 109.8046 0) + (effects (font (size 1.27 1.27)) (justify left top)) + ) + (pin "OUT" output (at 127 102.87 0) + (effects (font (size 1.27 1.27)) (justify right)) + (uuid dabe541b-b164-4180-97a4-5ca761b86800) + ) + (pin "IN" input (at 101.6 102.87 180) + (effects (font (size 1.27 1.27)) (justify left)) + (uuid e12e827e-36be-4503-8eef-6fc7e8bc5d49) + ) + ) + + (sheet_instances + (path "/" (page "1")) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f3bb8bb" (page "2")) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f3bb8bb" (page "3")) + (path "/00000000-0000-0000-0000-00005f342deb" (page "4")) + (path "/00000000-0000-0000-0000-00005f34e267" (page "5")) + ) + + (symbol_instances + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f34bc05" + (reference "#PWR01") (unit 1) (value "VCC") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f34c535" + (reference "#PWR02") (unit 1) (value "GND") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f34bc05" + (reference "#PWR03") (unit 1) (value "VCC") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f34c535" + (reference "#PWR04") (unit 1) (value "GND") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f4ece1f" + (reference "#SYM_CAUTION1") (unit 1) (value "SYM_CAUTION") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f3401d2" + (reference "C1") (unit 1) (value "C") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f33f73d" + (reference "L1") (unit 1) (value "L") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f33ec02" + (reference "R1") (unit 1) (value "R") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f3409f7" + (reference "R2") (unit 1) (value "R_US") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f3bb8bb/00000000-0000-0000-0000-00005f3bbcff" + (reference "R3") (unit 1) (value "1m") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f3bb8bb/00000000-0000-0000-0000-00005f3bbcff" + (reference "R4") (unit 1) (value "1m") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f34307a" + (reference "U1") (unit 1) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f344a0e" + (reference "U1") (unit 2) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f345e39" + (reference "U1") (unit 3) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f346e8b" + (reference "U1") (unit 4) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f348270" + (reference "U1") (unit 5) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f348d95" + (reference "U1") (unit 6) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f342deb/00000000-0000-0000-0000-00005f34a12f" + (reference "U1") (unit 7) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f34307a" + (reference "U2") (unit 1) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f344a0e" + (reference "U2") (unit 2) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f345e39" + (reference "U2") (unit 3) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f346e8b" + (reference "U2") (unit 4) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f348270" + (reference "U2") (unit 5) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f348d95" + (reference "U2") (unit 6) (value "74LS04") (footprint "") + ) + (path "/00000000-0000-0000-0000-00005f34e267/00000000-0000-0000-0000-00005f34a12f" + (reference "U2") (unit 7) (value "74LS04") (footprint "") + ) + ) +)