# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: proycon@anaproy.nl-20120922150605-srvpzc61j51tywd4 # target_branch: bzr+ssh://bazaar.launchpad.net/%2Bbranch/scribes/ # testament_sha1: 6ab45ce7bcb642bfe2982d3688028ec4f6728ccf # timestamp: 2012-09-22 17:12:58 +0200 # base_revision_id: mystilleef@gmail.com-20111118163400-\ # g4ldqge3dg50i90o # # Begin patch === added directory 'LanguagePlugins/CPPSymbolBrowser' === added file 'LanguagePlugins/CPPSymbolBrowser/Manager.py' --- LanguagePlugins/CPPSymbolBrowser/Manager.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/Manager.py 2012-04-25 20:06:11 +0000 @@ -0,0 +1,63 @@ +from gobject import GObject, SIGNAL_RUN_LAST, TYPE_NONE +from gobject import TYPE_PYOBJECT + +class Manager(GObject): + + __gsignals__ = { + "destroy": (SIGNAL_RUN_LAST, TYPE_NONE, ()), + "update": (SIGNAL_RUN_LAST, TYPE_NONE, (TYPE_PYOBJECT,)), + "show-window": (SIGNAL_RUN_LAST, TYPE_NONE, ()), + "hide-window": (SIGNAL_RUN_LAST, TYPE_NONE, ()), + } + + def __init__(self, editor): + GObject.__init__(self) + self.__init_attributes(editor) + from Updater import Updater + Updater(editor, self) + from TreeView import TreeView + TreeView(editor, self) + from Window import Window + Window(editor, self) + + def __init_attributes(self, editor): + self.__editor = editor + from os.path import join, split + current_folder = split(globals()["__file__"])[0] + glade_file = join(current_folder, "SymbolBrowser.glade") + from gtk.gdk import pixbuf_new_from_file + class_pixbuf = join(current_folder, "class.png") + self.__class_pixbuf = pixbuf_new_from_file(class_pixbuf) + function_pixbuf = join(current_folder, "function.png") + self.__function_pixbuf = pixbuf_new_from_file(function_pixbuf) + method_pixbuf = join(current_folder, "method.png") + self.__method_pixbuf = pixbuf_new_from_file(method_pixbuf) + from gtk.glade import XML + self.__glade = XML(glade_file, "Window", "scribes") + return + + def __get_glade(self): + return self.__glade + + def __get_class_pixbuf(self): + return self.__class_pixbuf + + def __get_function_pixbuf(self): + return self.__function_pixbuf + + def __get_method_pixbuf(self): + return self.__method_pixbuf + + glade = property(__get_glade) + class_pixbuf = property(__get_class_pixbuf) + function_pixbuf = property(__get_function_pixbuf) + method_pixbuf = property(__get_method_pixbuf) + + def show_browser(self): + self.emit("show-window") + return + + def destroy(self): + self.emit("destroy") + del self + return === added file 'LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade' --- LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/SymbolBrowser.glade 2012-04-25 20:06:11 +0000 @@ -0,0 +1,44 @@ + + + + + + 10 + Classes and Functions + ScribesSymbolBrowser + center-on-parent + 350 + 400 + True + scribes + dialog + True + True + True + static + ScribesSymbolBrowser + + + True + True + never + automatic + in + + + True + False + True + True + True + False + True + 1 + True + 2 + + + + + + === added file 'LanguagePlugins/CPPSymbolBrowser/TreeView.py' --- LanguagePlugins/CPPSymbolBrowser/TreeView.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/TreeView.py 2012-09-22 15:06:05 +0000 @@ -0,0 +1,186 @@ +class TreeView(object): + + def __init__(self, editor, manager): + self.__init_attributes(editor, manager) + self.__set_properties() + self.__sigid1 = self.__manager.connect("destroy", self.__destroy_cb) + self.__sigid2 = self.__manager.connect("update", self.__update_cb) + self.__sigid3 = self.__treeview.connect("row-activated", self.__row_activated_cb) + self.__sigid4 = self.__treeview.connect("cursor-changed", self.__cursor_changed) + from gobject import idle_add + idle_add(self.__precompile_method, priority=9999) + + def __init_attributes(self, editor, manager): + self.__manager = manager + self.__symbols = None + self.__parent = None + self.__editor = editor + self.__treeview = manager.glade.get_widget("TreeView") + self.__model = self.__create_model() + self.__column = self.__create_column() + self.__depth_level_iter = None + return + + def __set_properties(self): + self.__treeview.append_column(self.__column) + self.__treeview.map() + return + + def __create_model(self): + from gtk import TreeStore + from gtk.gdk import Pixbuf + model = TreeStore(int, str, str, int, Pixbuf) + return model + + def __create_column(self): + from gtk import TreeViewColumn, CellRendererText, CellRendererPixbuf + from gtk import TREE_VIEW_COLUMN_FIXED + column = TreeViewColumn() + pixbuf_renderer = CellRendererPixbuf() + text_renderer = CellRendererText() + column.pack_start(pixbuf_renderer, False) + column.pack_start(text_renderer, False) + column.set_sizing(TREE_VIEW_COLUMN_FIXED) + column.set_resizable(False) + column.set_attributes(text_renderer, text=1) + column.set_attributes(pixbuf_renderer, pixbuf=4) + return column + + def __populate_model(self, symbols): + self.__treeview.set_property("sensitive", False) + if self.__symbols != symbols: + self.__treeview.window.freeze_updates() + from copy import copy + self.__symbols = copy(symbols) + self.__treeview.set_model(None) + self.__model.clear() + indentation = self.__get_indentation_levels(symbols) + append = self.__append_symbols + for item in symbols: + append(item, indentation) + self.__treeview.set_model(self.__model) + self.__treeview.window.thaw_updates() + #self.__treeview.expand_all() + self.__select_row() + self.__treeview.set_property("sensitive", True) + self.__treeview.grab_focus() + return False + + def __select_row(self): + current_line = self.__editor.cursor.get_line() + 1 + get_line = lambda x: x[0] + lines = sorted([get_line(symbol) for symbol in self.__symbols]) + lines.reverse() + found_line = False + for line in lines: + if not (current_line == line or current_line > line): continue + found_line = True + current_line = line + break + if found_line: + self.__select_line_in_treeview(current_line) + else: + self.__editor.select_row(self.__treeview) + return + + def __select_line_in_treeview(self, line): + iterator = self.__model.get_iter_root() + while True: + if self.__model.get_value(iterator, 0) == line: break + if self.__model.iter_has_child(iterator): + parent_iterator = iterator + found_line = False + for index in xrange(self.__model.iter_n_children(iterator)): + iterator = self.__model.iter_nth_child(parent_iterator, index) + if not (self.__model.get_value(iterator, 0) == line): continue + found_line = True + break + if found_line: break + iterator = parent_iterator + iterator = self.__model.iter_next(iterator) + if iterator is None: break +# try: + path = self.__model.get_path(iterator) + self.__treeview.expand_to_path(path) + self.__treeview.get_selection().select_iter(iterator) + self.__treeview.set_cursor(path) + self.__treeview.scroll_to_cell(path, use_align=True, row_align=0.5) +# except TypeError: +# pass + return + + def __get_indentation_levels(self, symbols): + get_indentation = lambda x: x[-2] + indentations = [get_indentation(symbol) for symbol in symbols] + indentation_levels = list(set(indentations)) + indentation_levels.sort() + return indentation_levels + + def __append_symbols(self, item, indentation): + index = indentation.index(item[-2]) + parent = self.__find_parent(index) + self.__depth_level_iter = self.__model.append(parent, item) + return + + def __find_parent(self, index): + if not index: return None + depth = self.__model.iter_depth(self.__depth_level_iter) + if index == depth: + parent = self.__model.iter_parent(self.__depth_level_iter) + elif index < depth: + self.__depth_level_iter = self.__model.iter_parent(self.__depth_level_iter) + parent = self.__find_parent(index) + elif index > depth: + parent = self.__depth_level_iter + return parent + + def __select_symbol(self, line, name): + begin = self.__editor.textbuffer.get_iter_at_line(line - 1) + end = self.__editor.forward_to_line_end(begin.copy()) + from gtk import TEXT_SEARCH_TEXT_ONLY + x, y = begin.forward_search(name, TEXT_SEARCH_TEXT_ONLY, end) + self.__editor.textbuffer.select_range(x, y) + self.__editor.move_view_to_cursor(True) + return False + + def __forward_to_line_end(self, iterator): + if iterator.ends_line(): return iterator + iterator.forward_to_line_end() + return iterator + + def __destroy_cb(self, manager): + self.__editor.disconnect_signal(self.__sigid1, self.__manager) + self.__editor.disconnect_signal(self.__sigid2, self.__manager) + self.__editor.disconnect_signal(self.__sigid3, self.__treeview) + self.__treeview.destroy() + del self + return + + def __row_activated_cb(self, treeview, path, column): + iterator = self.__model.get_iter(path) + self.__manager.emit("hide-window") + self.__treeview.set_property("sensitive", False) + line = self.__model.get_value(iterator, 0) + name = self.__model.get_value(iterator, 1) + self.__select_symbol(line, name) + return True + + def __cursor_changed(self, treeview): + cursor = treeview.get_cursor() + if cursor != None: + path = cursor[0] + iterator = self.__model.get_iter(path) + line = self.__model.get_value(iterator, 0) + name = self.__model.get_value(iterator, 1) + self.__select_symbol(line, name) + + def __update_cb(self, manager, symbols): + from gobject import idle_add + idle_add(self.__populate_model, symbols, priority=9999) + return False + + def __precompile_method(self): + methods = [self.__select_symbol, self.__row_activated_cb, + self.__populate_model] + self.__editor.optimize(methods) + return False === added file 'LanguagePlugins/CPPSymbolBrowser/Trigger.py' --- LanguagePlugins/CPPSymbolBrowser/Trigger.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/Trigger.py 2012-04-25 20:06:11 +0000 @@ -0,0 +1,39 @@ +from SCRIBES.SignalConnectionManager import SignalManager +from SCRIBES.TriggerManager import TriggerManager +from gettext import gettext as _ + +class Trigger(SignalManager, TriggerManager): + + def __init__(self, editor): + SignalManager.__init__(self) + TriggerManager.__init__(self, editor) + self.__init_attributes(editor) + self.connect(self.__trigger, "activate", self.__activate_cb) + + def __init_attributes(self, editor): + self.__editor = editor + self.__manager = None + name, shortcut, description, category = ( + "show-python-symbol-brower", + "F5", + _("Show classes, methods and functions"), + _("Python") + ) + self.__trigger = self.create_trigger(name, shortcut, description, category) + return + + def __activate_cb(self, *args): + try: + self.__manager.show_browser() + except AttributeError: + from Manager import Manager + self.__manager = Manager(self.__editor) + self.__manager.show_browser() + return + + def destroy(self): + self.disconnect() + self.remove_triggers() + if self.__manager: self.__manager.destroy() + del self + return === added file 'LanguagePlugins/CPPSymbolBrowser/Updater.py' --- LanguagePlugins/CPPSymbolBrowser/Updater.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/Updater.py 2012-09-22 15:06:05 +0000 @@ -0,0 +1,175 @@ +class Updater(object): + + def __init__(self, editor, manager): + self.__init_attributes(editor, manager) + self.__sigid1 = manager.connect("show-window", self.__show_window_cb) + from gobject import idle_add + idle_add(self.__precompile_methods, priority=9999) + + def __init_attributes(self, editor, manager): + self.__editor = editor + self.__manager = manager + from collections import deque + # symbols has the format [(line_number, name, type), ...] + self.__symbols = deque([]) + self.__depth = 0 + self.__inside_class = False + self.__class_depth = 0 + self.__function_depth = 0 + return + + def __get_symbols(self): + try: + self.__symbols.clear() + f = open('/tmp/scribes.symbolbrowser','w') + f.write(self.__editor.text) + f.close() + from os import system + lang = self.__editor.language + langmap = { + 'cpp': 'C++', + 'chdr': 'C++', + 'c': 'C', + 'php': 'PHP', + 'java': 'Java', + 'perl': 'Perl', + 'js': 'JavaScript', + 'lua': 'Lua', + 'lisp': 'Lisp', + 'pascal': 'Pascal', + 'sh': 'Sh', + } + if lang in langmap: + lang = langmap[lang] + else: + lang = 'C++' #pretend C++ + system('ctags -f /tmp/tags --language-force=' + lang + ' --fields=afmikKlnsStz /tmp/scribes.symbolbrowser') + self.__extract_symbols('/tmp/tags') + self.__manager.emit("update", self.__symbols) + except SyntaxError: + pass + return False + + def __extract_symbols(self, filename): + classes = {} #classes + classchildren = {} #methods pertaining to classes (None key for classless functions) + + f = open(filename) + for line in f: + line = line.strip() + if not line or line[0] == '!': + continue + #print "DEBUG: PARSING LINE: ", line + fields = line.split('\t') + #if not len(fields) >= 3: + # print "CPPSymbolBrowser unparsable ctags line: ", line + name = fields[0] + filename = fields[1] + attribs = {} + for x in fields[3:]: + x = x.split(':',1) + if len(x) == 2: + attribs[x[0]] = x[1] + if 'line' in attribs: + lineno = int(attribs['line']) + else: + continue + if 'kind' in attribs and attribs['kind'] == 'class': + cls = name + classes[cls] = (name,filename,lineno,attribs) + continue + elif 'kind' in attribs and (attribs['kind'] == 'variable' or attribs['kind'] == 'enumerator' or attribs['kind'] == 'macro' or attribs['kind'] == 'define'): + continue #skip these + elif 'class' in attribs: + cls = attribs['class'] + else: + cls = None + + if not cls in classchildren: + classchildren[cls] = [] + + #print "DEBUG: Found: ", repr((name, filename, lineno, attribs)) + insertpos = 0 + for i, (_,_,lineno2,_) in enumerate(classchildren[cls]): + if lineno > lineno2: + insertpos = i+1 + classchildren[cls].insert( insertpos, (name, filename, lineno, attribs) ) + f.close() + + + #order symbols first + classorder = [] + for cls in set(set(classchildren.keys()) | set(classes.keys())): + if cls != None: + if cls in classes: + firstline = classes[cls][2] + elif cls in classchildren: + firstline = None + for _,_,lineno,_ in classchildren[cls]: + if firstline == None or lineno < firstline: + firstline = lineno + + insertpos = 0 + for i, cls2 in enumerate(classorder): + if cls2 != None: + if cls2 in classes: + firstline2= classes[cls2][2] + elif cls2 in classchildren: + firstline2 = None + for _,_,lineno,_ in classchildren[cls]: + if firstline2 == None or lineno < firstline: + firstline2 = lineno + if firstline > firstline2: + insertpos = i+1 + + classorder.insert(insertpos, cls) + + if None in classchildren: + classorder.append( None) #classless always last + + + for cls in classorder: + if cls != None: + if cls in classes: + name = classes[cls][0] + lineno = classes[cls][2] + elif cls in classchildren: + lineno = 0 + for name,filename,line,attribs in classchildren[cls]: + if name == cls: + lineno = line + break + if lineno: + self.__symbols.append( (lineno, name, 'Class', 0, self.__manager.class_pixbuf) ) + depth = 1 + else: + depth = 0 + else: + insertpos = 0 + depth = 0 + + if cls in classchildren: + for name,filename,line,attribs in classchildren[cls]: + if depth == 0: + type = 'Function' + pixbuf = self.__manager.function_pixbuf + else: + type = 'Method' + pixbuf = self.__manager.method_pixbuf + + self.__symbols.append( (line, name, type, depth, pixbuf) ) + + + + return + + + def __precompile_methods(self): + methods = (self.__extract_symbols, self.__get_symbols,) + self.__editor.optimize(methods) + return False + + def __show_window_cb(self, *args): + from gobject import idle_add + idle_add(self.__get_symbols, priority=9999) + return === added file 'LanguagePlugins/CPPSymbolBrowser/Window.py' --- LanguagePlugins/CPPSymbolBrowser/Window.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/CPPSymbolBrowser/Window.py 2012-04-25 20:06:11 +0000 @@ -0,0 +1,68 @@ +class Window(object): + + def __init__(self, editor, manager): + self.__init_attributes(editor, manager) + self.__set_properties() + self.__sigid1 = manager.connect("destroy", self.__destroy_cb) + self.__sigid2 = manager.connect("show-window", self.__show_window_cb) + self.__sigid3 = manager.connect("hide-window", self.__hide_window_cb) + self.__sigid4 = self.__window.connect("delete-event", self.__delete_event_cb) + self.__sigid5 = self.__window.connect("key-press-event", self.__key_press_event_cb) + self.__window.set_property("sensitive", True) + + def __init_attributes(self, editor, manager): + self.__manager = manager + self.__editor = editor + self.__window = manager.glade.get_widget("Window") + return + + def __set_properties(self): + self.__window.set_transient_for(self.__editor.window) + return + + def __show(self): + self.__editor.busy() + message = "C/C++ symbols" + self.__editor.set_message(message, "yes") + self.__window.show_all() + return False + + def __hide(self): + self.__editor.busy(False) + message = "C/C++ symbols" + self.__editor.unset_message(message, "yes") + self.__window.hide() + return False + + def __destroy(self): + self.__editor.disconnect_signal(self.__sigid1, self.__manager) + self.__editor.disconnect_signal(self.__sigid2, self.__manager) + self.__editor.disconnect_signal(self.__sigid3, self.__manager) + self.__editor.disconnect_signal(self.__sigid4, self.__window) + self.__editor.disconnect_signal(self.__sigid5, self.__window) + self.__window.destroy() + del self + self = None + return + + def __destroy_cb(self, *args): + self.__destroy() + return + + def __hide_window_cb(self, *args): + self.__hide() + return + + def __show_window_cb(self, *args): + self.__show() + return + + def __delete_event_cb(self, *args): + self.__hide() + return True + + def __key_press_event_cb(self, window, event): + from gtk import keysyms + if event.keyval != keysyms.Escape: return False + self.__hide() + return True === added file 'LanguagePlugins/CPPSymbolBrowser/__init__.py' === added file 'LanguagePlugins/CPPSymbolBrowser/class.png' Binary files LanguagePlugins/CPPSymbolBrowser/class.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/class.png 2012-04-25 20:06:11 +0000 differ === added file 'LanguagePlugins/CPPSymbolBrowser/function.png' Binary files LanguagePlugins/CPPSymbolBrowser/function.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/function.png 2012-04-25 20:06:11 +0000 differ === added file 'LanguagePlugins/CPPSymbolBrowser/method.png' Binary files LanguagePlugins/CPPSymbolBrowser/method.png 1970-01-01 00:00:00 +0000 and LanguagePlugins/CPPSymbolBrowser/method.png 2012-04-25 20:06:11 +0000 differ === added file 'LanguagePlugins/PluginCPPSymbrolBrowser.py' --- LanguagePlugins/PluginCPPSymbrolBrowser.py 1970-01-01 00:00:00 +0000 +++ LanguagePlugins/PluginCPPSymbrolBrowser.py 2012-09-22 15:06:05 +0000 @@ -0,0 +1,23 @@ +name = "Symbol Browser" +authors = ["Maarten van Gompel (proycon) " ,"Lateef Alabi-Oki ",] +languages = ["c","cpp","chdr","java","perl","php","lua","js","lisp","pascal","go"] +version = 0.2 +autoload = True +class_name = "CPPSymbolBrowserPlugin" +short_description = "Show symbols in C++ source code." +long_description = """This plugin allows users to view all symbols in source code and navigate easily. It is initially written for C++ but as it uses ctags it also works for most other languages. Press F5 to show the symbol browser.""" + +class CPPSymbolBrowserPlugin(object): + + def __init__(self, editor): + self.__editor = editor + self.__trigger = None + + def load(self): + from CPPSymbolBrowser.Trigger import Trigger + self.__trigger = Trigger(self.__editor) + return + + def unload(self): + self.__trigger.destroy() + return === modified file 'LanguagePlugins/PythonSymbolBrowser/TreeView.py' --- LanguagePlugins/PythonSymbolBrowser/TreeView.py 2010-11-14 02:01:01 +0000 +++ LanguagePlugins/PythonSymbolBrowser/TreeView.py 2012-09-22 15:06:05 +0000 @@ -6,6 +6,7 @@ self.__sigid1 = self.__manager.connect("destroy", self.__destroy_cb) self.__sigid2 = self.__manager.connect("update", self.__update_cb) self.__sigid3 = self.__treeview.connect("row-activated", self.__row_activated_cb) + self.__sigid4 = self.__treeview.connect("cursor-changed", self.__cursor_changed) from gobject import idle_add idle_add(self.__precompile_method, priority=9999) @@ -162,6 +163,15 @@ name = self.__model.get_value(iterator, 1) self.__select_symbol(line, name) return True + + def __cursor_changed(self, treeview): + cursor = treeview.get_cursor() + if cursor != None: + path = cursor[0] + iterator = self.__model.get_iter(path) + line = self.__model.get_value(iterator, 0) + name = self.__model.get_value(iterator, 1) + self.__select_symbol(line, name) def __update_cb(self, manager, symbols): from gobject import idle_add === modified file 'SCRIBES/Globals.py' --- SCRIBES/Globals.py 2011-11-10 15:09:01 +0000 +++ SCRIBES/Globals.py 2012-04-25 20:06:11 +0000 @@ -33,8 +33,8 @@ root_plugin_folder = join(library_path, "scribes") core_plugin_folder = core_generic_plugin_folder = join(root_plugin_folder, "GenericPlugins") core_language_plugin_folder = join(root_plugin_folder, "LanguagePlugins") -python_path = "/usr/lib/python2.7/site-packages" -version = "0.4-dev-build1038" +python_path = "/usr/lib/python2.7/dist-packages" +version = "0.4-dev-build1052" author = ["Author:", "\tLateef Alabi-Oki \n", "Contributors:", "\tIb Lundgren ", === modified file 'po/Makefile.in' --- po/Makefile.in 2011-11-10 15:09:01 +0000 +++ po/Makefile.in 2012-04-25 20:06:11 +0000 @@ -19,9 +19,9 @@ GETTEXT_PACKAGE = scribes PACKAGE = scribes -VERSION = 0.4-dev-build1038 +VERSION = 0.4-dev-build1052 -SHELL = /bin/sh +SHELL = /bin/bash srcdir = . top_srcdir = .. @@ -36,7 +36,7 @@ DATADIRNAME = share itlocaledir = $(prefix)/$(DATADIRNAME)/locale subdir = po -install_sh = ${SHELL} /home/lateef/Dropbox/scribes/install-sh +install_sh = ${SHELL} /home/proycon/scribes/install-sh # Automake >= 1.8 provides /bin/mkdir -p. # Until it can be supposed, use the safe fallback: mkdir_p = $(install_sh) -d # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWTKOAzUAGKV//////f////// ////////////////////////////////4Cy+V4oPe+xL4+fePNnzY1S0ysfdzpvbXQDYfe809BEQ JKCgBWxvBvvISb7TvGgZ4CvrRyKFJUACVW2nXu9dlTQDNhStGbWa2GlBmGC1kkICIDVMxl8AADSS mhkxCntJtTTEyeieminkaYjTUzJlM00yZT0aTaGIYU2mm1J6DIyNMnpTxGhpqZ6p6ZRgxTNT01PU 0zJoYmp6jaTBqMNDJk1NpoMBA0MKPJqCUgCZDQjTUyNCU08NSaG1PSDT0gNAABoAyaAA0AANNAAA AAaAAAAAAANADQAAAAAAA00IJNNFTzURoeU0Gagek9Ro9TQeo0ADQ0NAAAAaM00gDQAAAGgMgAAG jQAAAAAAAAAAAAJNKIgQSYVPyao09pT9U20p7U1PTaoaHlNlPUeo9QaA0DJoDQADT1NDQ0D1ANA9 Rp6QNAAAAAAaAAAAAAABoAAIpEQRhMqfoEYmVPNDKT1AHpmTVM9FG1Gj1PTKPamo3qmnlMQD1Gmm gAG1NMnqDIND1AAAAaD9U2oG1AAeoBoANB6jQNAANAkSEAIAjQEZMQaEYEJlPFHqninlPyU9pI2p 7UnqNGg2ofqgPUGIeoekB6gADTQaAAABoAAAAAAABoAAaGDY+DN4L1Dbe9uC+QbbVchhDxj17JE4 cOwAhDp4Q6CHbhi0gE30nA7PHpGEjhNV05+0r6KW3nfE+uvw1PWz/8gras5GMzKxMFjoOk3lq7dN C8rRxAAIyMRB7Ye8ry/ywDO5Jiy6EfjjTHU57sqzYYHpGucpCcmBfRMChxYu7EVzgQ3sIFRSDFYC wltFWKSCqIqCIqMBERQYSCkBQigiKiIkiwEYjAKhYH77JUFCMJCEAiCIBCIHiXzIUQ99BR+bbPg9 nytcnM05ZGmmMnfumBNb5M20MrCtNlp4yV8hmd5jJ412XG/3/Qnn8yhlgtYp3tmMGxxt4vPGTl5b qJotmzGNjZnddzhCptcuElVhNmgYwFmXKGJNfbavfZNcFNUswhUm4TJiyKUbbKjEXxPBOjhDpDJA q87XxeXxacTwacyjb83sCgB3JBwSgKQWWJYwel7fesfIZMwBa/yGiX+SmM4KVB/k1o1bGT8tczWo s5aSEuP8hVbgbmC5M70Muexpg/Mzcqi+LbJ1wVW0qtj6haODrI0gHAJkb05Jcubfsr8O+WcTny1x 0DeWa2Nc2C5dTJqHsBVazeziEEc3qsQEYTpVZEQZ457B3hSKY4Scxg5SJYHJaZdSpksnF2WIScCp A0oxKWBZaiZhXvYNh5RZEehRGaraK1im7HQbDsMNJb8EQKHHwsMtwSln/0z7VUJjGNtsbGW+1zuX TxnTfOT6qpCkvm9ZEkI7rSXgZa52apJIs3VBxDAq5mcnQS/Dl0NsK85u70gjBuWVlWzFw6ARiymU 7gRFtCc8FS6z8hj4QrZksfLebg6HNw9GriemiZSIQbicQIgqptzuibiceRgLAKOloCqU5RaaTFRG JfGP2ZxEBxZmuaMe3bBwfZS4q2TbbGr8sXO9JJ58FiAJVtJTTXddVVFHoMRCAEVkmy6cmOoH4E+F NeDgz7NI4KH0y+jSU3/YMzqLi6TMc78HFqoLTQvNxV/VCKPgdOJYEIqLKBAdYnPzJCm5gQdOFFoK JBupcCaKS8JJVlClZKYkFeR5k80eZ+DvhG4EPNrN9jA8Pkfd+bdPDdqnHduAtoZyXzGQmprAoEEf Nx+ZH3UKOvODqzioL4EaMvmadV2mrMi6sQYavsjUSEfuUbkMBttNpDGgrFLaw/dYMIYL5GZ2erv0 NsyRcfq3SbY/R98+VMrpO2++OpzKiiUy67qRZMaDNlkQVm1lw2QdCa8aWlQ4m614yDiqAUFVVlFB FJCQMEkGYqqToVZrlsmLlKB6WF6B517QFvUp4nb9T4p1BXgbT7DPbm41p1HtMVOfp0W0kdTqDGbh GUzGWA6hTINVJzxV0Z3Qrgxitb+6cfPKXKporea/PopPGkx3X2FqM1onCr3GT5J5NX5uV904opok zTZRRUpgtZiy4u47FJ48pfTmncDnoqpgwcgKaHQCqbg3Kcq2cpQUIUUdBUg2d742WmExjXHCfgys E3uu/GC25psjTbk11tt08mhUndZ5xyiSNT7JgWFRtZi68SKDqKA1eVXKkubSrlZodzKbJK8RGMBa 2r4yKmmySshOhktFc8SydWVdtpMZYvw0vbtiZQrtmKYLF4GiK+1XSsdhnaSrRjbUaVUoVVPFZJ3+ bCJR7b6AjFJDdZ668uNhIhapkVMh7XJRfldUjsVkjJ+RDXZsjnGiTNUT5t0cZUGxcn6jPmyTO0wl u1RdwyEFQFNHVFTFMB9gpabjXsgRqpOwZQc5RxRBU6MZVMKRXSGppDE5b/LWUqKkEg4ElwJsG0m0 lm5XhStLGVURatyzhTYPI0rECNklD2IwYGMrnBxjHF6VAguAKB8lFiiStqBTRq8ucQKgoYCuBxGK ePYwwHOamcczaWYV3pBXRbLlSIg+SsGXCAQbgum7s5cEugXymlgozYLeUZQL6Dn8wyE4yyMhc6hY m58jf8XQQl8f9N+C0mzoec7uanP4/Q8nlk/Ny+eb8lbplZZb0Kstqgs8heWl119tnGufohttaWaG UVbQZNssMlk02NtQO5FVj6L4FT/AKukyp12g0GoWX3uy0GKKFpjhk14SB6TnuKRKCZ29fVf0Y0In hhztoSuxd/BvS4H4tY9Oaw5rgHANd+uMYX0rjnGh8fQ+56znAPYEr0zGJHFPSO49R2ZNGs2uG4sJ sEiG6w0TRmTNmDFCjMtjAmHDKCZsaQpaBgfpfC8Cd5t35gPhKeOPGOJcOCmNqZisxKtt3KDEdfiu /B9YFK61J2t5Zl08FAyDSbKrJ9e8tb3ZWzPd8fVwl9T4ZK+6w6Y3hJ5JfIOnNq1qkUjmQBTyaNO0 ousiokoGSQ3BDB9Z+w/XS/b2i2egMF4waNplB8U1knKijOycqtXFKqqI11wWXztorKfDdKy13O/a ckd+a510NiF723TixqCb8Zq0u4M8W+G2kynNZ9OwlZb7k911tKwK3koW+5Irg3FkWYkrRqp23ZWL +S9hbbXdGsxdI03UcGEHsiuUDTTeLqsvqGraMJvLaiarIRW1iMAlBGkZVtWxvuUwbfWqw4owlfCN FV9arSkecLQIorvFxKBtXk2EBAygVL1Y57ci5ojXDgi6C1/KelyfsMwrgz2Itv3qq6bJFmmZBpFb KqvFbIw4sGRU5yRkjl3MUs6uXvzUFjB0dUWw385Mq2WLN+C2x6nHtfCqmZZwqLdgb3AT1cS5L/s7 ak1rZrpG9AZZy4THJ0h2p0Lpy8w2aw00ljRBqwdcIZxmY7DZtm6i8j9V+c9HaLxNv6WCGl4w9Fi+ 4H9f8VHu+LRr7vBsfRAUEZf+Y21b0MIgPnhjfuFdWixrg4YLiRd9eicz0vVC/tWkY9d2BgZAv0PP FA9AzSdUGYZQJqGJ3yDJk3ZfKnbZYVTUCkzrPdPj9dpTU1N+Lw3mzDQ9BbEKhdHeOK8RtNG6PsZ7 TV4VgEmggb+Rd8s9ggW/3naRB3ZIbQ2By7xhoDZ5gzcqOUJiXqhQoMSg4BAuE9QxIYPGG0uNMNZ+ /mYWfxjEi3sGWfaYrAmcy5hIN42lxQ6KywLwrKMSDnMrLdm3CMb2kwSD3ikV8Dsb+Lxi8+8vRyFV 54SHWb9OtSCl4S9X8GSo8cSAY6TZJANQ73HS6NlzpLJmZiMx0tC4yrUBVKfm6YMJ1imyYVqBzjOS ZMTSzdnWTO4351Z0CQibZqa91aNRKa6D16VHCJSgkTBx5x0tDYYqSiUz3W4piZRNnf+f8LY6sQ9T oHIzbdPQEzwESidu3NzYpRblbCkLKUgz7YURVK10SQaA4J0msi5m683z8x8XH5bGixVd1mQKUxDi osiB2E9+BFGKTRJqbFNqO/orku9QVqYU+TvWWIvBCGXEAeKX00jCX1REkmwSQ+hn2B3ixXTLMxQZ irvRvoOxmtYLBWqICTKoNYJkChXMpEVGPqqLAVYkFIJGATFsCZ9GSOcrpID5okEyVRWQXgmGBQr3 i8SLgtAbnHsgMLkmDbdCQk0gFo1KwqT+/mP5/qihchyYtRyjEUxaAot1SOXLZIbFi6mPZvkjhU68 AvaSflqOVnybC0NZaWCQPs577aPNKhKo7NZIuKcx6gS+KzUeYyMkY3J8ucSCU0ZkTetS42GlYGRe bfCX794JIxKtZLQc05didMnllTRItMrM4xlCZI+CJBgJBaZto99vEkDIysMSoqU+YSJYFgZEu0az YailKksJgmA40D0eS1XLapFFIEsRuYKGCMzCkoYGjKlmKWpxNgtLCuhQikpPLmhs0QD1HAMGEDQM FJAYZxTAoSHljzEYa2mF4s0leQJxEyYWAncsudtnwdjTfXa/PGm16zMax1LC69t8lR7fMJBjqeot AEWgsCUCAXJnAEckzgJAtFurMuF6NZUCkW2F/YrLleCY7bDgMCgUyNpQdKOgWACKyCoWlxCDq3RI ihcFF4+CoCi4piRIlZaxRIljbutQsREN1u1huIrUx4TKyoaZxdu2PIGJnO/MBpnKOPGqcIgeJzsy MMrjZXbexWwtWnm3Ogu4lGSxEYWiICxElIrMXHWwcu2uKa9eliKxNJeUTKcy0iweOMwx5AUORlco DGmkRAoYTTalEiQFwkw25JYSIFJDSouwemgawcWApQqBAY5KaKzQjXa/SxtNBJZaGcWRsVdwwZya AyUzORUJB+R6RIPQ6buE2GjKeyTM+jOxkm3ttVowqfW+o1BAV3p6lMtOPjftTFYjERC9qxqg0aYb c9eFhWNAEMS8ay4haUM84F0N8TuONmVNsKjAca816OS82DfBHC5IDCUr+ATK2VAjm3Vp2kGckVFx 2N40rSaSvE9091YiQcvztm0Riyu0EiO+o2vJ1OcGTKmb500gig1Aka9OLQ1jwS0UGsSRLVikRoX3 MEQLAeaTmwRo0AQmOJoVjtsksoCzfUYokXsIi2BFs3lmA0WPR02pssrqNg5a2x5bAiYlhQl8u4xG ES9FIQLzcF1b4iYpkXPLShJqKTmucu1jbss68HtOT+1SDjNitUZnZ75KjwBYG0IEgsLZApbpJs0l CrS4OEkswV5H0gg4gWQkg3ZkjbDAt0it68ruLax9RgWMa8htmCCFxmLRbxaPJGocD82BbWLMCp55 +1N4N/ARAt8R+38ktrNblgYNW6/NwYHPDY2djYRK5vKyc3mYtCCbRqFQNRAodCIl2s1zJi3JE2ww GTWKWaBRYUIFJ0aOBhErFiiMCJUSNRnMBWsqEQ7ISIWEgcSKuSR5oIl1xE1JUGId261vrX57rcU0 Irl77GrUKbVfLJbBMDbwRhWYkiOsmR6r1ZIFKXlBhMJC6GgiWLIJs2vFC3msEmNK1jTb1RKzMIgZ Eyhc8gPGCyg+vPcjRpUV7thoIbZ4WJ08vBxQrKzMLLLM613misqJAoxDEaKtThnbk/BeGRrymVtv 9EutgtUVxwZtEBRdK4uImVVSL0t8sDcZthaCyGFxCqJrSqc2SGseMcbQ/UPwHJIclpw22FLxxEzg ckF9UMgOmrN0q3DcihYNZrLpPBK09xc4upy/BM2WXsiCI04nQQSaAKMWpnBKemqsZ9PFbG+25/U8 cq51RGuftOuc5FJE5X1ysZUXS9+vnJpG4OtTVpyR8mWEFeV/YIBa45T2pcZSYwOM5B1nb5CQIuRU SEhiLCBbwQaiIQiKOErhS/F/lONQ8ZzG9jb29WwbquJY1rX7qxzMMdBk9689y8fJy2EMGMeJYqW0 WWka3Aa63vv2/G8H3H+vWQ8kxgwBF8rQCnm4UIc1mBikDCSiKABUh2XQ7MvPYjFgoognRjDrpFFw yklCxEokYooaEiglESKgogsund92G2AaabT437v0HnPZNnYPtwMcJNCyJQEmSaCPZqnFKhH0MweQ 9k0XIn9bC/UGIALQnzgEPK97rxlnTbWB4XgvnBe7SdhBECTACvxMg/Nj/QEHwbrgpkO8yX4HxOz5 1zEwwIFiGAiFiPePbXz5adNi19KzmZpIiIQ1OPR6+nfRnw4xNzT4p1JizKkRrT0BcOxoCvr+GMHj pz431Mykulo50kdnONhWpvaYgwhtJPwxbBlCILxW0MDhswM+WWIkoQvJo/y1M4qYwyNYOIFyDEZq BwP5MHY7xJ8wzFhm3nKTFkCC6ho/MwLABilq7qnyTjIiSJByA3yEn3cpEMg8jVRRpN4XyFgU09LA 5eWKcDLe5LEWQ2LJvim7dg0SsArCtx1DxFd5KyHOhDJpHYIw5DtEMsEvaMi4fq/Bcbcm1K+9ILfN 8OXepSImRRZPsXeqS8yTJz2JGImKW0sg8uQRC/I6zq+PLozyvMFnJSyXHxp1mjY33WxgWVxJchtA OPjwAuhsW1szMcYxgzA4GMblzNE8HQKreql2ncykXIQwvGILDaxEG4Dt1D16rNbDGD4kGlYygECE ZB4HJzqbJCBQINBrSihIhyWj5gzggmQSY+Ki4fdQ9C2FSx/6QKPYDvGJMNUGiUJq3IUqWISRGAc1 AQ7j+HXXuOTWhcoJCk1DC2hgXACfL5e04YcILgSuKIkZ46ybYRMFkLhF0mEdBpThORRDyWxmMwid T8o5IMxnlsUhhiQAd8rXgg0Osz5mLIvE8hmddpTR4jZSSCASUYNfq2+9/hL3RdhxflYXauD6ZK/J Kus1xqBwKenk0wpu7WJEqUuJMgk9ZlESLUAU1Pr/T4mlv+J2Fvr9xdI2xCEqDKkzducFc5OWIM5J HaGDodz7GE4u0FIrEUgxIAvTSjHkVWtaHKyiCTPNcQxBWQIoqrFWLEWISRZDlPLTcAr4GDscAmZ6 Frq4WLlg7lwqvmIgWNuvJVkoBdhNkDiZUJGSzKJdDSwgbQ0WzyWGNDYZPtdSZ4gZRkiO68ME48mz d3bNgRGMHeJSD3DNskKFBjCmJIcsmkN4aE2oU5ZTZJBNhSlG2o2pIO/XZ6AMGeGu/fNDZu378aDW 22220tWjdDZONDjNsDiVU1134ms3MCocdgFgRITwhhnAWW2MnHpw0DTTiECciOlLcgSv5F/FIlFL EWeN09r/PXbxj7/Jf16sunV9dEERcwnZ2RTVkIFVPJFBqcjUKXpXodo1jVHGJm1DizJlcgg1x9kX F5Mep+99YHP0nR++pu6nYZGQY8G5ru4rv9w/CtdauNpIDSAblfyHLkcKs4f3pxfeTm4RMZqSRC3C EtsLwPgQb6T0pccjkpZkmC2nJ2iC4gkbAp9AET8juAefWcBWhJFxUGBmzJjQ0NCbG2MAbR+YEhWl yDUXCkcIoQoVQWB5fIL12azMJC7e8bEzyJZsyQl+xFqjWWA6aW2yfvO64qkagSDSGUedYdxbCIHa FE4D1SW0oCuEri9sWuq9bgHMJCOMdVgA7I3bwtt6qIMZsYtqsY2f5HjbPa4iI7nuyCfhLjlO6eMJ lPIVeImR6clYTKeQ6ihXAyCY8qJkhosnUb0SXRA4nBOm1BFqWmY0g44BaVmnUdr0OiO5Z5OAFO4t NpvrOt43ls3hfXMGTvTRikhM7dm+tnKfi/HOqOOHcpyDZMKyILADhc8gmxKptCtVIT6PChBu4dev 6Wn0S4SuquDjJ8Z7AkEF3B0dg7YeyC7R0kgZiZHaKGYyNil3L9KzDDacaEYl2kvLifhWRIgg47Mv HyKnXpMS30R2cpcGnjg7n7IeyTFOPaox6Ge0JthjcbWzTR6yvXer99jUn6V9VwHmnQcjDQumA0dM 50zrBLBknlkZJzyQLDfvFECqS6DiD3EhLTNI1tgbbDAGTek1yNckLINwZgpcB9WMbRvNQ8wkiSuM cCLijBsQ2qJRo1gx1NkF4YmEyQeJHWca1LD2fxf+Ln6g0OyQ7IYjHuWbuLIoTCj5FdcuMmwLZmHg K0VnN4TcX2HSM4iwO4b/ZkHWqz1SSaGw0GYuJTChiecoVmlCPQNYbjUJGbNI8KrNAzJAjYE8JtNt BtQdcDT2B4c5jiZzbltPZQFm+S1gbTWVn1s1oGnsCG0NRBSUDM2bNziPhNJtRQWKApMHbbpgEkmO qdAkZ6x13XtjKRSZu4s0EAyGrBEUVC0OpSbkMJdwqSOTh4zsnItoHj5QR4skHf5kCXnO8WAZIEat i/resQAeki6IVYXUMbvUJ95055DuTam64zQqnVdEcUrbVacjeWy8drkzOcYhsxU3UMIYiiq5zO2o 9BoCd9KkEUm50fwgkDkpO23u2zZjUDKY43cPDAGeMz3htNmdBdsWbN7q2Z4WqO6shTYE0qQEAxFK iysgyGKasVZXIQYB3jjt18UiZBYus5MJHh4S4PYEgqMDgKtBflmPDKF8BkNsJYMtLV0+Cson0jNN e/pNzYNtjbFvyFJg2cCA3JJGbSF6S4GDedRbAldUguoG+yaZBVQQTN9JEBREnxYOs0HGuNKwvO4S Rwmw1m9vTP6HIcZYHwRakJpYpQAxNyzvflr2DBg6FpvnGVUXrahdaXpOIaGmJqEkUqNi0+UzCVxU k++Vc8G46PNYCDsmpIFpUAQQYnSpVrA3jkJ8wNC7LEjVowOLswX5eAkFloHdS1IUk0CQHdPEev4j m3/wAXInWis8le9taXH4g4i6egYbip0hoDmgF0TyqgXMMdUKsX1YRfZyCRsRULEYm02waN5iFvCX f00FMSMDzfPvUypWQJccwSUSphlGiF4c8zYdmk0NBQtLECoGRZqXx1rmSaMwaMJ47AUwhkkQEBOC fhmRKhlAVkhlFJipZmJITaAxIIa9l5TnrM5Nuu+GDSRkSACZNhZXfd/rq01jExi3V0qZBZCcBCaC d6KzRQuVBrkIawDdDaDEQWAIiLAVikNJTuyoqUExUq1SoLhZxBqgs1cZQIAbSAyB2JHF9G+I0nvV xDEIvvUR3EjDQe9b87+b6ZqBo0Q5xjE7Y5tA4GqSQ8jSSjJFhEwGsQWNoaBAFCqBPw7PIeA3HP4C D05SPS9Q9ktqg7t54zylpNTMTEhSPKExzNSfHrkA0s5zhI6hjLK0uNKckZrTEYnrWyJAhEelCDRU VJqBChscjYaV2j2UAwyXqCCJiCuuEfHQ5qqPOfFgbTZ7Fga9iJhBi0jOa4dKr7VdGcwDyMWANFoM Bn4u0etRrhiIU6AzibEogb3aHXm85x625N2tXouOB4Pou+6noelBLzrXNLlDlPzLJkJQQPHYVJD2 nAmOdCQQxAoioAoRYCiMQVhwA5ptEOf8aCSJORIgaYiswSQc/SDGgoV1KBm7pgoxSjVb9bjfqzsD YK96jAQujaqoVxO3GGKG4Kj5boeb6iW4NGIV8z0u+ooz4BgyxQzhQ5Zoep5yVSAH7tiSDY5Cg279 XxQoQFPBSomG8RxNTTKxItyTuxVQcqELDdIQLJX2J7jt6Cc0XDXwaDhm2srQJB0nOuYn3/gyBaUx IJnTHfgeqpb+tIOE0EhJNgfSAXszATD0vAOsmewlXmF9d7iYNjEDGSI97yCbko98d/j2bjM5uD+q +BrVNmybNmfA0I70QHACMFwCDiNCQYDA6AfuHmS3HGMEbw2hJdQNC3wOZWEBcziQlyNjQgfe84Q4 IK/BB2Rh2xJXqW1loRAztyhq1yGePnYMbQ00DYlkhKxpAHdz9Xn3t7ISL8VnTObkfN9JVpsjwZuU OJEypncI4hfAPEWEjY2MExoaEMYwRaHC2MXa7PAhYLE66IOhIXF9zZJ1eF8QSXIJGEpmpvaC4UnJ sfe5kd2dSGwKRPmu2i25kCWOJogJgvdO2ANibSW2ysaA02kfQ/xugcPE0uVRvJ3Qoo7R/fHzVzi3 gpEpbQhkbckybuA4goVm2WscymZHALi0Kld3jf54X7rHJFDk/g6ba3EFPVJtSYwHUO1xoq4yuktq ZAbMN3kBREmbyTBLMCkdakBFQVAqwkE0DPqDzAG8vKeaPiRBwcxxLxEzcI+WwENpIjT415MxpQLY A0dSgA1JNdtoDtRRhIJNCLQUo6QGJGBWhW0aDv4lSFjaVqmfnBSQJAebJRJ0zscIOpzEU6NvYlq6 B1iks1izyoU0hlkQxonAcXpj9f1JopYEFyee+NAZIza44iSI0imlBsH84+wpb2uf5zK7zjXEbi3K ZCYMiIQxDDVmBmEJiYxDAiMUJjkiQMwGHIKs0aJgaD0gaVyAl1cvbLb8DT6n9udyB3QkoY0QmwAm cCZ7HTqTC5hrl3tU64SFIiIYGCCc5KfeZqFZib+SEkZiSEibSSMaLlLjsndNpIyMzjNXDdbl8Oej 4VKh2nrmWQS9EZ8rQaEBZfhCSUBZlTmSvNIItAvSFrOYSCaPaM+8BoaSrsaTC28dzA3g4yWZkgoY LKJElYgzGiGClwGI4MYawRMRBHGCghis2O/ChIZzUMU38hRmRQt2VcgQoKJiJW1oWmvpPB4bNqqK mpNtb6ICcSE5IhJI47xRkwSFCwGGoU0EMLNZAwqTJzkM5TFJKQQhEeQBWIyAoiIgKsIIsYLJ1SQp SQwh67whdQV7cixOKhoRdcTSFwiQr/7VYkXpFbSGI51T1g7gPLzZDfHuCwNXj3wbNMUGRWCRXFFH JgmFGBAzGcCkDOTIb3nqei07/sMPKgTaRr5MT5exMDhZ9j8sisVyVYuULkfGQHcOptAEAYfaly+6 rp/VI8wCgYMGhFyI0Jq9mVBIJB7LQ2KYhNJhPCR6YMMOECaaUgaOqUJSiEggSE0DiEH1gC+QZiiE X0FVJL3sDNOEpCBx9wcybAwQ6YkibJsiCzDLGQsgiEIIGJNpFagUJIkR5GGmqm13LEPiK0WRikrm kOE1BIN1ibCSLmPQovXAl2HQvhm4m+anrRxO0soR5tGtBhYWE8xgMBgBhGAxAlg0CX6Pu26aV3w2 4pP06ku8M5TJVdxPrsNS1752OvEnFoMXR6ZVRIPppzEjH1forfPdCwgsRc8yP0gmLUCNaNQMgNK3 gXizZpl7AQZwnOsMRL4YxFbGjPmKW7goewXGC0go23otELMcyUuPqWsFsIBF5QLWdXA1mSkHAeuh KAmFxFvxRvMm4rAtVYJJASqhgAlhx4VMEkkJeBggEt1tC+34P27PF0M8NkHm81zS4YQ9UPyfRfDb OgaiIqKKiIDIxUjGEUYIqITpssUMWhekZxkalZFiKqsFGKsiSIDHtWBRlsAoyIyKICMYsijGSIjD q0OoH12cIxJjYMqYmM8VamkiPGd/moVCAp0KssEwGmN2JXIwDs2fUiVyQHj59C2JoWYWIB20NCGh iRvHavEYVe2ZB3kB8QY3Y0QOGhtLHuHUTBFwbcRbU5bAWtCCMtkkxtjYweQDoLsFgeUSBqwTFcJI ilVe+LtzRuJJxGhCB0ZZqGtnLjzAsZFgDESbgmwUYSBF2FgThtotBdhKEDFR6OlRoiKS1hQsJS0g Bz5IcvahNITinW8Wdbu9butliOdHNapzW8VHO6phURBLazCwNDDO6UddcqOPhlUpXXQKwabTduFv li6d4ymJyEWGAYelG0Mxg1ymum7WzjmaBxWwQUu7ZjHJUuaYN4Kf58zaudjLsm283MKGuQxMLGHW 9uuF4RKu26q06lMmVATUIIqSDRWtUUqmg2aSAK1Uti4ZpK1BuPGj2+oxR2/J6tczEE8tqkgOHpqq LZDY0nbB1/H0VCETs3Biww4mI0YYwUwgImExil9WcGXLhKChgtC2Bc0KImbUCpFC1Slh5dlHRyIi IxXFMX2INaZ0tY94gGHCgkUOEPHkIc7kORBvohgFljeZUazA0uHsS9a4UmJOSAw9C0JEkWKUg4lc QkLovMtyqBsEbq0b9ggr14HYF2WDrgFrOFYICEV584sk4Hm0gsUZhoY0mwGNAwGCRbnVhiqGcz8n SsGlaC2JIkZWID35TzEbWrw309FvfbzMS5s9RY00mFg4BgNMoGYlxn2/tf8v5Wv/jvZuEYbjghGV YNgNqW2vzxPgVhCXlKMJfXzIL7GSIsvO4xfk8asC9WMWKKnFnHDbqatNNWzXPDOmmkLbwKdqDNc0 5DXbPrZ9HOEAwwdQYcKShvpAobmFig7kuChyshd8tjYBQGAWkVUFVfXjxFSG7qJcDvSVxMsQYXzM 0xSGKp1KqAK4Yw7UwqpMGNsVUCoSSQSCyZYCocnD3OQgQEjQW2bBNNPpGQxNNqTSwqrRqHkgXKlk WlK4M4tAHOF5gJqiq1qFIcCaGgbTfZaU0dSD3FHoXAvROBLSlwC0EYFjYNpNIYMbGNpoGkhjBVpI +MYZhaEpnCrrWhppMavzsZCDhQgYpSiqxoDhPDcTFLLiFsB5+AbVSgVOk0GWzFChFrQBAQhL4hlp M+0FsOv2/n/Zz9/u/K6vffMI5N7j7fJs422vkwocWgTQNaokkZkiMtoxzSDJKwVkDRwyoARmAcR3 tPGuQ6SCDWVqVBJHUAFiK9SJDQswfcvyHScBNHfyAuD1uoFmLEkbRM9RVQxiArtT7IwBMdmEx5Tn ab1RUigoD7XxmDAiiqKipBiIooPq8pUBGRBFHooFkERF9AXwVnGuAytU9lMUMrmRQ0m6ath0VyJF 9DKKMGTPLkM45oUKjrwqStApgvOOus+59M4h4eCvCaEXpT4QoUSP940jdRrkEpYzHmeRQUwKL0Oa XN1yoMp2UJUVrkC3wkTRC77JxIJKVVsAiyRYqCQoRUgCAsoQCS5Fx+YLxJiGoxCrBAxcKyb2JVml 0FkaTaCVQXtYCRVbVAxLYBGIgFswBhrgOrfuaUG2ioeA8AxM6glj30vd80Koi30xPXf1mqkZxXVM WENNpklj2Z6hRTsTd2F/wLsu7LJK2ZrFzeO/kdLi3SXTWzn2ldUqYhf/20uegwQhaN/eVx4sXqKK N6IxU1LteFGxmDE+91gq7lxEtL+h64lCXOvt5nGOgbJl749DWvtA4Zr+45XCJIbsr3u6gbepfVR6 e+iCzW/wNS2RS1lX93w0cBe6Wc8+PoFTzGt2en5qTSKtipNWS5bgt9y+IdE76HeKaihZ7aManw+6 +rLbBX7evOl7GP58J2HzDh6jdXXpv+k9Rdc1Tfi8frVfGL6/CKen+r3uuzXEpJ/w/a3K99/rubY3 LNUt75hasMPRrWuuisVeYPsUwRv1kyhlUHZv1rJffrajrYXZvzymkv/OyczrZ/XYXKd6lXVzeWjL PJ4NOmybg6uLP6mClk9UxI0NdolSx7DnO/zuvhVH7uGkb7NTeeG0r6+Sl3takM9SancVklNzUdsp 3GYOy1eyAguZyVnOUGg7lVwPUvL5yLOXWr79jgc/RQeh46bzWEjgYeFT2+398h89TnWLd2fci9Aw /y4St6uKEVtzNsuXauDnnDZV644x29g/t6F5p9hZ9eGaNf+ktJenkO94isgWq7DP835p4dCbX6dt ovFMK0cR7X3RO/QEDpLXt5ifvMWVjEsjTIOTH28Hi6JXEonZnfOtQnlb9GU2BOzfOpfBsundsnG3 uow63SDGe9g267B72s78xc8T1s2/1MP4bSFbszTPE25+q1lYuEVqG+UPc2kyN1eEo3efvWNkt6OF 2Gco/LrdHD7byeIYuaobLS8UtrG/tUU7meT6Fah3T0dWlSKGVwtO3ZJ3br1m/hGm8zqR2dL07mYq FunXTwn4653qVovLDPY23UZsn7WZlB8P/F3JFOFCQMo4DNQ=