From 13073684296f13d907dcb027b3963f00c5e44f39 Mon Sep 17 00:00:00 2001 From: Libing Bai <51594106+922397935@users.noreply.github.com> Date: Tue, 30 Jun 2026 16:00:15 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=A4=9A=E5=B1=82?= =?UTF-8?q?=E8=B6=85=E5=9B=BE=E7=B1=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- multilayer_hypergraph.py | 221 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 221 insertions(+) create mode 100644 multilayer_hypergraph.py diff --git a/multilayer_hypergraph.py b/multilayer_hypergraph.py new file mode 100644 index 0000000..ba1c850 --- /dev/null +++ b/multilayer_hypergraph.py @@ -0,0 +1,221 @@ +import random +import re +import itertools + +import matplotlib.pyplot as plt +import torch + +from typing import Optional, Union, List +from dhg import Hypergraph +from tqdm import tqdm + + +class MultilayerHypergraph(Hypergraph): + r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. + Args: + ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. + ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. + ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. + ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. + ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. + ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. + ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. + ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. + """ + + def __init__(self, + num_v: int, + num_layers: int, + layers_list: Optional[List[Hypergraph]], + e_list: Optional[Union[List[int], List[List[int]]]] = None, + e_weight: Optional[Union[float, List[float]]] = None, + v_weight: Optional[List[float]] = None, + prob_inner_layer_connect: float = 0, + device: torch.device = torch.device('cpu')) -> None: + + super().__init__(num_v, e_list, e_weight, v_weight, device=device) + + assert num_v > 1, "number of node must be greater than 1" + assert num_layers > 1, "number of layers must be greater than 1" + assert num_layers == len( + layers_list), "number of layers must be equal the length of layers_list" + assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" + + self.num_layers = num_layers + self.layers_list = layers_list + self.prob_inner_layer_connect = prob_inner_layer_connect + self.device = device + self.node_sum_before = [] # 总的节点数必须是列表类型 + self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 + + def construct_multi_layer_hypergraph(self) -> Hypergraph: + r""" + Construct the multilayer hypergraph. + """ + + print("Multilayer hypergraph constructing...") + + prob = self.prob_inner_layer_connect + _node_layer = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + + for i in tqdm(range(self.num_layers)): + _node_layer.append( + MultilayerHypergraph.select_nodes( + range( + self.layers_list[i].num_v), + prob)) + self.node_sum_before.append(sum(layer_num_v[:i])) + self.node_layer.append( + MultilayerHypergraph.add_numbers_list( + _node_layer, self.node_sum_before[i])) + + temp = [ + self.node_layer[i][j] for i in range( + self.num_layers) for j in range( + self.num_layers) if i == j] + between_layer_hyperedges = list(itertools.product(*temp)) + inter_layer_hyperedges_list = self._inter_layer_connect() + between_layer_hyperedges += [ + edge for edges in inter_layer_hyperedges_list for edge in edges] + + print("Multilayer hypergraph constructed") + return MultilayerHypergraph( + self.num_v_multi(), + self.num_layers, + self.layers_list, + e_list=between_layer_hyperedges, + device=self.device) + + def num_v_multi(self) -> int: + r""" + the number of node in multi-hyper-network + """ + layer_num_v = [] + for i in range(self.num_layers): + layer_num_v.append(self.layers_list[i].num_v) + return sum(layer_num_v) + + def _inter_layer_connect(self) -> list: + r"""多层超图排序后的超边列表(无层间超边) + """ + layer_e_list = [layer.e[0] for layer in self.layers_list] + layer_num_v = [layer.num_v for layer in self.layers_list] + _layers_e_list = [] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _layers_e_list.append( + MultilayerHypergraph.add_numbers_list( + layer_e_list[i], self.node_sum_before[i])) + return _layers_e_list + + def load_interlayer_mapping(self, + path: Optional[Union[str, List[str]]], + save: bool = False, + save_path=None): + r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 + :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 + 若无,则用文件路径列表,每个文件对应一层的映射关系 + return: 等待添加的层间超边 + example: + file_path = "../data/integrated/gene_merged_file.txt" + merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) + bio_mhg.add_hyperedges(merge_gene_mapping) + """ + if isinstance(path, str): + gene_encoding = {} + with open(path, 'r') as file: + for line in file: + gene, codes = re.findall( + r'([^\[]+)\s+\[([^\]]+)\]', line)[0] + codes = [int(code) for code in codes.split(',')] + if len(codes) > 1: + gene_encoding[gene] = codes + + hyperedges_list = [] + for key in gene_encoding.keys(): + # 只有一个编码的不用加入 + if len(gene_encoding[key]) == 1: + continue + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + if save: + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + elif isinstance(path, list): + gene_info = {} + gene_encoding = {} + # 遍历文件列表 + for file in path: + with open(file, 'r') as f: + for line in f: + gene, code = line.strip().split('\t') + if gene not in gene_encoding: + gene_info[gene] = int(code) + gene_encoding[gene] = [int(code)] + else: + gene_encoding[gene].append(int(code)) + # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 + hyperedges_list = [] + for key in gene_encoding.keys(): + # 这会过滤掉那些多层超图里只出现过一次的基因 + if len(gene_encoding[key]) == 1: + continue + # 这会不过滤,保留所有基因 + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + # print(hyperedges_list) + if save: + # 将结果存储到新的txt文件 + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + with open(save_path, 'w') as f: + for gene, code in gene_info.items(): + f.write(f"{gene} {code}\n") + return hyperedges_list + + def node_layer_list(self) -> List[List[int]]: + r"""返回多层超图的节点列表(有层次) + """ + _node_layer_list = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + layer_v_list = [layer.v for layer in self.layers_list] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _node_layer_list.append( + [num + self.node_sum_before[i] for num in layer_v_list[i]]) + return _node_layer_list + + @staticmethod + def select_nodes(num_v: int, prob: float) -> list: + r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" + res = [] + for i in range(len(num_v)): + if random.random() < prob: + res.append(num_v[i]) + return res + + @staticmethod + def add_numbers_list(lst: List[List[int]], num: int) -> list: + res = [] + for e in lst: + new = [i + num for i in e] + res.append(tuple(new)) + return res + + def __str__(self): + r"""Print the multilayer_biological_hypernetwork hypergraph information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + + def __repr__(self): + r"""Print the multilayer_biological_hypernetwork hypergrpah information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + \ No newline at end of file From b56aa49abc92155a4f3b0c794c8e8b22478d0b8b Mon Sep 17 00:00:00 2001 From: Libing Bai <51594106+q923397935@users.noreply.github.com> Date: Tue, 30 Jun 2026 16:52:31 +0800 Subject: [PATCH 2/2] Added multilayer hypergraph --- dhg/structure/__init__.py | 3 +- dhg/structure/hypergraphs/__init__.py | 1 + .../hypergraphs/multilayer_hypergraph.py | 440 ++++++++--------- examples/plot_multilayer_hg.ipynb | 453 ++++++++++++++++++ tests/structure/test_multilayer_hypergraph.py | 62 +++ 5 files changed, 738 insertions(+), 221 deletions(-) rename multilayer_hypergraph.py => dhg/structure/hypergraphs/multilayer_hypergraph.py (97%) create mode 100644 examples/plot_multilayer_hg.ipynb create mode 100644 tests/structure/test_multilayer_hypergraph.py diff --git a/dhg/structure/__init__.py b/dhg/structure/__init__.py index 3b32e95..5ca1342 100644 --- a/dhg/structure/__init__.py +++ b/dhg/structure/__init__.py @@ -1,7 +1,7 @@ from .base import load_structure, BaseGraph, BaseHypergraph from .graphs import Graph, DiGraph, BiGraph from .hypergraphs import Hypergraph - +from .hypergraphs import MultilayerHypergraph __all__ = [ "load_structure", @@ -11,4 +11,5 @@ "DiGraph", "BiGraph", "Hypergraph", + "MultilayerHypergraph" ] diff --git a/dhg/structure/hypergraphs/__init__.py b/dhg/structure/hypergraphs/__init__.py index d9ed176..fda3eb2 100644 --- a/dhg/structure/hypergraphs/__init__.py +++ b/dhg/structure/hypergraphs/__init__.py @@ -1 +1,2 @@ from .hypergraph import Hypergraph +from .multilayer_hypergraph import MultilayerHypergraph diff --git a/multilayer_hypergraph.py b/dhg/structure/hypergraphs/multilayer_hypergraph.py similarity index 97% rename from multilayer_hypergraph.py rename to dhg/structure/hypergraphs/multilayer_hypergraph.py index ba1c850..a49128e 100644 --- a/multilayer_hypergraph.py +++ b/dhg/structure/hypergraphs/multilayer_hypergraph.py @@ -1,221 +1,221 @@ -import random -import re -import itertools - -import matplotlib.pyplot as plt -import torch - -from typing import Optional, Union, List -from dhg import Hypergraph -from tqdm import tqdm - - -class MultilayerHypergraph(Hypergraph): - r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. - Args: - ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. - ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. - ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. - ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. - ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. - ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. - ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. - ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. - """ - - def __init__(self, - num_v: int, - num_layers: int, - layers_list: Optional[List[Hypergraph]], - e_list: Optional[Union[List[int], List[List[int]]]] = None, - e_weight: Optional[Union[float, List[float]]] = None, - v_weight: Optional[List[float]] = None, - prob_inner_layer_connect: float = 0, - device: torch.device = torch.device('cpu')) -> None: - - super().__init__(num_v, e_list, e_weight, v_weight, device=device) - - assert num_v > 1, "number of node must be greater than 1" - assert num_layers > 1, "number of layers must be greater than 1" - assert num_layers == len( - layers_list), "number of layers must be equal the length of layers_list" - assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" - - self.num_layers = num_layers - self.layers_list = layers_list - self.prob_inner_layer_connect = prob_inner_layer_connect - self.device = device - self.node_sum_before = [] # 总的节点数必须是列表类型 - self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 - - def construct_multi_layer_hypergraph(self) -> Hypergraph: - r""" - Construct the multilayer hypergraph. - """ - - print("Multilayer hypergraph constructing...") - - prob = self.prob_inner_layer_connect - _node_layer = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - - for i in tqdm(range(self.num_layers)): - _node_layer.append( - MultilayerHypergraph.select_nodes( - range( - self.layers_list[i].num_v), - prob)) - self.node_sum_before.append(sum(layer_num_v[:i])) - self.node_layer.append( - MultilayerHypergraph.add_numbers_list( - _node_layer, self.node_sum_before[i])) - - temp = [ - self.node_layer[i][j] for i in range( - self.num_layers) for j in range( - self.num_layers) if i == j] - between_layer_hyperedges = list(itertools.product(*temp)) - inter_layer_hyperedges_list = self._inter_layer_connect() - between_layer_hyperedges += [ - edge for edges in inter_layer_hyperedges_list for edge in edges] - - print("Multilayer hypergraph constructed") - return MultilayerHypergraph( - self.num_v_multi(), - self.num_layers, - self.layers_list, - e_list=between_layer_hyperedges, - device=self.device) - - def num_v_multi(self) -> int: - r""" - the number of node in multi-hyper-network - """ - layer_num_v = [] - for i in range(self.num_layers): - layer_num_v.append(self.layers_list[i].num_v) - return sum(layer_num_v) - - def _inter_layer_connect(self) -> list: - r"""多层超图排序后的超边列表(无层间超边) - """ - layer_e_list = [layer.e[0] for layer in self.layers_list] - layer_num_v = [layer.num_v for layer in self.layers_list] - _layers_e_list = [] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _layers_e_list.append( - MultilayerHypergraph.add_numbers_list( - layer_e_list[i], self.node_sum_before[i])) - return _layers_e_list - - def load_interlayer_mapping(self, - path: Optional[Union[str, List[str]]], - save: bool = False, - save_path=None): - r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 - :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 - 若无,则用文件路径列表,每个文件对应一层的映射关系 - return: 等待添加的层间超边 - example: - file_path = "../data/integrated/gene_merged_file.txt" - merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) - bio_mhg.add_hyperedges(merge_gene_mapping) - """ - if isinstance(path, str): - gene_encoding = {} - with open(path, 'r') as file: - for line in file: - gene, codes = re.findall( - r'([^\[]+)\s+\[([^\]]+)\]', line)[0] - codes = [int(code) for code in codes.split(',')] - if len(codes) > 1: - gene_encoding[gene] = codes - - hyperedges_list = [] - for key in gene_encoding.keys(): - # 只有一个编码的不用加入 - if len(gene_encoding[key]) == 1: - continue - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - if save: - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") - elif isinstance(path, list): - gene_info = {} - gene_encoding = {} - # 遍历文件列表 - for file in path: - with open(file, 'r') as f: - for line in f: - gene, code = line.strip().split('\t') - if gene not in gene_encoding: - gene_info[gene] = int(code) - gene_encoding[gene] = [int(code)] - else: - gene_encoding[gene].append(int(code)) - # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 - hyperedges_list = [] - for key in gene_encoding.keys(): - # 这会过滤掉那些多层超图里只出现过一次的基因 - if len(gene_encoding[key]) == 1: - continue - # 这会不过滤,保留所有基因 - value = tuple(gene_encoding[key]) - hyperedges_list.append(value) - # print(hyperedges_list) - if save: - # 将结果存储到新的txt文件 - with open(save_path, 'w') as f: - for gene, code in gene_encoding.items(): - f.write(f"{gene} {code}\n") - with open(save_path, 'w') as f: - for gene, code in gene_info.items(): - f.write(f"{gene} {code}\n") - return hyperedges_list - - def node_layer_list(self) -> List[List[int]]: - r"""返回多层超图的节点列表(有层次) - """ - _node_layer_list = [] - layer_num_v = [layer.num_v for layer in self.layers_list] - layer_v_list = [layer.v for layer in self.layers_list] - - for i in range(self.num_layers): - self.node_sum_before.append(sum(layer_num_v[:i])) - _node_layer_list.append( - [num + self.node_sum_before[i] for num in layer_v_list[i]]) - return _node_layer_list - - @staticmethod - def select_nodes(num_v: int, prob: float) -> list: - r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" - res = [] - for i in range(len(num_v)): - if random.random() < prob: - res.append(num_v[i]) - return res - - @staticmethod - def add_numbers_list(lst: List[List[int]], num: int) -> list: - res = [] - for e in lst: - new = [i + num for i in e] - res.append(tuple(new)) - return res - - def __str__(self): - r"""Print the multilayer_biological_hypernetwork hypergraph information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) - - def __repr__(self): - r"""Print the multilayer_biological_hypernetwork hypergrpah information - """ - return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( - self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) +import random +import re +import itertools + +import matplotlib.pyplot as plt +import torch + +from typing import Optional, Union, List +from dhg import Hypergraph +from tqdm import tqdm + + +class MultilayerHypergraph(Hypergraph): + r"""The ``MultilayerHypergraph`` class is developed for multilayer hypergraph structures. + Args: + ``num_v`` (``int``): The number of vertices in the multilayer hypergraph. + ``num_layers`` (``int``): The number of layers in the multilayer hypergraph. + ``layers_list`` (``List[Hypergraph]``): A list of hypergraphs representing each layer in the multilayer hypergraph. + ``e_list`` (``Optional[Union[List[int], List[List[int]]]]``): A list of hyperedges in the multilayer hypergraph. Default is None. + ``e_weight`` (``Optional[Union[float, List[float]]]``): A list of weights for the hyperedges in the multilayer hypergraph. Default is None. + ``v_weight`` (``Optional[List[float]]``): A list of weights for the vertices in the multilayer hypergraph. Default is None. + ``prob_inner_layer_connect`` (``float``): The probability of connecting nodes between layers. Default is 0. + ``device`` (``torch.device``): The device on which the multilayer hypergraph will be constructed. Default is CPU. + """ + + def __init__(self, + num_v: int, + num_layers: int, + layers_list: Optional[List[Hypergraph]], + e_list: Optional[Union[List[int], List[List[int]]]] = None, + e_weight: Optional[Union[float, List[float]]] = None, + v_weight: Optional[List[float]] = None, + prob_inner_layer_connect: float = 0, + device: torch.device = torch.device('cpu')) -> None: + + super().__init__(num_v, e_list, e_weight, v_weight, device=device) + + assert num_v > 1, "number of node must be greater than 1" + assert num_layers > 1, "number of layers must be greater than 1" + assert num_layers == len( + layers_list), "number of layers must be equal the length of layers_list" + assert 0 <= prob_inner_layer_connect <= 1, "prob_inner_layer_connect must be between 0 and 1" + + self.num_layers = num_layers + self.layers_list = layers_list + self.prob_inner_layer_connect = prob_inner_layer_connect + self.device = device + self.node_sum_before = [] # 总的节点数必须是列表类型 + self.node_layer = [] # 每层的按概率选择的节点列表必须是列表类型 + + def construct_multi_layer_hypergraph(self) -> Hypergraph: + r""" + Construct the multilayer hypergraph. + """ + + print("Multilayer hypergraph constructing...") + + prob = self.prob_inner_layer_connect + _node_layer = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + + for i in tqdm(range(self.num_layers)): + _node_layer.append( + MultilayerHypergraph.select_nodes( + range( + self.layers_list[i].num_v), + prob)) + self.node_sum_before.append(sum(layer_num_v[:i])) + self.node_layer.append( + MultilayerHypergraph.add_numbers_list( + _node_layer, self.node_sum_before[i])) + + temp = [ + self.node_layer[i][j] for i in range( + self.num_layers) for j in range( + self.num_layers) if i == j] + between_layer_hyperedges = list(itertools.product(*temp)) + inter_layer_hyperedges_list = self._inter_layer_connect() + between_layer_hyperedges += [ + edge for edges in inter_layer_hyperedges_list for edge in edges] + + print("Multilayer hypergraph constructed") + return MultilayerHypergraph( + self.num_v_multi(), + self.num_layers, + self.layers_list, + e_list=between_layer_hyperedges, + device=self.device) + + def num_v_multi(self) -> int: + r""" + the number of node in multi-hyper-network + """ + layer_num_v = [] + for i in range(self.num_layers): + layer_num_v.append(self.layers_list[i].num_v) + return sum(layer_num_v) + + def _inter_layer_connect(self) -> list: + r"""多层超图排序后的超边列表(无层间超边) + """ + layer_e_list = [layer.e[0] for layer in self.layers_list] + layer_num_v = [layer.num_v for layer in self.layers_list] + _layers_e_list = [] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _layers_e_list.append( + MultilayerHypergraph.add_numbers_list( + layer_e_list[i], self.node_sum_before[i])) + return _layers_e_list + + def load_interlayer_mapping(self, + path: Optional[Union[str, List[str]]], + save: bool = False, + save_path=None): + r"""读取多层超图层间节点的映射关系,用超边连起来各个层间的公共点,构成层间超边 + :param path: 映射关系文件路径, 可以是单个文件路径,也可以是文件路径列表,若有全部映射关系的文件的话,用这个 + 若无,则用文件路径列表,每个文件对应一层的映射关系 + return: 等待添加的层间超边 + example: + file_path = "../data/integrated/gene_merged_file.txt" + merge_gene_mapping = bio_mhg.load_interlayer_mapping(path=file_path) + bio_mhg.add_hyperedges(merge_gene_mapping) + """ + if isinstance(path, str): + gene_encoding = {} + with open(path, 'r') as file: + for line in file: + gene, codes = re.findall( + r'([^\[]+)\s+\[([^\]]+)\]', line)[0] + codes = [int(code) for code in codes.split(',')] + if len(codes) > 1: + gene_encoding[gene] = codes + + hyperedges_list = [] + for key in gene_encoding.keys(): + # 只有一个编码的不用加入 + if len(gene_encoding[key]) == 1: + continue + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + if save: + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + elif isinstance(path, list): + gene_info = {} + gene_encoding = {} + # 遍历文件列表 + for file in path: + with open(file, 'r') as f: + for line in f: + gene, code = line.strip().split('\t') + if gene not in gene_encoding: + gene_info[gene] = int(code) + gene_encoding[gene] = [int(code)] + else: + gene_encoding[gene].append(int(code)) + # 将合并后的基因列表存储为待添加的超边,长度为1的值可以去掉 + hyperedges_list = [] + for key in gene_encoding.keys(): + # 这会过滤掉那些多层超图里只出现过一次的基因 + if len(gene_encoding[key]) == 1: + continue + # 这会不过滤,保留所有基因 + value = tuple(gene_encoding[key]) + hyperedges_list.append(value) + # print(hyperedges_list) + if save: + # 将结果存储到新的txt文件 + with open(save_path, 'w') as f: + for gene, code in gene_encoding.items(): + f.write(f"{gene} {code}\n") + with open(save_path, 'w') as f: + for gene, code in gene_info.items(): + f.write(f"{gene} {code}\n") + return hyperedges_list + + def node_layer_list(self) -> List[List[int]]: + r"""返回多层超图的节点列表(有层次) + """ + _node_layer_list = [] + layer_num_v = [layer.num_v for layer in self.layers_list] + layer_v_list = [layer.v for layer in self.layers_list] + + for i in range(self.num_layers): + self.node_sum_before.append(sum(layer_num_v[:i])) + _node_layer_list.append( + [num + self.node_sum_before[i] for num in layer_v_list[i]]) + return _node_layer_list + + @staticmethod + def select_nodes(num_v: int, prob: float) -> list: + r"""依据概率从每层的节点组内选取固定节点数,作为层间相连超边的节点依据""" + res = [] + for i in range(len(num_v)): + if random.random() < prob: + res.append(num_v[i]) + return res + + @staticmethod + def add_numbers_list(lst: List[List[int]], num: int) -> list: + res = [] + for e in lst: + new = [i + num for i in e] + res.append(tuple(new)) + return res + + def __str__(self): + r"""Print the multilayer_biological_hypernetwork hypergraph information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) + + def __repr__(self): + r"""Print the multilayer_biological_hypernetwork hypergrpah information + """ + return 'MultilayerHypergraph(num_v={}, num_e={}, num_layers={}, layers_list={}, prob_inner_layer_connect={})'.format( + self.num_v, self.num_e, self.num_layers, self.layers_list, self.prob_inner_layer_connect) \ No newline at end of file diff --git a/examples/plot_multilayer_hg.ipynb b/examples/plot_multilayer_hg.ipynb new file mode 100644 index 0000000..a71d97c --- /dev/null +++ b/examples/plot_multilayer_hg.ipynb @@ -0,0 +1,453 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import sys, os\n", + "sys.path.append('..')\n", + "\n", + "from data import MultilayerHypergraph\n", + "from dhg.random import hypergraph_Gnm\n", + "import matplotlib.pyplot as plt\n", + "import dhg" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### 先画一个大型图" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "big_hg1 = hypergraph_Gnm(30, 30)\n", + "big_hg2 = hypergraph_Gnm(30, 30)\n", + "big_hg3 = hypergraph_Gnm(30, 30)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_1 = [str(i) for i in range(big_hg1.num_v)]\n", + "e_color_1 = ['r'] * 30 \n", + "v_color_1 = ['r'] * 30 # 节点和边的颜色数平分\n", + "big_hg1.draw(v_label=big_v_label_1, v_color=v_color_1, e_color=e_color_1)\n", + "plt.savefig('figs/big_hg_1.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_1.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_1.pdf', dpi=600)\n", + "plt.savefig('figs/big_hg_1.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_2 = [str(i) for i in range(big_hg2.num_v)]\n", + "e_color_2 = ['b'] * 30 \n", + "v_color_2 = ['b'] * 30 # 节点和边的颜色数平分\n", + "big_hg2.draw(v_label=big_v_label_2, v_color=v_color_2, e_color=e_color_2)\n", + "plt.savefig('figs/big_hg_2.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_2.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_2.pdf', dpi=600)\n", + "plt.savefig('figs/big_hg_2.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label_3 = [str(i) for i in range(big_hg3.num_v)]\n", + "e_color_3 = ['g'] * 30 \n", + "v_color_3 = ['g'] * 30 # 节点和边的颜色数平分\n", + "big_hg3.draw(v_label=big_v_label_3, v_color=v_color_3, e_color=e_color_3)\n", + "plt.savefig('figs/big_hg_3.svg', dpi=600)\n", + "plt.savefig('figs/big_hg_3.eps', dpi=600)\n", + "plt.savefig('figs/big_hg_3.png', dpi=600)\n", + "plt.savefig('figs/big_hg_3.png', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 3/3 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "big_v_label = [str(i) for i in range(big_mhg.num_v)]\n", + "e_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30\n", + "v_color = ['r'] * 30 + ['b'] * 30 + ['g'] * 30 # 节点和边的颜色数平分\n", + "big_mhg.draw(v_label=big_v_label, v_color=v_color, e_color=e_color)\n", + "plt.savefig('figs/large_hg.svg', dpi=600)\n", + "plt.savefig('figs/large_hg.eps', dpi=600)\n", + "plt.savefig('figs/large_hg.pdf', dpi=600)\n", + "plt.savefig('figs/large_hg.png', dpi=600)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "#### 可自定义层内连接及控制连边概率" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label = [str(i) for i in range(small_mhg.num_v)]\n", + "e_color = ['r'] * 3 + ['b'] * 3\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)\n", + "plt.savefig('figs/small_hg.svg', dpi=600)\n", + "plt.savefig('figs/small_hg.eps', dpi=600)\n", + "plt.savefig('figs/small_hg.pdf', dpi=600)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MultilayerHypergraph(num_v=10, num_e=8, num_layers=2, layers_list=[Hypergraph(num_v=5, num_e=3), Hypergraph(num_v=5, num_e=3)], prob_inner_layer_connect=0)\n" + ] + } + ], + "source": [ + "small_mhg.add_hyperedges([[4, 7], [2, 5]])\n", + "print(small_mhg)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAJOCAYAAABBWYj1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2QUlEQVR4nOzdd3hUVRMG8HdLQhJ670VA6TUUpUgxoYl+KqJgAwVFsSACFhAERRTsIoh0VARUBBGQjkqRFnpXSkKXEkggpOzufH9MEgIkYZPs7t3dvL/nybNm252N5GbunHPmmEREQERERES3ZDY6ACIiIiJfwcSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIiIiIicxMSJiIiIyElMnIgo20SAxES9JSLKDaxGB0BE3u/wYWD5cuDvv4EtW4DTp4GrV4H4eMDhAPLlA2rUAGrW1K977gEaNgRMJqMjJyJyLZMIrxWJ6GZJScCPPwKffAJs2wYUKgQ0bw6EhgIVKwLBwUBQkH6dPQvs3Qvs2wfs2gUcOQLUrg307Ak8/jhQqpTRn4aIyDWYOBHRdeLjga+/Bj7/HDh1ShOf554DmjQBLJZbv14E2L4dmDEDmDkTiI4G+vQBRowAihVzd/RERO7FxImIUu3dC3TvDhw9CrzwAvDyy0DZsjc8SQQ4dw6IjQViYrQ0Vbq0ft2QWSUmatXqrbeAOnWABx4AevcGzJxdSUQ+iokTEUEE+OYboH9/oGlT4LvvgPLl0zzh2DHgt9+A1auBP/7QxOlGwcE6PnfffVqmqlw59aG4OOCDD4DRo4FGjfRYdeq4/WMREbkcr/uIcjkR4PnngZdeAoYOBVauTJM07dunE5UqVwaGDdOZ4MOGAWvX6mSmyEjgxAlg82Zg8mSdBPXNN0CVKkCzZsDixQCAkBDgvfeAHTuAgACgQQPg9deBK1cM+9hERNnCihNRLiaiCcyXXwILFgDt2yc/EBOj5adp07Q0NHgw8PDDzk1ycjiAv/4CJk4EZs3SCtTnn6dWoER0/tPAgboa76uvgM6d3fYRiYhciokTUS42apRWmX76CXjooeQ7N23ScbVNm4Bx44D//e+6vgKxsbHYtm0b9u/fj6tXryIgIAAVK1ZEaGgoSt24fG7dOi1l7d8P/PAD8OCDqQ+dOwe88QYwdare/eWXQLlyHvjQREQ5wMSJKJf65RegSxctKvXsCS0FffaZZjOdOgFTpqQug4uLi8Ps2bMx4auvsGX7dogIzADymM1IEoEt+TRyW/nyeOa559C7d+9rSZTdDrz5JvDpp5qIPf/8dXH89ZdORI+K0uG8l14CrOwwR0ReiokTUS507pw2qnz0UWDsWADnz2v2tHQp8NFHwCuvACYTRAQzZ87Eqy+/jAsXL6KT2YwuDgcaAagB7aArACIBbAGwFMAPZjOSzGYMHDQI77zzDvLkyaMH/fRTYMAAbQz12mvXxZOYqHe/+6420pwwQdsfEBF5GyZORLnQs88CK1YAu3cDebev0x4EViswZw7QuDEA4NKlS+jx5JP49bff0N1kwvsiuM2J974I4AsA75tMuOOOO/DjL7+gZs2a+uC4cZqULVkChIff9NrDh7XitGQJ0Lcv8P77QMGCrvrUREQ5x8SJKJfZuROoXx/4aY4DXQ6NAd5+WycZTZ6cmqVcuHABYa1b48jevZhmt+OB7BwHwGMWC07ly4cVq1ejQYMGOhzYqxfw+++6Ki+djpgiwM8/A/366X9//jnwyCPcvoWIvAMTJ6Jcpk8fYMuGJGwpfT9Mf6zWeU3PP5+amSQlJaF1y5Y4sGULVtntqJuDY0UDaGexILJAAWzZvh0VKlTQxpn16gEdOgDjx2f42pgYzem++gpo106LVVWq5CAYIiIXYB8nolzk6lVg9kwbnol8B6bDh4ANG3RmdppyzujRo7Fx0yb8lsOkCQAKA1hityNPbCye7dULIgLkz6+9oKZO1d2CM1CggK6027RJ98KrXVuH7hISchgUEVEOMHEiyi3sdsx/6hfEX7Gj2z3ngIgIHbNLY9++fXh3xAi8IYK7XHTYogAm2WxYtmIFpk+frnc+9hhQooRWu26hUSNNnkaP1q/69YE//3RRcEREWcTEiSg3OH0aaN8eM38Jwn0NT6Loz99o5ecGn37yCUoCGObiw3cA0AXAhyNHatUpMBB49VWdV+Vw3PL1FovOKd+3D6hVC2jdWhcBprfzCxGROzFxIvJ3K1dqmebECUQUCUfbXrelO9P64sWLmPn99+hjsyGPG8J4BcDBw4exatUqvePee4ELF3S2upPKltWJ4wsXatWpWjUd8XMi9yIicgkmTkT+ym7XuUTh4UD79ohethmnzwWgRo30n75kyRJcTUjAM24KpyWAqlYr5s6dq3fccQdQurRuHJxF994L7NmjbRX69NEK1J49Lg2XiChdTJyI/NHJk8A992hXyWnTgBkzsO9YPgDa+DI9W7ZsQaWAAJRxU0gmAHfZbIjYuDH5DhPQsiXw99/Zer+QEODDD4Ft27TiVL++bqkXF+eykImIbsLEicjfLFmiy/3Pnwc2bwZ69AAAHDigbZpKlEj/ZdsjItAwKcmtoTUEsGPXLtjtdr2jZEkgOjpH71m7tm7b8vXX2nG8dm1tE0VE5A5MnIj8RVIS8NZbQMeOwAMPABs3XldeSpmTnVEjyQvnzqGkm0MsCSAhKQlXr17VO/Ln14ZNOWQ2A717a3LYsqVutffII1p4IyJyJSZORP7g2DGd6PPVV8DMmcCkSTqWlUZQkPZx8ir58gGXL7vs7YoXB2bMAFat0jnn1avrXnwpBS4iopxi4kTk6xYu1Ak+V65ob6bHHkv3acHBQHx8xm9TpFgxnHFPhKnOAMgTEIDg4GC9IzoaKFTI5cdp0wbYsQMYNEi/7rwT2LrV5YcholyIiRORr0pMBAYMAO67D3j0Ue0CfscdGT49OBiw2TJOnuqHhmJrQICbglVbAdSrUwcWi0XvOHIEqFDBLcfKkwcYOlQ3Mi5cWPcu7tfPJSODRJSLMXEi8kVHj+pknsmTgTlzdM+3oKBMX1Ktmt5mtGy/UaNGOJqUBHdNCxIAf1utCG3a9NqdO3cCdeq46YiqalVg6VIdwZwzB6hRA5g7V+d8ERFlFRMnIl8zbx7QoIFO3Nm6VWdBO6FSJaBIEd2+JD0dOnRAcJ48mOq6SK+zBsC/Nhu6dOmid/zzD3DwINCihZuOeI3JBHTrBuzfD/zvf0DXrkDnzpp/EhFlBRMnIl+RkKD7jjz0kLYYWLcOqFLF6ZebTECrVjpxOj2FChXC4088gW+sVrhjH90vTSZUq1IFbdu21TtmzgTKl/dI4pSiUCEtzv39N3DihC46HD1aFyQSETmDiRORLzh0CGjeHPjuO604ff65TuLJonbtgOXLM24S+dqAATgD4N0cBXuzJQDmiuCNIUNgMpm0Y+XMmTqR3ez501DTpsCWLcDIkcB772kBb+1aj4dBRD6IiRORt/vxR/3LbrVqm+wHHsj2Wz36qE4Qnz49/cdr1KiBYe+8g9EmE7LXz/tm5wE8a7WiXVgYevbsqXfOmKHjZL16uegoWWe1Aq+9BuzdC9x+u04Z691b+4YSEWXEJMIpkkRe6epV/cs+YQIwcCAwahTgglVv/fsDv/2mzSJTFrellZSUhNYtW+LAli1YZbejbg6OFQ2gncWCyAIFsGX7dlSoUEFbEFSrBvTsCYwZk4N3d60FC4CXXtIf+yefAE8+mXGzUCLKvVhxIvJGBw5o86Eff9Q+TR995JKkCQBefVWLPfPmpf94QEAAflu8GBVq1kQriwUZPO2WdgJoabHgcL58WLpypSZNIpoEBgRorwAvcv/9Wn3q2RN45hmgbVudTE5ElBYTJyJvM3MmEBqq25Fs3w7ce69L375iReCJJzR/uXgx/ecUKVIEq9esQatOnfAQgMdMJhx28v0vAhgBoJHJBFStijXr16NBgwb64Pvv6zDd1Kn6+bxMvnyao0ZEaL+runWBYcO8sOM6ERmGiRORt4iL00k2Tzyhq+f++ENXnbnBZ5/p/Oznn8+4n1HBggUx79df8f3332NZwYKoCuBesxnToNUkW/LzBMARAD8B6A2gjNmM961WDHrrLUTs2IGaKfvlTZyoVaYpU4D27d3yuVylXj1dtDh2rH7VqaOT6omIOMeJyBvs3av9mP77T1fOeSCx+Osv3d5u2jTtbpCZuLg4zJkzBxO++gqbt22DiMAEIMhsRqII7MmnkdvKl0evPn3Qq1cvlCpVSl9sswHDh2u1acwY3QPFh5w5o1PNfvgB6N4d+PRTIOWjEVHuw8SJyGjTpwN9++oa+ZkzgTJlPHbooUOBjz/WTtqdOjn3mtjYWGzfvh379u3D1atXERAQgEqVKiE0NBQlS5a8/sknTlzbO69vX13W56NWrABeeAE4exb44AOgTx9DOikQkcGYOBEZ5fJl4MUXtcI0dKhOpklvmZsbORw6KvjNN8D337s4r1myRJemlS6tk9yrV3fhmxsjPh748ENNnBo00AWP9esbHRUReRKvl4iMsHOn7jq7bJmWMkaM8HjSBGjFZOxY4I03dBhq/HgX7OGWlAS8+SbQsaN2Od+40S+SJkC3Axw+XP/35c0LNGqk+yxfvmx0ZETkKUyciDxJRCdJN20KlCunq+ZStiAxiMmkHbQ//hh4+WVdln/8eDbfLCpKJ06NGwfMmqWlrOBgV4brFapV03x3+nQtGNaoAcyfb3RUROQJTJyIPCUmRuf7vPAC8PbbOpR145wgA732mu7hZjLpHm5ffqn7CDttwQIdt4qL082Hu3VzV6hewWTSBZD792tx7cEHdQPhqCijIyMid+IcJyJP2LZNV83FxWkl5u67jY4oQwkJ2sto5Eigdm2dx9OoUcbP//D99/HW22+nfi9Xr+qYVi6zfr1OGD98WEde+/VzWc9SIo9xOIDNm7UYvmuXLvhNSAACA/WrVCm9PmrZUuf5GTDDwHBMnIjcSUQnDr32GnDPPdr8sXhxo6Nyyr//6tz1FSv0duRIoECB659zYOVK1A8PR3ya00huPqUkJWmPrOHDdf+7b77RBvBE3u7ECR16njpVk/9ixbR/Wa1aOp8vMVETqOPHdYPskyc1iXrpJb1gKFbM6E/gQUJE7hEdLdKli4jFIjJ6tIjdbnREWeZwiMyeLVKqlEjp0iI//qj3iYjYf/pJmlksAkDuatBAoL0wjQ3YSxw5ItK5s4jJJNKnj8iFC0ZHRJS+S5dE+vcXsVr1d/zNN0UOHMj8NQ6HyMGDIsOHi5QoIRIUJNKvn8jlyx4J2XCsOBG5w+bNurbfZgNmzwaaNTM6ohy5eBEYMgT4+mugQzs7xpV8Dwu+HYFXATzevTuq3nEHRowYASB3V5zSEtH9AF95RStRn36qU9y4cTB5g5R/n/366TZMzz2n/z6t1pufa0+e7GhJZ1wuPl7bzw0eDBQsqP/duLG7ozcWJ4cTuZII8PnnQPPmWufevt3nkyYAKFRIF8pt+OkYTv31D2p8+whetwajaNGi+OyLL4wOzyuZTNqNYd8+/YP01FNAu3bAP/8YHRnldseP62KGLl2A++4DFi3Sf59Wq174rF+/HgMGDECLFq2QN28BWK1WWK1W5M1bAC1atMKAAQOwfv16iAiCgoBevXQ+VPXqerqbNMnoT+hmBla7iPzL+fMi998vEhAg8umn18a0/MXs2SL580tS0+Zye6W7BYCULTtD1qwReeeddzhUdwsRESKNGonkyaNDHPHxRkdEuY3NJvLVVyL584vUrCmydu21xxwOh8yaNUtq1aonAMRqLSdAVwE+EGBq8tcHAnRNfgxSq1Y9mTVrljiSz3UOh8iHH+oQ9YwZBn1ID+BZjsgV1q8XqVBBpFIlkY0bjY7GteLidKIOIPL66zLx668FgLRoESYPPqh3N2jAxMkZKX+4ChQQueMOkZUrjY6IcoudO0XuvFMkMFDkvfdEEhKuPXby5Enp3Pl+ASAm070CLBXALlpCT+/LLsDS5OdCOne+X06ePJn6fu+9J2I2i8yda8AH9QCe5Yhywm7Xid8Wi8hDD+mEcH+yf79I3boiRYuKLFokx48fl4IFC0pwcLAcOnRIREQWLBApUOBa4uRvhTZ3OHFC5NFH9Y/QE0+InDljdETkr65eFRkyRCd/3323/kqntWvXLilevLRYrSUFmJdJspTR1zyxWktK8eKlZdeuXSKilaf+/UXy5dOFEv6GiRNRdp09K9Kxo17CffWV/w3NffedSN68Ii1aiBw7JiIi996rV5ijR4++7qlvvXUtcWrVSmTvXgPi9UG//y5SubJI4cIiEyf65MJL8mKrVoncfrtIoUIikyff/O/rwIEDUqRIcbFY6glwOhtJU8rXabFY6kmRIiXkQPKSvIQEkQYNRNq1879TIyeHE2XHmjXaBe7gQW23/eKL/rNc6soV4JlndLboq68Cq1cD5crh+++/x6JFi1C/fn289tpr170kMPDafycmAvXqaXP0q1c9G7qv6dAB2L0b6NtX/wm1bKmTbIly4vx5/RVu2xZo2FAXKPTqpXtTpkhMTMRDDz2CS5eKwG5fASAnuxiUhN2+AjExhdGly6NISkpCYKD2MVu+HFi4MKefyLswcSLKCocDeP993Y+tRQvdWqRhQ6Ojcp09e4AmTXSZzdKl2vXSasWZM2fw6quvwmKxYNKkSbCmt2Y52dq1wFdf6Sq8OnV0H2PKWHCw/pi3b9dVTQ0b6qbLV64YHRn5GhHdmKBGDWDlSk1YZs/WRpU3GjVqFPbu3Q27/QcAruheWQw220zs2bMLo0aNAqBtCbp00e2b/IrRJS8in3H6tEh4uHZ7++Yb/6o/OxwiU6eKBAeLtGkjkmaip4hIz549BYC88MILEhsbe9PXW2+9lTpUl3JfVFSCPPGElvIfffSmt6R0OBwi06bplLKKFUV++83oiMhXHDki0qGDTsru318kNjbj5545c0as1kABhuRgeC6jr8FitQbKf//9JyIiS5bo/f4014mJE5EzVq7U9tnVqons2GF0NK4VG6szlE0mXSdvs930lFatWqUmRs5+9evXT0REVqzQeRYFCoiMG5fu29MNzp4VeeYZ/YPz0EOpU8yIbpKUJPLxxyIhISL164ts3nzr13zwwQdiNgcJcN4NidM5MZuD5MMPPxQR/X0vX17knXfc+3PwJA7VEWXGbteNx8LCgPBw3aSpbl2jo3KdnTuB0FDdkG7lSuCdd1y+a+c99+hh+vfXr2bNdM9jylixYsCUKcCff+r8lBo1tK+qzWZ0ZORNtm4FmjYFhg7V09SmTZlvyJ1iwoTJcDi6ASjihqiKwuF4FBMmTAagp5P77wf++ssNhzKK0Zkbkdc6cUKkdWsdvpo61f+G5iZM0G6M4eE5Xg/vbAPMAwdE2ra9NpwQE5Ojw+YKCQkio0bpCHGDBiKbNhkdERnt8mWRAQP09yg8XCS5M4hTzpw5k/y7+qMbqk0pX3MEQOpw3YQJIsWLu+mHYQBWnIjSs2yZrpo7e1arTE8/7T+r5mJigO7ddSnXsGHAkiVAiRIeOfQdd2hxa8YM4PvvgZo1db8sbm+XscBA4K23dN5+yZJaYXjpJeDSJaMjIyMsWQLUqqW/Q99+q2s4Kld2/vURERHJ/xXqlvjSvnfKsWrX1lPpmTNuPKQHMXEiSstm091sO3TQTZw2bdK/7v4iZRXg2rXAH3/ozpxmz54GTCbgiSeAAweAe+/V/dz+9z8gMtKjYficypWBxYuBOXOAX37RfcHmzGHSmVv89x/w+ONAx466qHffPv0+q9dzR44cgclkBXCbO8JMVhkmkwVHjhwBAJQvr/eeOuXGQ3oQEyeiFMePA23aAF98oZdyU6YAISFGR+UaItoj4K67gGrVdO17y5aGhlS4MDBhArB+PXD0qOanH30EJCUZGpZXM5mArl31j+bDD2vhsGNH4NAhoyMjdxEBpk3TRHnjRq3YTp+u8+CyIykpCSZTIAB3VtBNMJkCkZiYCODa3Ly0/d58GRMnIkAv5evX12GsiAgtifiLixf1r2z//tow6Lffsn/WzcDw4cMhuko3y6+96y79kY8YoRNcQ0O1pyhlrGBBYOxYLYiePatDIe+/r81HyX/8848urnj2WaBPH22Oes89OXvPoKAgOBzxAOwuiTF9NjgcCQgODgZw7d8lEycif5CUBLz+uo4Zde0KbNigFRl/sWkT0KCBztP66y9g0CCPD805IyAAGDgQ2LsXqFRJV9716QNERxsdmXdr1EirEB9+qF/16+tKPPJtiYnAqFHaQPbKFR1h/+ADbZaaU9WqVQPgALA/52+Wof0AHMnHujYfz18K+N53BiXylMhI4O67dbxo9mzg669dc2byBiLAp58CzZtr+4Rt27S04+UqVgR+/VUnjC9erMMTM2dyHk9mrFagXz9g/34d7mzdWtcynDtndGSUHRs2aNV11ChgzBgdynZlB5QGDRok/9cW173pTSKuO9bOnTo0X7q0Gw/pQUycKHeaP18vzxMT9XLu0UeNjsh1LlzQ2dZvvgl8/LF+1iLu6NfiHiYT8MADWn16/HHdMi88XLcFpIyVLQv8/LNus7F6tRZOp05l0ukrYmJ0tWSzZlp13bsXeOUVl7dVQ8GCBVG3bkOYTL+49o3TMJnmom7dhihQoAAAYN063cnJXxYmM3Gi3CUxUTeuffBB4Mkn9XKualWjo3Kd9es1Idy9W89W/fr57Nkqf34tmm3ZAsTG6rDF8OFAfLzRkXm3e+/V1gUp82JatdI/wuS9fv1Vq4U//6wrJRcsACpUcN/xXnyxD4CFAKLc8O6RABbhpZeeB6CzIZYty/ncLK9idCMpIo85dEikUSORggVF5s41OhrXsttFPvxQxGIRefhhkYsXjY7IpWw23a6lQAHdvmXFCqMj8g07d4o0by4SECAyeLDIlStGR0RpnTihW+oAIs89J3LhgmeOGxsbK/nzFxKgpxuaX/aQ/PkLyeXLl0VEZNYs/fd34oRnPpsnsOJEucPPP+skabNZ5/s89JDREbnO2bNA587azPLLL4Eff9RlV37EYtF+nfv36/yPsDBd+OgvDfXcpU4dXRMwfrxO4atdWxsokrEcDv3/UaOGVgP/+gv45hudB+QJ+fLlw+effwJgOoBFLnznRQBm4IsvPkXevHlTp1p26waUKePCwxjN6MyNyK2uXhXp21cvhQYM0P0r/Mmff4qUKSNStarI1q1GR+MxS5aIVK4sUqiQyDffaMGNMvfffyJPPaW/Co884l8VAF+ye7dIs2ZahXnnHZH4eGPicDgc0r59R7FYigqw1wWVpr1isRSV9u07iiN5e6oFC/Qxfzs1MXEi/3XwoG4XXqSI/gb7E5tN5L33dLOq7t1z5aZvcXEib7+tf4Duuktkxw6jI/INq1aJVKumw55jx+o/JXK/q1dFhg7Vf68tWojs3Wt0RCLnz5+X6tVri9VaUoCIHCRNEWKxlJDq1WvL+fPnRUS3vyxRQqRPH4M/pBswcSL/9MMPIvny6aVdZKTR0bjW6dMiYWG66+vEif61+XA27N0r0qqVTu8aNEg3QKXMxceLvPuu7vHcqJFIRITREfm3P/7QZLVgQe+rkP73339Sr16omEwBArwrQGIWEqZEAd4VkylA6tULTd3U124X6dxZ5yP64+8jEyfyL3FxIr1762/1m2+KJCYaHZFrrVghUrKkSPXqOvOXRERzx+nTRYoWFalQwf8KjO5y8KDm4GazSL9+IpcuGR2Rf7lw4drp6OGHRU6eNDqi9MXHx8vgwYPFbLaI1VpZgI8EOJdJwnROgI/Eaq0sZrNFhgwZIvHJY45JSTokHBQksmmTwR/MTZg4kf/Yu1ekdm2RYsVEfv/d6Ghcy2YTGTZMxGTSs1JsrNEReaVz50R69dKT+4MPikRFGR2R93M4tEBbsqROl/v551xfxMwxh0Nk9mz9mZYrJ/Lrr0ZH5Jxt27bJ448/IVZroAAmCQioLsBjAvRP/nos+T6TWK2B8vjjT8i2bdtSX5+QINK1qxb7V6827GO4nUmE7dHID8yYocuuGjUCfvhBuwH6i5MngcceAzZvBsaNA3r2NDoir7dmDfD880BUFPDuu8DLL2uHbcrYxYvA4MHaSL9jR/2nVqmS0VH5nqgoPRUtXqz/7kaO1J5kvuTs2bNYuHAhIiIisHnzNpw7dwEAUKxYETRu3AChoaHo3LkzihcvnvqaPXv01PTvv8DvvwN33mlQ8B7AxIl825UrwIsvAt9+C7z9ti7J96e/kEuXaqPOEiW0zUDNmkZH5DMSE3Up9Lvvahftb77R7sWUuQ0bNOk8eBB45x3gtdd0L0HKnN0OfPUVMGQIULkyMGkS0LSp0VG5X0KC7pM4bZr+nn39tX5+f8Y+TuS7du/WCtOSJdqa9t13/SdpstmAt94COnTQ7VM2bWLSlEWBgbrrzJ49ukfWnXdqjp2y4Sil7847tVv7e+/pV4MG2oSeMrZ9u/7c3nxTr98iInJH0rR2rf77+PRT4I03tNLk70kTwMSJfJEIMHky0LixDslt364dEf3FsWO6U+tXX+kOt5Mm+c+24ga47TZg0SIt2M2frxsHz57NPdwyY7UCAwZoc8aqVYEWLXQLlwsXjI7Mu8TFacLQqJH2nN21S5Mnf6/QXbyoVcmWLa818XzhBe0vnBvkko9JfiM2VltG9+mjEzKWLgVKlTI6KtdZtEj3mrt8WS9bH3vM6Ij8gskEPPwwsG8f0LWrbh7coYPOx6CMVaigyeb8+fqrVq2ajooz6QSWL9fO7JMnA1Om6Pf+tO1lekR0E4YaNXQz6XnzgLlz/WtKqTOYOJHv2L5d99v44w9g1Spg6FDXbx1ulMREYOBA3Trl0Ud1oskddxgdld8pUEB3pdm4ETh/XrcgGTlS52lQxv73P60q9OgBPPOMbth64IDRURnj7FngqaeAdu2AZs10G6AePXx2L+1MrV+/Ho899hgqVKiAPHnyICioGLp2vRvVq0/C7t0OPPCA0REaxNhFfUROcDhExo/Xbn0dOujeEf7kyBGRpk21lfOcOUZHk2vYbCJffCGSP7+2xfLn5dOutH27/nMNDNRO2FevGh2RZzgcIjNmaK+w224TWbrU6Ijc6+233xYAab4KJTfJ1O/vvvvu1I18cxsmTuTdLl7UxiAWi8iHH3pXy11XmDdPN1wLDRX591+jo8mVjh/X5oSASI8e/peXu4PdLvL119oJu2pVkWXLjI7Ivf79VxuF5pbu9JMmTUpNkIoU6SaBgcdk5EiRmJh4mT59uuTNm1cASNeuXY0O1RBMnMh7bd6sO7mWKyeydq3R0bhWfLzIK6/oX+tXXjFup09KtWiRSKVKurXh5Mn+l6O7w+nTIo89pv+Mu3cXOXXK6IhcKzFRr9eCgvTaxt82q02PzWaTkiVLJSdODaVVK7scOHD9c77++uvUxGqtv52bncDEibyPw6FjKAEBuuHRuXNGR+Ra//6rZ+FChbTiRF7jyhXdqcdq1Y1Yd+82OiLfsHy5Vp4KFtRKlD8knRs3itStK5I3r8hnn+lWIrnB2LEbUpOiZ5+dmW4XeZvNJoUKFRIA0qtXL88HaTBODifvEh0NPPSQroX+8ENgwQKgaFGjo3Kdn34CGjbU9d7btiH3zq70TiEhwAcf6P8aEV3g+NZbuuycMhYWpkvx+/XTr2bNgB07jI4qe2JjgVdf1b5MZctqH7BXX/WfFnEZOX9eO3+//HJk6n19+9ZMd9K7xWLBHcmLV5YsWeKhCL0HEyfyHhs2aDe1bdu0s9prr/nPUpX4eN2H4ZFHtCHOX39xPwsvVru2/i+aMAGYOFG///13o6PybkFBwIgRwM6dmoCGhupC0cuXjY7MeQsXArVqAbNm6deiRUDFikZH5V4i2i6uenVdsPzmm9ces9vtGb4u5bETJ04gOjrazVF6FyZOZDyHA/j4Y+2m1rChJk7+1Hb34EG9fJ0zB/jtN/2sgYFGR0W3YDYDvXrpcvO77wY6ddIeUCdPGh2Zd6tWDVi5Urfg+PZb7fkzf77RUWXu1Cm9prnvPqB9e+339eij/nPdlpHDh7Wf2VNP6dfu3cCDD1ZKfXz37t3pvi4xMRH//PNP6vcnc9kvBRMnMtb588D99+sGT599pt3UChc2OirXmTlTk8F8+bQPVefORkdEWVS8ODB9OrB6tQ5HVa8OjB2re5NR+kwm3WJx/37dMPjBB7UXVFSU0ZFdz+HQxvw1aujQ4urV+n2RIkZH5l42G/DRR1pJPXtWd3T65BM9TTVs2BAlS5YEAIwePRo2m+2m148dOxYxMTGp36f971zB6ElWlIutWaMr5qpUEdmyxehoXOvKFZFevXS50Vtv6fIc8nnx8SLvvactxUJD/e+frbusXStSu7ZISIjIRx95x6/Dvn0iLVvqGpTc1I9q82aR+vVFgoP1/0V6k97HjRuXOkG8ffv2EhERIQkJCXLq1CkZM2aMBAQESEDAtZ5OGzZs8PwHMRATJ/I8u11k1ChtivLII9qryZ/s2SNSq5ZI8eIiS5YYHQ25wT//iLRrJ2I2azeJS5eMjsj7JSaKjB6tf7Dr1hX5+29j4oiPFxk+XBt43nVX7lk5GRsr0r+//ptt317k8OHMnz9w4MAbGmBe+7r99ttlyJAhqd8fuLFfgZ/jUB151n//ae1+xAhg3DjdbbVgQaOjcp3p03Xz4WLFdGiufXujIyI3qFoVWLJER2LnzNGhnp9/5h5umQkIAF5/XbduKV9eV9698IIupPWUtWt1/cknnwCff67f16rlueMbZfFiHZb7/nvgu+90ocNtt2X+mo8++ghr165Fz549UatWLZQvXx5NmjTByJEjsW3bNliSt7vKkycPKuW2hS5GZ26Ui6xeLVK6tMgdd+i+Df4kNlbkqadETCaRYcNyT9MXkuhokb599X99p063vpInbdU2d65I2bIiJUqIzJwp6fYLcpXoaJE+fXTk/MEHtVt8bnD6tEi3bvq5e/Z0bUu8Tp06CQBp3ry5697UR7DiRO5ntwPvvqs7g7ZtC2zZAtSrZ3RUrrNrl1aZli7VLdJHjPD/pi+UqlAhLZ7+/beuuKtVS1uQJSYaHZn3Mpm0Xdu+fUD37jqRvF07IM1CLZcQ0UpgjRq6oPWXX/SrbFnXHsfbiABTp+rn3rLl2ipHV7XEO3PmDFasWAEA6NGjh2ve1JcYnbmRnztxQqR1a53YMGWKey8rPc3hEJk4UfdjuOce/9tvgrIsKUnk00+123StWrr+gW4tIkKkUSOddD9ihGt2IIqKErn/fq0E9u3rf1MpM3LggJ5yrVaRwYNF4uJc+/42m00eeOABASBVqlSROFcfwAcwcSLXSEwUWb9eJ3136KDbzRcsqDViQLegv+MOkbvvFnn1VZFffvHtGbWXLmkN3GzWZVY2m9ERkReJihJ54AH9p9+rl//tGuQONpvIV1+JFCigp4pVq7L/Pl9+KZIvnyav69a5Nk5vlZBwbcVn06YiO3Zk/70OHTokgwcPli1btsjV5OWGdrtd1q5dK23bthUAEhQUJOtyyw/3BkycKGd27NDJA/nz61+JSpVEnnxSpE0b/b5tW92PbcYMkTFjdAnSXXfp5VBAgP518bVNIrdu1Y25ypQR+eMPo6MhL/brryIVKogUKyYyfbp/FVzd5cQJkUcf1dPHk0+KnDnj/Gt37BBp0kSTh5EjNZnIDdav1yQxXz6RsWNzfh23bdu261bRFS5c+Lr2AyVLlpRV2c1s/QATJ8qePXtEOnbUs1u9eiLjx4tERuqsy5Ytdazi228zfv3FiyJz5mhNGdBk6vffPRZ+tjgcIuPG6TrmDh1E/vvP6IjIB8TGigwcqN03WrXS/kF0a7//LlK5skjhwjointnGwXFx2i7NatVTSm5ZHX/x4rWFCfffr5VOV4iOjpZhw4ZJq1atpEyZMhIYGChFihSRO++8U0aNGiUXc8u4ZwZMIlxAS1mQlASMGaOTvRs1At57D2jTRmd7/v679u0vXRr48UdtseyMLVv0PX/6CejRQ9cJFyrkzk+RdZcuAb17A/PmAe+/DwwapHtyEDlp506gTx8gIgJ44w1g8GAgONjoqLzQwYO60OLoUdgij+PExhOQ48dRxBqDoBIFEFisoM7urlgRCA3F2vwd0XNIWVy4oLsZPf20/2+VAug2Ni++qHMhxo7Vyfa54XN7AyZO5LyoKOCBB/TENnq0NmExmzWZevttTX6ee04Tn+z8RVi6VDcHM5m0Qc7dd7v6E2TP5s26cZXNpn2nmjUzOiLyUSlbfLz5pq5wGj9eV5Plag6HbvD966/AggW6T0uJErrpXblyQNmyOG0pi+nzCuL0v5fRqdlFtLn9OOToUdjX/o3gpFhEFqqLYk92Qt7u9+u+kH6cQZw4Abz8sl7DPf888MEH3ned6feMLXiRz9i3T7dHadhQ5MiRa/dHRuowW758IrNm5fw40dE66TooSGTRopy/X044HCKffaZzse67jzN8yWVOnxZ5/HEdpe7WLZcuyHQ4RBYuFKlTR38QtWrpMrANG9Idl3M4RKZOFSlaVOeMFSggUrVCgmz4cLXIoEG6pwugC1D+/NPzn8fN7HadKZA/v0iNGlyxaSQmTnRrERF6pmrd+vqVcL/+qhMQGjQQOXjQdcez20VefFETlp9+ct37ZsX58yL/+59Omvj0U87qJbdYsULk9tt1Aeq4cblocebatSItWmii07270xO/Dh++tu4E0Hk9x46lecLmzdqFFNAWIX6y6mv3br0+DQx0XbsGyj4mTpS506e12/e9917bBTMpSa8MS5cWeemlm3bHdDgccvjwYfn555/l66+/lvHjx8vMmTNl165dYnP2L4PDIfL66zqjdvVq136mW/n7b10KVamSyMaNnj025TpXr4q8847+UWzSRGTbNqMjcqOYGJEnntDEpkMHpz9sUpJuSBscrNdpW7ZoUalGDS12f/bZDc36//5bNxME9Dzio538r14VefttvYZs2ZILC7wFEyfKWFKSXt5Vr64nPBHt13T//brN+c8/X/f03bt3y4svvihFCxZMXbZqBsRiMqV+HxIUJF0fflhWr14tjltVcRwOPckWLy5y8qSbPmQadru2TLBaRR56SIcNiTzkwAHt3mE262assbFGR+Rie/eKVKumF1zLljn9si1bNFkKDtbkKW0OlJAg8v77OrLfoIHIpk03vHjOHF3h26ZN1voaeIHVq7UaWaiQyKRJma8qJM9i4kQZGzpUTzp79uj3DofI00/rIPuWLalPO3XqlDyU3Em2pNUqbwCyEJBTgDiSa+oXAVkNyIeA1LBaBYCE1qsn22+1Z92VK3pZ2b69e4fLzp7VEn9goDZC4dAcGcDhEPnuO71WKFdOW6D5hZUrdTyydWutYjshNlbktdc0kWzfPvM9AP/9V59jMuko/3Wr5ffs0YStbFmtRHm58+e1aSog8sgjuXT+m5dj4kTp++cfrQ9PnHjtviFDNLFYuTL1rnnz5kmRggWlhNUq3wKSkDL5IJMvByArAalttUqA1SqjRo3KvPoUEaFnxPnz3fNZ//pLT6pVqlyXEBIZ5cIFkeeeuzaP5+hRoyPKgSVL9FzSo4fTHSkXLxapWFETSGc3AHY4tMBUqpSO0i1cmObBS5d0d9+8eb02eXI4dH1NiRIi5cuLLFhgdESUESZOlL5nnxV5+OFrs1X//FPP4jNnpj5l6tSpYjKZ5CGTSc46kTDd+BUPyODkIbwX+/bNPHl67DGRunVdW6+227XOb7Foq2Jf3gKG/NK6dbroLCREh6kSE42OKIv27tVKU+/eTmU/p0/rKkNApGfP7C1kvXBBDwfo7k6ppwybTaRLF13QklJF9xJHjmg/YZNJpF+/azMjyDsxcaKbbd6sZ52lS/X7pCQdLuvSJfUpCxYsEJPJJH0AsWcjaUr7NSk5eRo+fHjGMR04oDX7H390zWc8fVokPFz3ZpgwgUNz5LUSE3XqXUiIJlHr1xsdkZPOndMqbuvWt6w0ORy6B3jhwrqbUZqidrbNn69zn556Ks28qPh4jadKFR0TM1jKptAhIXpdyLUovoGJE90sLEwnU6YkExMnaoIRGSkiImfPnpXihQtLZ5Mpx0lTytcIQMwmk2zYsCHjuB5/XPesyKlVq7Sef8cdIreaY0XkJY4eFencWX9lnntOKyteKzFRzyFVqtyybHTokI7iWa26WDcuznVh/PGHTsl84IE0i3/PnRO57TYt8Rh4wbR1q0hoqCZ3H37og9XEXIyJE11v+XI9M6dNYEJDRZ5/PvXbx7t3lyIWi5xyUdIkgCQB0shikRq33y6JGZ1BFizQqlN294iz2USGD9f3eOIJP1y2RP7O4RD55RedkleihMj333tpsfSLL7SMsndvpk+bO1enHYWH6wa9aTkcDomMjJRffvlFPv74Y3n//fflk08+kQULFsiJEyecDmXzZm2a2aNHmju3bNFxsblznf9MLnL58rW9C8PCdGI7+RYmTnSNwyHSqJFOokyxf78mN8mN5I4cOSImk0m+dmHSlPIVkTxk9/MNbQ5SXb2qZ9mpU7P+2U6e1Cvg4GAdE/DKvzZEzomJ0ZYFZrP2efSqTW2jozVTGTYs06fNmKHxv/ba9dWWkydPyogRI6RMmQqpbUwslnxitRYTszkk9b5KlarK6NGj5ezZs7cMadkyPc1ct7lB795aebqhD507LVmihyxaVPdA52nINzFxomt+/lnPZGknTg4bpr/pyb/hb775phS0WOSyGxInAaS5xSJtMxuOe/BBka5ds/a5li3Ty/OaNbUFL5Gf2LpVpHFjXew6fLhHc4CMvfGGSMmSmVZ0J03Sgs+7715LHhISEmTYsGFitQYkJ0jPCvCrAMcFcCSfIhwCHBVgrgBPidmcRwIDg+Sjjz66ZXPdgQN1nnrqjlGnT+s43gcfuORjZ+bMmWtb7Dz5ZPaL5uQdmDiRSkrSXidPP339/a1ba3fwZFUrVpQ+bkqaBJCpyVeT5zOauPnOOyL16jn/mYYM0TP0009rjZzIz9hsul1LgQI6bc8VE6uz7ejRawsuMhARod0J3n//2n0HDx6UmjXrislkFWCYABedPGWcFaC/ACZp0uQuOXbd/ivXS0jQrTbDwtLc+dFHWsV2U3NMh0Nk2jSRIkVEKlfOUt9P8mJMnEhNnqyXrckTwFMVKybyzTciIhIdHS0A5Fs3Jk77kxOn5cuXpx/nd9/pie5WNe5jx3SPgrx5tSZO5OdOntSuGoBO4TOkUfagQTohPIMtTq5c0Y0IOnS49iu8Z88eKVKkhFgs1QTYls1TxzqxWitI2bIV5WgmTa/WrdPnp3YYj4/XpXxffuniH4S2wmvbVucyvfGGfnbyD2YQXb0KDB8OvPgiUKHCtfuvXAHOnQMqVwYA7NixAwAQ6sZQbgeQz2LB1q1b039ClSoa15kzGb/J4sVA/frAxYvAli3Ak0+6IVIi71K6NDB7NrBkCbB+PVCtGjBxIuBweCgAEWDuXOCxxwCrNd2nDB+up5Rp0wCTCThz5gzatAnHpUslYbevBVA/mwdvBpttLc6csaBNm3DExMSk/6xm+vXxx8l35MkDdOmiPzgXSUoCPvwQqFMHiInRU9CHHwIhIS47BBmMiRMB48cDly4Bb711/f0XL+pt4cIAgAsXLgAASrkxFDOAEmYzoqOj039CoUJ6e/nyzY8lJQGvvw7cey/w8MPAxo1A9eruCpXIK7VvD+zeDbz0kn61aAHs2uWBA+/cCRw+rIlIOi5e1FPN8OFAqVKAiOD55/vi/PlE2O1LARTLYQDlYbMtRWTkSQwa9HqGzxo0CPj5Zw0VANCtm2aakZE5PL6eckJDgZEjNVnasEGv4ci/MHHK7S5dAkaNAgYOBIoXv/6xfPn09soVAHqi85QMjyUCNG+ul6tpRUYCd98NTJgAzJqlt8HB7g+UyAsFBwPvvQfs2AEEBgINGug1RfKvsnvMnasV4bp103148mSNpWdP/X7evHmYP/8X2O3jAJR2URBV4XCMwcSJ3+CPP/5I9xn33QdUrAjMmJF8R+vWQMmSwI8/ZvuosbHAK68Ad92lRfu9e4F+/QCLJdtvSV6MiVNu99FH+tv92ms3P5aSOMXGAgAKJ1eeMhkkyzEHgLMOR+qxbpKYCKxbp2fgFL/+qn8ZEhKArVv1CpKIUKMGsHo1MGUKMHUqUKsWsHChmw7266/AQw/dfFEDvd756ivgueeAvHn1vlGjxsBsvgfAIy4O5HlYLPUxZszH6T5qsQCdOgHLl6e54777gGXLsnW0334DatbUvGv2bP0+7YwH8j9MnHKz06eBzz4Dhg69liSlZbEABQoAZ88CAOrVqwcAyGD2kUscAhBrt6NBgwbpPyE+Xm/z5NEk6tVXgQceAB5/XMvtVau6MToi32MyAT16AAcOAPfcoznCQw8Bx4+78CBJScCePVpySce+fVoU7t5dv4+IiEBExEY4HC+7MIgUZtjtL2HJksU4cuRIus+45x5g0yad3glAM59//83SUU6dArp2Be6/H+jYUT/jI4+kmzeSn2HilJuNHAmUKKGXgRlp0ADYvBkAUKRIEVQuXx7r3RjS38m3DRs2TP8JKYnTqVM6ZDd9uk5YGDsWCApyY2REvq1oUa08/fWXJlE1auh1k83mgjc/fBiw23VGejrWrNGpknXq6Pfz5s2D1VoMwL0uOHh6usNkCsSvv/6a7qONG2u4yetddIgxKkovxm7B4QC++UZ/frt2AX/+qZPwMyqSk/9h4pRbHT6sv/3vvqvVm4y0bAmsWpX67UOPPopZFguuZvyKHJlqsaBVixYoViyDiaIJCXp79916abdtW4aTUYnoZi1b6q/N4MH61bixVl9y5NAhnSN5223pPrx9O9CwIWBO/ouzeXME7PYmANJffZdzITCb6yEiIiLdR8uW1WL6wYPJd1StqhnR0aOZvuu+fUCrVsDLL+scpu3b9VREuQsTp9xq2DBdcfbYY5k/r2NHYP9+PWMAeP755xFtt2OmG0LaCeBPux0vvPRS+k+Ijwe++EL/+5lngLVrMzxRE1HGAgN1Ee2ePdrG4M47tRvJpUvZfMPISB3az2BBxn//abKSYuvWHRDJoKrsIjZbQ2zevD3dx0wmnWuVOlRXubLemcFwXUKCrgasV0/na23fDowYwSJ3bsXEKTfasQP44QddTXerZR933aX19Y8+AgBUqVIFXbt0wWCLBWddGJIdwPMWC26/7TY8+OCDNz/hn3+0ActffwEBATrGkHaCOBFlWeXKwKJFwJw5wLx5ei01e7YmB1kSFaVL1TKQmHh9YTsmJhpAiWzF7LziuJjSUiUdQUHXRv4RFKTnlbi4m563Zo22FPjsM+DLL/UUVLOmWwImH8HEKTcaMkQTos6db/1ck0kvTb/7Tk+OAMaOGwd7vnx4wWSCqxoUfAJgg8OBad99h8AbE6JZs7TOHxSka6zZSY7IZUwmneS8f7/ePvYY0KGDjr45LTIy06VkiYnXX+eYTCbAZWePjJkymakdHJym4gToBPeAgNRvL14E+vTRobhatbTo/vzz14YbKffiP4HcZs0avcT88EPnl3907apXk2+/DQAoWbIkJk6Zgrki6I+cn/6+B/AmgDfeeAPNmze/9sDVqzpx/bHHgL59dRZm3rysjxO5QYECWlHZtEm7e9euretHUqYVZioyMtOKU1BQalcTAEDBgkUAnMpxzJk7jSJFimT4aGJimoJ7QoJW1vPlgwjw0086+XvRImD+fF1/UqaMm8Mln8HEKTcR0epRp046Q9RZVivw9ddadUpuEtelSxeMGzcOXwB4AsDFbIRjAzASwFMAnn76abz//vvXHty/H2jSRMcPFi8GRo/Wq8GEBCZORG7UqJEmT6NHA2PG6DDVn3/e4kW3GKqrVUu7mV87RgOYze5sbAJYrRFo0iT9tibx8bo+JnVjgcuXgZ07cSymIO6/H3j0Ud18YO9e4H//c2uY5IOYOOUmCxdqr6NRo7L+2vBwYMAAnZSdvH9D37598cMPP2Bh3ryoZbHgJ+hcpVsRAOsB3Gmx4B2TCW8PHYpJkyfDnFID//Zb3begcGGdhdmx47UXx8dnvgqQiHLMYtFO2Pv2adLTurV2/D53Lp0nJyUBJ09mOlRXp44mIfbkE0STJo1gMm0CcOvl/9lzCXb7LjRq1CjdRw8e1EV0KXOV7NEx+BIvo+YTDXD0qJ4mx47VKhzRTQzeZJg8xWYTqV1b5PHHs/8eSUki7duLFCki8vffqXdHRUVJx3btBIBUsFplOCArAYlOs315HCAbAPkCkAYWiwCQWtWqycaNG6+9/+XLIj17iphMIm+/nf4O6++9J1K3bvY/AxFl2cKFIpUq6a/+lCkidnuaB48c0d/z7dszfP3+/fqUDRv0+927dwsAAWZJmtOEC7/GitlskRMnTqQbz6xZIkFBelrcvl2kca0rkgdX5f1B0ZKQ4LqfG/knJk65xbffilitIocO5ex94uNFHnlEJDhYZMGC6x7asmWLPPP005IvODj5pAjJa7FIfotFzMnfWy0WubdjR1m8eLHY0559d+4UqVFDpEQJkWXLMj7+kCEijRvn7DMQUZZduSLy5pt6GmnZUmT37uQH/vhDs5Xo6Exf37ChSJ8+175v0aKVmM13CeBwcdKUJBZLdXnooS4ZxtK7t8idd4q88YaIxSLSpkG0HERVkQsXcvpjolzAJOLBnVvJGAkJOph/7726YVROORxA//46k/S553Tor2jR1IftdjsOHjyIrVu34r///oPD4UChQoVQr1491KlTB3nSDrXFx2tMI0fqkNynn2pjmYwMHKgTMP76K+efg4iybPduXV22cSMwaBDw9m0zETLgBW0ClcmCk/HjdYrlqVO6MHbZsmVo3749gMkAerkwwtEwmQZj48YNaNy48U2PxsVpr86QEB06/OQToGeJxTB1vleHHa3uaspJfsPozI084MsvRUJCRE6dcu37/vqrSLlyIgULigwbJvLPP86/NiZGZMwYkVKlNLZPPrmh/p+Bl14SCQ/PdshElHN2u8jkyTp0d1vhC7K44vO3fM2FC/qr/umn1+7r2fNpsVgKCHDIRdWm7WI2B8qgQYPSjeHsWZEWLfS5XbqInDmT/MCsWRockRNYcfJ3sbG6D9Nzz2lVx9Xi4oDPP9dVd8ePA02b6jKUevW0u17x4sCVKxrHhQtARIRu175ypa6Se/llnYWa0RYrN3r2Wd2c+LffXP9ZiChLzp4FBjVfjxn/NEPXrnoqyGzZ/siR2kt33z593sWLF9GgQWMcP+6AzbYaQMYTzG9tPyyWNqhRoxQ2bVqP4DRdzEWAmTO1UH75sm4zc13ReuJE4J13tBxGdAtcVefvPv9c69GDBrnn/UNCdMOryEjgjz+AunWBqVO1uWaNGpoQVayoTWHuvlvPmnny6JKVyEjdK8/ZpAlgOwIiL1K8ODC90nCsvv8z7NypMwLGjr22eu5GAwcC5coBvXvriH+hQoXwxx8rULq0wGptDmB1NiP5DRZLS1StWhQrVy69Lmk6fBho3x7o0UNXB8bHp7OwOCaGS+jIaUyc/Nm5c5qovPUWULCge49lNuvulxMn6vYosbG6/njNGt1R9N9/9fL0xAntBfX009k7UbEdAZF3iYpC62aJ2LEDeP11vUZr2lSLyzcKCtJuI6tXAy+9pJWgihUr4u+/16Bp08oA2gJ4AcAxJw9+CCbTkwDuR3h4E6xb9ydKlNCtXGw27UNVuzZw/jywbp2ekh55BGjR4oa3YeJEWcDEyZ998IGeDF580eOHjnU4MHzOHNR54QXka9ECBRs2ROOOHfHJJ58gMTEHvVvi41lxIvIWItr8skIF5Mmjmwvs3g0UKaL9a/v105wkrdBQ7Ws7ebImWiJA2bJl8ddfqzF27FiEhMyEyVQJJtODAKYA2A4gAbow9yqALQC+gdncEUBVFCiwGNOnT8fixQtRNHmRypYtOhw3YoQOD27cqKP7J07oZPCbxMQA+fO77cdEfsboSVbkJpGRInnyiEya5PFDHz16VCpVqpTakiAkJETy5MmT+n2DBg3kQnaX/bZrJ/Lii64NmIiy58wZnWm9bt11dzscOt+6ZEmRMmVEfvpJ70vrl1+0FUC3btd3AYiJiZGvv/5a6tZtKGazOfW8kfbLbLZIo0Z3yrRp0yQuLi71tbGxIq++KmI2i3ToIHL4sN4/e7a2h5s2LYPP8cwzIv/7X45/HJQ7cHK4v3rmGa1N79nj0eW1NpsNDRs2xK5du1C6dGl8++23CAsLg8PhwE8//YRnn30WsbGx6NSpExYtWpT1A7RqpXtCpHvZSEQelVLaOX4cKFv2pocvXtQpkBMmaLeRr74Cbrvt2uN//gk89ZTOd5o2DQgLu/71V65cwfbt23Ho0CEkJiYiT548uOOOO1C3bt2bJn/Pn697gB8/DnzxBdCtm3ZHWLxY16u8/jqQdlen63Ttqrv+fvttjn8klAsYnbmRG+zZo5dcP/3k8UNPnjw59apw/fr1Nz3+ww8/pD6+YsWKrB+gaVORwYNdECkR5djPP2tHTJst06dt2CBSr572zf3gA5HExGuPRUeLPPaYFq7uuktPW+ltGpCey5dFZswQad5cK0qDB4ucP3/t8T/+0A7hffveXPG6DivZlAWc4+SP3n4baNgQ6NLF44eeMWMGAKBNmza46667bnq8W7duuC35kvPb7FzdcXI4kfeIjATKl9fN7TLRtKkWp0aO1K8GDYC1a/WxQoW0VcCmTUClSlopqlBBK1Hjx2vbgK1bde7Uvn3AokXAhx8C3btrr9znntOFu5s2aUWpSBGtYI0ZoxWsrl11pV8mvTk5OZyyhImTv9m4UWdefvjhLc4UrhcXF4d169YBADqm3Zg3DZPJhA4dOgDQzsFZxsnhRN4jKkqzFidYrcBrr+nKtttvB1q21LYEZ8/q440bAz/8ABw5os87fx4YPlxH50NDdaPgmjWB++4DpkzRziQffKCtl2bO1BF8QPcbDg8Hhg3TbiwzZuii30wxcaIsYG95fyICvPmmXmbdc4/HD79v3z44HA4AQO3atTN8Xspjp0+fxoULF1CkSBHnD5KQwIoTkbeIjNTyUBZUqKDXdgsWaMu3O+7QJKd3b13YVr689nsaOFBPaRcu6PVSYqLuiFKunLaPu9GJE7oL1IQJ+h6bN2uy5RSuqqMsYMXJnyxfrk0ob+ru5hknT55M/e+y6UwUTe+xtK9xCitORN4jCxWnG91/PzBrllaXhg4FSpYEnnxSNxUwmUwwmUwwm00oVsyEcuVMqFzZhGrVTMib15T6uMlkQsOGbdCzp046nz1bWxBkKWkCtO8cK07kJFac/IXDoY0uH35Ya94GiI2NTf3vkPQuCdN5LO1rnMLO4UTeIzIy24kToAvZhg4FXn0V+PlnYPp0LZibTCVhtSL1y2K5fke6pKQkxMdfAABs29YYZrMOyT38sO7klCUiHKqjLGHi5C9+/hnYsUMnCfgzTg4n8g5XruhEpCwO1aUnf37dTODpp3WLlGXLTmPfPp0PtW8fcOaMJlnBwXrd5HB8guPHBwIAVq/uhdatc/g5RJg4kdOYOPmDpCRdSff000C1aoaFkT/NHIG4uLgMn5f2sfxZmVcgwooTkbeIitLbHFSc0lO5MvD885k/p2bNKQCAFi1aoHXrHJ7zUlqbM3EiJ3GOkz+YOlVPYu+8Y2gYZdJsi37ixIkMn5f2sTKZbaV+I5tNhyRZcSIyXmSk3pYv79HDrl+/Hvv27QMA9O7dO+dvyMSJsoiJk6+Li9PZkC+/rMtNDFSjRg2Yk9f97t69O8PnpTxWqlSprK2oi4/XW1aciIwXGQmUKKHjZx40ZYpWmwoWLIiuXbvm/A1TEieuqiMnMXHydWPH6hj9m28aHQlCQkLQvHlzAMCSJUvSfY6IYOnSpQCAdu3aZe0ACQl6y8SJyHg5WFGXXZcvX8aPP/4IAOjevXumi1CclrJAhRUnchITJ18WHa2NLt94A0jeFdxoPXr0AACsXr0aGzduvOnxn376CYcPHwYAPPXUU1l785SKE4fqiIyXjR5OOTV79mxcvnwZgIuG6QCtOFksHq+cke9i4uTLxozRJKJfP6MjSdWjRw/UqVMHIoIuXbpg5cqVAHDdJr+Adha/J6tNOllxIvIeOWxFkB2TJ08GANSrVw+hoaGuedOUVgQe3mmBfBdX1fmqkyd1C/CPPwby5jU6mlRWqxULFixAmzZtcPToUYSFhSEkJAQOhwPxyRWjBg0aYObMmVl/c1aciLxHVJRuBOche/bsSa1iu6zaBLCHE2UZK06+6r33dIdLV55AXKRSpUrYuXMnhg0bhtq1a8NkMiEgIAChoaH4+OOPsWHDBhQuXDjrb8zJ4UTewWbTPU48OFSXUm0KCgrCE0884bo3ZuJEWcSKky/65x9g0iTg22+BwECjo0lX/vz5MWLECIwYMcJ1b8qhOiLvcPIkYLd7bKguMTER33//PQCgS5cuKFSokOvenPvUURax4uSLhg0DatUCunUzOhLP4lAdkXdI6eHkoYrTr7/+inPnzgFw8TAdwH3qKMtYcfI127bpTpaLFgHmXJb3suJE5B0iI3VuZVb6sOVAyjBd1apV0apVK9e+OYfqKIty2V9eP/DWW0DLlkDHjkZH4nnx8ZosWpnvExkqpYeTB1aiRUVFYcWKFQCAZ555BiZXH5OJE2UR/wL5ktWrgaVLgbVrc+fS2fh4VpuIvIEHezhNnToVDocDVqsVPXv2dP0BYmKA2293/fuS32LFyVeIaLXpvvuA5O7cuQ43+CXyDh7q4eRwODBt2jQAQKdOnVC6dGnXH4QVJ8oiVpx8xa+/Aps2ATt3Gh2JceLjOTGcyBtERQGunmuUjhUrViAqKgqAGyaFp4iN5ao6yhImTr7AbgcGDwaefBKoXdvoaIzDihOR8UQ8NlTXrl07iIh7D8KKE2UREydf8N13wL//AosXGx2JsVhxIjLe+fNAXJzHt1txGyZOlEWc4+Tt4uOBd94BXngBqFTJ6GiMxcnhRMZLHjrzi8QpMVHPK0ycKAuYOHm7CRP0Cm/IEKMjMR6H6oiMFxkJWCy65ZOvi43VWyZOlAVMnLxZTAzw/vvAgAFAiRJGR2M8DtURGS8yEihXzj/6qcXE6C0nh1MWMHHyZp9+qhMxBwwwOhLvwIoTkfGiojy6ua9bseJE2cDEyVv99x/wySc6RMdfasWKE5HxPNTDySNSKk48x1IWMHHyVu+/DxQurJPCSbHiRGS8lO1W/AGH6igb/GCQ2g8dPQp8/TXwzTdMFNKKj9eNRYnIOB7cbsXtYmKAkBD/mK9FHsOKkzd65x3dO+mpp4yOxLtwqI7IWHFxwNmz/lVx4jAdZRHTbG+ze7c2vPzlF13yS9dwqI7IWMeO6a0/JU4cpqMsYsXJ2wwZAjRpAvzvf0ZH4n1YcSIyVmSk3pYvb2wcrhIby4oTZRkrTt5k/XpgwQJg9WrAZDI6Gu/DihORsSIjgWLF/GeuIYfqKBtYcfIWIsCbbwLt2wOtWxsdjXfilitExvKnHk4AEyfKFlacvMWSJcCaNUBEhNGReC8O1REZy596OAFMnChbWHHyBg4H8NZbwKOPAg0bGh2N9+JQHZGxmDgRMXHyCrNn62q6994zOhLvxooTkbH8caiOq+ooi5g4GS0xERg6FOjdW3s3UcZYcSIyjt0OHD/uXxUnrqqjbGDiZLTJk4FTp4Bhw4yOxPux4kRknFOnAJvNvxInDtVRNjBxMtKVK8C77wL9+gFlyhgdjXcTYcWJyEgpPZz8baiOiRNlERMnI33xhSYDr79udCTeLzFRb5k4ERkjMhIIDtY+Tv5AhIkTZQsTJ6OcPw+MHq29mwoXNjoa7xcfr7ccqiMyRlSUDtP5S3PeK1c0eWLiRFnExMkoo0dr992XXzY6Et+QkKC3rDgRGSMy0v+G6QCuqqMsYwNMIxw/DowdC3z+ORASYnQ0voEVJyJj+VsPp9hYvWXFibKIFScjvPsuUK4c8MwzRkfiO1ISJ1aciIzhjz2cACZOlGWsOHnagQPA1KnAzJlAQIDR0fgODtURGUfE/ypOTJwom1hx8rS33wbq1gW6djU6Et/CoToi40RHA5cv+1/iZLHoSkGiLGDFyZM2bwZ+/lk39DUzZ80SVpyIjBMVpbf+NlRXoID/rBIkj+Ffb08aPBho3Rpo187oSHwPK05ExomM1Iu9smWNjsR1uE8dZRMrTp6yYoV+bdjAK5zsSKk4MXEi8ryoKE2a/GleJvepo2xixckTRIC33gIefBBo2tToaHxTfLyetC0WoyMhyn38rYcTwK7hlG2sOHnCL78AW7cCM2YYHYnv4ga/RMbxtxV1ABMnyjZWnNzNZgOGDAF69ABq1jQ6Gt/FDX6JjJOy3Yo/YeJE2cSKk7vNmAEcOQIsW2Z0JL6NFSci4/jrUF3JkkZHQT6IFSd3unoVGD4cePFF/zvpeBorTkTGiI8Hzpzxv4pTbCxX1VG2MHFyp3HjgEuXdGI45Ux8PBMnIiMcO6a3/nbxx6E6yiYmTu5y8SIwahQwcCBQvLjR0fg+DtURGSMyUm/9reLExImyiYmTu3z8MWC1Av37Gx2Jf+BQHZExIiOBIkWAfPmMjsS1mDhRNnFyuDucPg189hnwwQccQ3cVVpyIjBEV5X/DdAATJ8o2VpzcYeRIoEQJoE8foyPxH6w4ERnDH3s4JSXpxRgvbCkbWHFytcOHgW++AaZOZYXElTg5nMgYkZFA3bpGR+FasbF6y4oTZQMrTq42bBhQvTrw2GNGR+JfOFRHZAx/HKqLidFbJk6UDaw4udKOHcAPPwC//so91VwtIQEoWNDoKIhyF4dD2xH421AdEyfKAVacXGnIEOCuu4DOnY2OxP+w4kTkeadP63wgVpyIUrHi5Cpr1gCLFgF//QWYTEZH4384OZzI8/y5hxPAyeGULaw4uYII8OabQKdOQMuWRkfjnzg5nMjzIiO10luihNGRuFZMDBAcrL32iLKI/2pcYeFCYP16YPt2oyPxXxyqI/K8lInh/lZFj43lMB1lGytOOWW3A4MH6yq6evWMjsZ/caiOyPP8sYcTwOaXlCOsOOXUDz8A+/cD8+cbHYl/Y8WJyPOYOBHdhBWnnEhI0L5NffoAVaoYHY1/Y8WJyPP8sYcTwMSJcoSJU05MnAj89x/w9ttGR+L/ODmcyPNYcSK6CYfqsis2FnjvPaB/f6BUqQyflpiYiN27d+P48eOw2WwICQlBzZo1Ub58eZj8bcKlOyUkcKiOyJMuXtQEw18TJ7YioGxi4pRdn3+uE8MHDbrpocuXL2PmzJmYMWUKIrZtQ6LNdtNzihUqhLD27fFC375o2bIlk6hbYcWJyLOiovTWH4fqYmP9r8UCeQyH6rLj3Dngo4+At966bhsQu92Ojz/+GGVLlULfF15AsS1b8LHNhnUATgM4B+AIgAUAXrh4EVvnzkWrVq3QoE4dbNy40ZjP4gscDu1ezIoTkedERmobgnLljI7E9ThURznAxCk7Ro3SX7oXX0y96/Dhw2hx1114fdAg9LhyBUdEsEAELwNoBqAkgKIAKgG4D8C7APbbbFgBIGD/fjS76y68+eabsKVTncr1EhL0lhUnIs+JigJKlwYCA42OxPWYOFEOcKguq6KigHHj9Cs4GACwZ88e3NOqFfJduoS10ETJGSYA9wD4227HRwCGjhmDfw8exKw5cxAQEOCe+H1RfLzeMnEi8hx/nRgOMHGiHGHFKauGDwcqVQJ69gQAHDt2DOFt2qDkxYv422ZzOmlKywrgLQC/iGDB/Pl4tndviIjLQvZ5KRUnDtUReQ4TJ6J0MXHKin/+0W1VPvgAsFohIuj9zDMwR0djmd2O4jl8+/sBTBXBjG+/xY8//uiCgP0EK05EnuevPZxEdHI4V9VRNjFxyoqPP9ZJyg88AACYNm0alq1YgUk2G0q66BBPAOhqMuHF55/H2bNnXfSuPi4lcWLFichz/LXiFBenC05YcaJsYuLkLJsNmDsXePZZwGyGw+HAyOHD8QiAji4+1FciuBoTgwkTJrj4nX0UJ4cTeVZCAnDqlH8mTjExesvEibKJiZOz1q8Hzp8H/vc/AMDSpUtx5Ngx9HfDoUoAeNzhwDfjxnGVHcCKE5GnHT+ut/44VMfEiXKIiZOzFi0C6tVLvQKbNWsWalutaOqmwz0L4MSZM1i3bp2bjuBDWHEi8qzISL1lxYnoJkycnLV7N9CoUeq3W/7+G3fbbHBXv++GAELMZmzZssVNR/AhnBxO5FmRkdrc1x+TCyZOlENMnJwVGQncdhsAIC4uDvsPHUKoGw9nAVDfZEJERIQbj+IjUhInf2zER+SNoqL8s9oEaOJkNqf24SPKKiZOzjp7FiiuDQfOnz8PEUFZNx+yrN2Os2fOuPkoPiBlg1/u50fkGf66og7QVgQFCvB8QtnGxMlZefIAiYkAkNqc0t2/dmYADrvdzUfxAfHxnBhO5EmRkf45MRxg80vKMSZOzipaVFfVASiQ/Et33s2HPG8yoWDhwm4+ig9ISOD8JiJP8vehOiZOlANMnJxVtChw7hwAoFChQihfqhS2ufFwAmCbxYJ69eu78Sg+Ij6eiRORpzgcTJyIMsHEyVk1agA7dqR+2+jOO7HB7L4f3yEA5202hIa6cwq6j+BQHZHn/PefTkvgUB1Rupg4OSssDLDbtV0/gPvuvx9rHA4cctPhZgDIHxKCVq1auekIPoRDdUSe4889nADuU0c5xsTJWXfdpd3DkxtSPvrooyhcoADGu+FQCQAmWa146umnkZ+/4Kw4EXlSZKS2/ijpqh04vQwrTpRDTJycVaKEdg5fvhwAEBISghdfeQVfmc3Y6+JDvQfgAoCXX37Zxe/so1hxIvKcqCigfHntdeSPmDhRDvnpb4abhIcDK1akfjtkyBBUrlwZPS0WJLroEJsBfGgyYeiwYahWrZqL3tXHcXI4kef4cw8ngIkT5RgTp6wICwO2bUtdXRcUFITp33+PHSYTnjSZkNPteA8AuM9qRWiDBnjzzTdzHK7fSGmASUTu5889nAAmTpRjTJyyomVLHftfuTL1rqZNm2LWnDn4xWzGAyYTzmbzrVcDaGmxoGjlyli4ZAkCAgJcErJfYMWJyHP8uRUBoIkT545SDjBxyoqQEKB58+uG6wDgoYcewoLffsOGggVRy2LBLADO9vs+D+BFAG0B1GrWDH+uW4fiyVu7UDJODifyHH8fqkvZcoUom5g4ZVVYmE4QT952JUXHjh2xZ/9+tOjcGY8BqGK1YhR0zlLCDW9xFsDvAHoAKGs2Y3pQEMaOHYuVf/yBYsWKeeJT+BZODifyjJgY4OJF/x2qS0oCrl5l4kQ5wsQpq8LC9Irs0M0dnEqWLIlf5s/Hxo0b0eaJJ/BeYCCaAMhvMqFyQACqBQSgTEAASgDoBOCvcuUwYtQoHI2KwksvvQSzv65iySkO1RF5RlSU3vprxSk2Vm+ZOFEOWI0OwOeEhgKFCulwXdWq6T6lSZMmaNKkCcaPH4+dO3ciIiICx48fR1JSEkJCQlCzZk2EhoaiSpUqMHGH7lvj5HAiz0hpflm+vLFxuEtMjN4ycaIcYOKUVRYL0LatJk7PP5/pU4ODg9G0aVM0bdrUQ8H5KVaciDwjKgooVcp/L1SYOJELcGwoO8LCgFWrdAsWcj9ODifyDH+fGJ6SOHFVHeUAE6fsCA8HoqOBrVuNjiR34ORwIs/w98QpZY4TEyfKASZO2VGlip5cbmhLQG7CoToiz4iK8t8VdYBWnIKDAfbJoxxg4pQdJpMO12WSOMXFxWHJkiX44IMP0LVrV1StWhVmsxkmkwk9e/b0XKz+gJPDiTzD3ytO7BpOLsDJ4dkVFgb06AHExWljzBts2rQJHTt2NCAwP8SKE5H7JSYCJ0/6f8WJiRPlECtO2XXPPXqiWbs2w6cULlwYbdq0Qf/+/fHtt9+ifv36novPn3ByOJH7nTihjX1ZcSLKFCtO2VW8OFC/vg7XtWt308MtW7bEhQsXrrtvypQpHgrOz3ByOJH7pfRw8vfEiRPDKYdYccqJlO1X0mGxWDwcjJ+y2bTtAxMnIveKjNSkomBBoyNxH+5TRy7AxCknwsOB7duBs2eNjsR/JSTv9MehOiL3iorSapM/72bAoTpyASZOOdGiBRAYqM0wyT3i4/WWFSci9/L3FXUAEydyCSZOORESAjRvzn5O7pSSOLHiRORe/t7DCWDiRC7BxCmnwsN1npOI0ZH4p5ShOlaciNyLFScipzBxyqmwMD3hHDpkdCT+iUN1RO4nknsqTlxVRznExCmnGjYEChfmcJ27cHI4kfudPasXKf5eceKqOnIBJk45ZbEAbdtm2JaAcogVJyL3yw09nEQ4VEcuwcTJFcLCdGWd3W50JP6HFSci94uMBKxWoFQpoyNxn7g4wOFg4kQ5xsTJFcLCgIsXga1bjY7E/7DiROR+UVFA+fJaQfdXMTF6y8SJcohbrrhClSpa4l6+HGjc2Oho/Et8vDbks/KfKpHbZHFFXXR0NCIiIrB161acPn0adrsdBQoUQJ06dRAaGorKlSvD5G2NNJk4kYvwr5ErmEzalmDFCmDw4NS7o6OjYU8zfJeUlAQASEhIwLlz51LvDwoKQr58+TwXry9J2afO207CRP4kMvKWK+ocDgeWLl2Kr74aj99/XwQRgcWSD2ZzeejgRTSSkk4CACpXvgOvvNIXPXr0QKFChdwevlNSEieuqqMc4lCdq4SFAevW6Th6sgYNGqB48eKpX+vXrwcAzJ49+7r7X3rpJaOi9n7x8RymI3K3lO1WMrB//37ceWdzdOrUCUuXHofI1wD2w26/hKSkvUhK2o2kpBMAzgBYiCNHGqB//4GoWLEyvv/+e4g39LmLjdVbVpwoh5g4uUrbtkBiIrB2rdGR+JeEBE4MJ3K3TIbqJk2ahLp162PbtvMAVsFu3wqgD4BquPlPSAkA90JkNkSiEBvbAU8++SQefLALrly54taPcEsxMYDZrDs+EOUAEydXKV4caNDgurYER48ehYjc8mv69OnGxe3tWHEicq/Ll4ELF9Idqvvkk0/w3HPPISmpJ2y27QDaAHB22Lw0RH4AMBe//bYM4eEdjE2eUloRcNifcoiJkyuFhbERpqvFx7PiROROUVF6e0PF6ccff8TAgQMBvAngawDZrdQ8BIdjBTZt2o7u3R83btiOPZzIRZg4uVJYGLB9u3bhJddImRxORO6R0vyyfPnUu06fPo3nnnsBJlNXAKPgfJUpI3fCbp+J3377Fd9++20O3yubmDiRizBxcqWWLbU6snKl0ZH4Dw7VEblXVBRQogQQHJx6V79+/XH5sgUi45DzpCnF/TCZnsRLL/W7blWxx3CfOnIRJk6uFBwMNG/O4TpX4uRwIve6YWJ4VFQUfvrpR9jtIwAUd+mhRD5BXFw8pk2b5tL3dQr3qSMXYeLkamFhOkHcG5bf+gNWnIjc64YeThMnToTZnA/Ak244WHE4HI9i7Niv4XA43PD+meBQHbkIEydXCw/X0ve//xodiX/g5HAi97qhh9O8eQtht3cB4K6mvE/h2LEj2Lt3r5vePwNMnMhFmDi5WoMGQOHCHK5zFU4OJ3Kv+PjUxOnq1avYv383gKZuPKBuSxUREeHGY6SDiRO5CBMnV7NYtBkmEyfX4FAdkfuI6ErgsmUBAPv27YPDYQdQ340HLYCAgKrYsWOHG4+RDiZO5CJMnNwhLAxYtQpIs08dZRMnhxO5T0ICYLOlJhQxKfu5oYhbDytSJM2xPCQ2lqvqyCWYOLlDeDhw8SLg6VK0P2LFich9UrpoJ0/UNptT/iS4e3GLAxaLxc3HuAErTuQiTJzcoXJloFIlDte5AieHE7lPnjxAkyaaVAAoUaJE8gPH3Xzg4yhe3LWtDm6JiRO5CBMndzCZuP2Kq3ByOJF7nToFnD4NALj99tsRFJQXgDur5Sdhs51GaGioG49xg6Qk4OpVJk7kEkyc3CU8HFi3DoiLMzoS38ahOiL3Kl48dZsoi8WC0NBQmEx/ufGAawAAjRo1cuMxbhAbq7dMnMgFmDi5S9u2QGIisGaN0ZH4Nk4OJ3KvEiWA//5L/faJJ7oDWAzgmFsOZzZPxF13tUD5NHvjuV3KRHRODicXYOLkLsWKaU8nDtflDCtORO6VpuIEAI8//jiCg/MCGOuGg+2Aw7EKL7/c1w3vnQlWnMiFmDi5U3i4br9C2ceKE5F73ZA45c+fH4MGvQaT6TMA2114IBsslt64/fYa6NKliwvf1wkpFScmTuQCTJzcKSwM2LHjujI4ZRErTkTudcNQHQAMHjwYNWrUhMXyFIDLLjrQe3A4tuL776cjMDDQRe/pJA7VkQsxcXKnFi20WrJqldGR+C4mTkTudUPFCQACAwMxa9Z3yJPnKMzm+5Hz5OlLAO9i5Mj30KRJkxy+VzbExADBwUBAgOePTX6HiZM7BQcDzZtznlN2iXCojsjdSpQALlzQDuJp1K1bF0uXLkZQ0BZYLC0B7MrGm18G8CKAfhg0aBDeeustFwScDezhRC7ExMndUuY5ibs78fqhpCT9ubHiROQ+KY0oz5276aEWLVpg/fo1qFo1CSZTKIC3AZx24k0TAcyB1VoXQUHTMW7cOIwePRqmlE7lnhYTw2E6chkmTu4WFgZERQH//mt0JL4nIUFvWXEicp+UxOmG4boU9erVw44dERg8+HUEBX0Gk6k8gIcBfAXgbwAnAJwCsA/ADwD6w2qtCKAbWrW6Hbt370Tfvn2NS5oAXVXHihO5CBMnd2vQAChcmMN12REfr7esOBG5T8o2K5ksYsmTJw9GjhyJU6dO4PPPP0GDBlGwWl8D0AxAOQBlANQE8DjKlfsVzz33EHbv3o0VK5aiSpUq7v8Mt8KhOnIhq9EB+D2LBbjnHh2ue+EFo6PxLUyciNwvb179Hcug4pRWoUKF8Morr+CVV15BYmIidu/ejTNnzsButyN//vyoXbs2ihYt6oGgs4iJE7kQEydPCAsD3ngDsNs1kSLncKiOyP1MpnRX1t1KYGAgGjZs6KagXIyJE7kQh+o8ISwMuHQJiHDnxpl+iBUnIs9Ip5eTX2HiRC7ExMkTqlQBbruNXcSzihUnIs/IRsXJp3BVHbkQEydPCQvjBPGsYsWJyDNKlMhW4hQTE4PRo0ejWbNmKF68OPLkyYNy5cqhTZs2GD58OC5evOj6WLODq+rIhTjHyVPCwoAZM4ArV3QyJt0aEycizyheHDh8OEsvWb16Nbp3744zZ84A0DlPISEhOHHiBE6cOIE//vgDDzzwAOrXr++GgLOIQ3XkQqw4eUrbttrQce1aoyPxHRyqI/KMLA7VrVu3Dvfeey/OnDmDhx56CJs3b0Z8fDyio6Nx5coVbNq0CUOGDEHBggXdGHQWMHEiF2LFyVOKFdOeTsuXA+3bGx2Nb4iPB6xWrkQkcrcsTA6Pi4vDU089hatXr+Lll1/Gl19+ed3jISEhaNy4MRo3buyOSLNOhIkTuRQrTp7EeU5Zw33qiDyjeHEgOlqr4rfw3Xff4fDhwyhVqhTGjBnjgeByKC4OcDiYOJHLMHHypLAwYMcO/17260rx8ZzfROQJKd3Dz5+/5VO//fZbAEDXrl0R5Au/nzExestVdeQiTJw8qUULraCsXGl0JL6BiRORZ6TsV3eLi7qEhARs2bIFABAaGoqoqCg899xzKF++PAIDA1GyZEncd999WLRokbsjdl5srN6y4kQuwsTJk4KDNXnicJ1zOFRH5Bm32Og3xdGjR5GYmAgAOHz4MGrXro1Jkybhv//+Q968efHff/9h4cKF6Ny5M5599lmIiLsjv7WUihMTJ3IRJk6eFhamE8S94YTi7VhxIvKMvHn1wu4WFafo6OjU/x45ciQCAgLw008/4fLly4iOjkZkZCS6du0KAJg8eTI+++wzt4btFCZO5GJMnDwtPBw4dgz45x+jI/F+rDgReYaT+9U5HI7r/nvKlCl4+OGHERAQAACoUKECZs+ejXr16gEARo0aBZvN5r64nRETA5jNQEiIsXGQ32Di5Gn16wNFinC4zhmsOBF5jhPdw/OnmWB9++2344EHHrjpOWazGQMHDgQAnD9/HhFG79GZ0orAZDI2DvIbTJw8zWLRZphMnG6NFScizyle/JZDdWXLlk397+rVq2f4vJo1a6b+d2RkZM5jywnuU0cuxsTJCOHhwKpVgN1udCTejRUnIs9xYqiuSJEi1yVPGUk7KdxkdKWH+9SRizFxMkJYGHDpEpC8rJcywMSJyHOc3Oi3Xbt2AIB9+/Zl+Jy9e/em/vdtt92W89hygl3DycWYOBmhcmXgtts4XHcrHKoj8hwnhuoA4OmnnwYA/Pvvv5g/f/5NjzscDnz88ccAdGivYcOGLg0zy5g4kYsxcTJKeDgTp1thxYnIc5zc6Ldly5Z4+OGHAQC9e/fG3LlzU1fORUVFoXv37ti5cycA4P3334fZbPCfGSZO5GLc5NcoYWHAtGnAlSvaQ4VulpCgmyMTkfuVKHFtv7rk9gIZmT59Ov777z/89ddfePjhh5EnTx6EhIRc1+fpnXfeQY8ePdwd9a3FxFxr8EnkAqw4GaVNG8BmA9asMToS78WKE5HnpCQX587d8ql58+bF6tWrMWnSJNx9993ImzcvLl++jLJly6Jbt25Yt24dhg8f7t54nRUby1V15FKsOBmlWDGgQQMdruvQwehovBMTJyLPSdno9+xZoHTpWz7dbDajd+/e6N27t5sDyyEO1ZGLseJkpPBw3X6F0sfJ4USe4+RGvz6HiRO5GBMnI4WFATt3AmfOGB2Jd2LFichzUvarc2KCuE9h4kQuxsTJSM2ba0Vl1SqjI/FOrDgReZaTvZx8ChMncjEmTkYKDgZatmRbgoyw4kTkWU72cvIZNhtw9Sonh5NLMXEyWliYznNKs0UBJWPiRORZ/lZxio3VW1acyIWYOBktLAw4dgz45x+jI/E+HKoj8ix/qzjFxOgtEydyISZORmvQAChShMN16WHFiciznOwe7jOYOJEbMHEymtkM3HMP2xLcSARITGTFiciT/G2ojokTuQETJ28QFgasXq0TGUklJOgtK05EnuOvQ3WcHE4uxMTJG4SHA5cuARERRkfiPeLj9ZaJE5HnlCgBXLyo+9X5g5gYPYfcYu89oqxg4uQNbrsNqFyZw3VppVScOFRH5DlZ2K/OJ8TGcpiOXI6Jk7cIC+ME8bRYcSLyPH/bdoXNL8kNmDh5i7AwYP164MoVoyPxDqw4EXleSuLkLxPEmTiRGzBx8hZt2+rk8DVrjI7EO7DiROR5efMCISGsOBFlgomTtyhaFGjYkPOcUjBxIjKGP/VyYuJEbsDEyZtwntM1HKojMoY/9XKKiWErAnI5Jk7eJDwc2LkTOHPG6EiMx4oTkTH8qZcTV9WRGzBx8ibNm2uisHKl0ZEYL6XiFBhobBxEuY2/VZyYOJGLMXHyJkFBQIsWHK4DtOIUGKhb0hCR5/hTxYmJE7kB/yp5m/BwTZxEjI7EWAkJHKYjMgInhxNliomTtwkLA44dAw4eNDoSY8XHc2I4kRE4VEeUKSZO3qZ+fW1NkNuH6+LjWXEiMkLx4rpfXWKi0ZHkjAhX1ZFbMHHyNmYzcM89TJwSElhxIjJCiRJ66+v71V29CjgcrDiRyzFx8kZhYcDq1dpJPLdixYnIGP6y7UpMjN4ycSIXY+LkjcLCgEuXgC1bjI7EOJwcTmQMf9nol4kTuQkTJ290221A5cq5e7iOk8OJjBESonvWseJElC4mTt4qpS1BbsWhOiLj+EMvJyZO5CZMnLxVWBiwfj1w+bLRkRiDk8OJjOMPvZxiYnSxTUiI0ZGQn2Hi5K3atNHJ4WvWGB2JMVhxIjKOP/Ryio3VVgQmk9GRkJ9h4uStihYFQkNz73AdK05ExvGXoToO05EbMHHyZmFhwPLlRkdhDFaciIzjDxUnJk7kJkycvFlYGLBrF3D6tNGReB4TJyLj+MscJyZO5AZMnLxZ8+aaPKxaZXQknsehOiLjcKiOKENMnLxZUBDQsmXunOfEihORcUqU0Ca8vrxfXcrkcCIXY+Lk7VLmOYkYHYlnseJEZBx/2HaFFSdyEyZO3i4sDDh+HDh40OhIPIsVJyLjpGz0y8SJ6CZMnLxd/framiC3DdcxcSIyDitORBli4uTtzGbgnntyX1sCDtURGSc4WPer8+UJ4kycyE2YOPmCsDBg9WrtJJ5bsOJEZCxf7+UUE8PJ4eQWTJx8QXi4ngS2bDE6Es9hxYnIWL7eyyk2lhUncgsmTr6gUiWgSpXcNVzHihORsUqU8N2hOpsNiItj4kRuwcTJV4SF5Z4J4na7nviYOBEZx5crTrGxesvEidyAiZOvCA8H/v4buHzZ6EjcLyFBbzlUR2QcX+4eHhOjt0ycyA2YOPmKNm20CrNmjdGRuF98vN6y4kRkHF+eHM7EidyIiZOvKFIECA3NHfOcWHEiMp4vD9WlJE5cVUduwMTJl4SH5455Tqw4ERmveHHdry7lQsaXpMxxYuJEbsDEyZeEhQG7dgGnTxsdiXulnKiZOBEZJ2XblXPnjI0jO2Ji9PwRGGh0JOSHmDj5kmbN9GSwcqXRkbhXSsWJQ3VExknZdsUXJ4izazi5ERMnXxIUBLRs6f/DdRyqIzKeL+9Xx8SJ3IiJk69JmeckYnQk7sPJ4UTGCw4G8uVj4kR0AyZOviYsDDh+HDhwwOhI3IcVJyLv4Ku9nLhPHbkREydfU68eUKyYfw/XJSQAJhMQEGB0JES5m6/2cuI+deRGTJx8jdkM3HOPfydO8fE6TGcyGR0JUe7mq72cOFRHbsTEyReFhQGrV2sncX/EDX6JvIOvbvTLxInciImTLwoL0xPD5s1GR+IeCQmcGE7kDVhxIrqJ1egAKBsqVQKqVtXhurvuctthLlzQwtamTcD27fp9fLx+JSQAZcsCNWsCtWrp191360KcHGPFicg7+PLkcCZO5CZMnHxVWJgmTkOHuvRt7Xbg11+Bzz8H1q4FLBadj96wIdCkieYzwcE6bzsqCti7V/txRkYCBQsCjz4K9OwJ3HlnDqYoJSQwcSLyBr46OZyr6siNmDj5qrAwYMoU4PJl7bWSQ1evAtOmAZ9+Chw9CnTtCixcqFUkZ97+/Hlgzhxg+nRg4kSgRg3ggw+A++/PRgKVMjmciIxVvLgmIb42fM5VdeRGnOPkq9q21cnhf/2V47fasQMIDQVefx3o3Bn4919g1iygU6cbkiYRHa+LjQUcjuveo2hRoG9fHdbbvVsrTg8+CPTpo++XJRyqI/IOvtg9XIRDdeRWTJx8VeHCQKNGOWpL4HDokFyTJkC5csA//+j3lSolPyEuTstIjz2mk5iCgzVDKlAAsFqBQoX0xW++CSxbpmUr6FOnTgU2bgS2bQNq1wbeey8Lm6z72tUtkb9K2ejXlxKnq1d1zgETJ3ITDtX5srAw4LffsvXSpCSge3dgwQLgww+BV1/VFlEAgH37gFGjgHnzgMREoF07nbx0xx06I9xmAy5dAi5eBHbuBH7/HRg9GihSBOjXD3j5ZaBwYTRuDGzYAHz9NTB4MPDDD8CECUCrVrcIjhUnIu/gixWnmBi9ZeJEbsLEyZeFhelEotOngVKlnH6ZwwE88wywfDmwZg3QtGnyAzExwIgRwJdfAg0aAF98ATz0kFa3buXsWWDyZJ0k9fHHwBtvAG+8AYvVipde0rd59VWgdWudPP7RR9oAPV2cHE7kHYKCdJK1L62sY+JEbsahOl/WrJkOn61c6fRLRLQg9PPPOvk7NWnasgWoXh2YOVMnnW/YAPTqlZo0ORwOHDhwAMuWLcOiRYuwcuVKnDhxApKy2XDx4sBbb+nyuuHDtWJ1993AiRMAgDJlgB9/BBYtAv74Qw81bVoGexVzcjiR9/C1Xk4piRNX1ZGbMHHyZUFBQMuWWZrn9Mknuurtl1/0pQCAJUu0FNSkCXDwIPDUU4DZjMTERMyePRvtw8JQKH9+VK9eHe3bt0fnzp0RFhaGcuXKoXTx4ujerRv+/PNPTaJCQoDXXtPGT1eu6KzznTtTj9+pE7BnD/Dss8Bzz+lh9+27IUhWnIi8h6/1coqN1VtWnMhNmDj5urAwHXNLt3Rzvb17gSFDdJisY8fkO+fO1aV0Tz6p/12gAEQE06dPR4UyZdC9e3fEr16NwXFxWAbgCIATAA4CmAeg9/nz2D53Llq3bo26NWti7dq1+r633w6sX69NoDp21KZPyUJCdIRx2zadLlWvnrajSp5bzooTkTfxtV5OMTHaAyVvXqMjIT/FxMnXhYfrcNiBA5k+TQR4/nktKr3ySvKdO3dqwvTqq8D48YDFgjNnzqBzp054+umnEXb+PHYD+NPhwJsAwgFUAlAGwO0AHgAwEsBemw2rAOT/5x/cfffd6N+/PxITE/XENXcuULo00KGDtjJIo3ZtnWM1bhzw1VdAnTqaA3JyOJEX8cWhugIFuEk4uQ0TJ19Xt67Osr7FcN3PPwPr1mmSYjZDTy4PPaTDcqNHAyYTjh07hhZ33omIFSvwG4DvAdRyIgQTgDYA1tjt+FgE47/8Eg/cfz/i4+O1EdSiRdra4NVXb3qt2azDdgcO6O4x7doBj20fhNP24ln+URCRG/jaRr/s4URuxsTJ15nNwD33JJdqMvbpp8ATT2ieBRGgd2+dSzRyJGCxIDo6GmGtWyPp+HH8bbOhczZCsQB4DcAihwOrly/HY9266bynkiW1ovXddzp8l44SJfTh5cuBLTF3oPq01zFhwk19NonI03y14kTkJkyc/EF4uO7Ga7Ol+/D+/bpI7tlnk+8YP15nh8+Zk9oT4NV+/XAmMhIrbDbclsNwwgDMcTgw79dfMWnSJL2zUyedS/XSS5lmQ2FhwM47uqLfXZvRrx/QosV1c8uJyNN8LXGKjeWKOnIrJk7+ICxMTxabN6f78IwZQJUqQPPmACIidNXbBx9oOwMAixcvxrfffYfP7HZUdVFI9wPoDWDAq68iKmVi+Mcf64zwW2wTE5QYgxEdN2DHDp0j3rChbgdz5YqLgiMi55UocW2/Ol/AihO5GRMnf1CxIlC1arrDdSI6BNazJ2C6dFF3723XDhgwIPU57w4bhlZmM3q6OKxPAORJTMTnn3+ud1SrppvYzZqV+QuTJ4dXrw6sWqXbt0ybplu5LFzo4iCJKHO+1j2ciRO5GRMnfxEenu4E8RMn9KtduGi7cLtdS1DJ+6tERERgY0QE+jsccPUalAIAetntmDZ5MuLi4vTO7t2Bn37SrVwykmavOpNJ56/v369Tue67D+jSJbWvJhG5W8p+db4yQZyJE7kZEyd/ERYG/P03cPnydXfv2aO3Nf74Wve1mzNH95RLNmvWLJS2WrM1GdwZzwG4GBuLJUuW6B0PPghER+uQYUbSaUdQtKg2NP/rL22YWaOG7gxjt7spcCJSLq44XbkCHDqkMwuWLdNC+Z49afq45RQTJ3IzJk7+ok0bzSJumD+0dy9QoVQC8g99FRgzRofK0ti8YQNa2GywuCmsKgDKWK3YsmWL3lGunCZuu3dn/KJMOoe3bKlNyd98U7fDa9o08xyMiHIoTx6dbJ2DxGnrVuC993QXpkKFdGZBkyZA+/Y6c6B2bW37VrMm8PbbwK5dTvX0TV9MDCeHk1sxcfIXhQsDjRrdNM9p3/Z41Li4Abj33pv6KIkItm3bhlA3hxZqtyMiZeK6yaQz1Y8eTf/JIrfsHB4YCAwerLlX0aJ6Au7X79oWVUTkYtns5fTXXzrEHhoKTJ+u8xTnzNHf3RMntL3b5cu609NvvwEPPADMnq1tU+rV0zmNWU6gYmNZcSK3YuLkT26c5ySCpNXrEGK+qjOsb+ikGx8fj9i4OJRzc1jlRHD29Olrd2S2hYPNpu0KnOgcXqWKbrM3c6aejGvU0Ebl2b5SJaL0ZbElwbFjWklq1QoICNDmu4cOAV9/rX13a9XSjb+Dg7XSdPvtem03ahTwzz9aRW7QQOc0duiglXOncaiO3MxqdADkQmFheuY5fRooVQr47DMEnciLM3c+ChQudNPTHcn9lNy9MYEZgD3tZKS4uIz3kYqP11WCwcFOvbfJBHTrpifXwYN10WCnTrqFS6VKOQ6diIAsbfT722/a7SQuTqddpp0dICKIjIxEREQEDh48iPj4eOTJkweVK1dGaGgoqlSpArPZjIYNdQ3Liy9qobxRI61E3X+/EwEwcSI3Y+LkT5o104RjxQqdRPDGGwi6exPiTYXSfXpQUBCsFgsuuHmG9QUABQqlieHSJaBgwfSffPkyEBmpOwFnQaFC2tfzqaeAPn30inb4cD3pBgRkL24iSubEUJ3NBgwbpknTwIE6pymlcHz69GlMnjwZ48dPxKlTxwAAVmthmEwhEImHzXYeAFC0aEk899wz6NOnDypWrIgmTXQ/y4EDdV3JF19oD91Mg4iLY+JEbsWhOn+SJ4/Ovly4EHjkEeB//0NQ0/pI6QRwI4vFgtrVq2O7m8PaFhCAeg0bXrvj/PmME6eLF/U2baKVBXfeCWzZAowYoYlTaKhe9RJRDtxiqO7MGR2a++IL4IcfgI8+0qTJZrPhgw8+QIUKFfHOO6Nw6lR7AAsBnILNdgFJScdhs50DcBbAUpw//wjGjBmH226rjNdffx3x8fGwWIDPPtNto155BRg7NpM4Y2P1lokTuRETJ3/Tti0wf76WWaZMQZWqJhw4kPG8n9A778RGq/sKjxcBHEhKQmho8hT0kye1opQ2kUrrn3+0x1SZMtk+ZkCAXqHu3avDdc2bA88/r10QiCgbMqk4rVunv86nTmmLge7d9f6oqCg0bnwXhgx5G0lJ/eFwnAQwCcC9AErd8C7FALQD8CXs9hMQGYlPPvkCdeo0wN7kCU79+mkC1b8/8McfGcSZskKEq+rIjZg4+ZuTJ3U5/5gxQMGCCA3VIs6hQ+k/vXPnzthts2Grm8L5HoDZbEb79u31jtWr9VL0hrYIqTZturY2OYcqVgR+/VUnjC9cCFSvrk3LOXmcKIvSqTiJaCLTurXuKblpk7YTAIDDhw/jzjtbYPfucxD5G8CHAAo5ebB8AN6Cw7ENR45Y0axZS+zYsQOAVpy6ddMNyy9cSOelrDiRBzBx8idr1+qs6Hz5NIECUKeOjoqtXp3+Szp37ozypUtjnBvCcQAYb7XiwQcfRJmUCtLSpXqWzajdwKZN2l/ARUwmnRuxbx/w2GN6wm3fHvj3X5cdgsj/FS+uSUl8PAAt7DzyiO4h+cknOnE7pchz6dIltG3bDmfP5oHNtg5Adn+fa8Ju/wuXL9+Gtm3b4dSpUzCZdC6jw6HDgTdJqTgxcSI3YuLkL86e1Uuxhx/W2dFbtYZktWpvzEWL0n+Z1WpFvwEDMN1kwiYXhzQewD6bDf1fe03vOHlS+wY8/nj6L3A4tNbftKmLI9GT+mef6dtHR2tRa+RI39m3lMhQKduunD2L3buBxo117uCff2oVKG2nkwEDBuL48TOw2ZYCyP6QuyoMu/13xMSY8OyzfSAiKFBAG+B+9ZVOl7wOh+rIE4R8n90u0r69yO23i1y6JPL99yJBQSJXroiIyLx5ImazyKFD6b88KSlJQuvVkxoWi8RpBT7HX/8CEmI2S98XXrh2oNdeE6lYUSQxMf1A1qzR1+/f79Ifz41sNpEvvxTJn1+kenWRP/5w6+GIfN+xYyKAfP/eYQkJEbnnHpEzZ25+2qpVqwSAABNccRpJ8zVfAMisWbNERCQuTqRkSZEhQ24IYM4cPfcRuRETJ3/w/vsiefKIbNum3587J2K1agIlmijcfrvIyy9n/Ba7du2S4Dx5pLPZLPE5PMudBKSq1SpVK1WS2NhYPUBUlEjevCLjxmUcxOOPi7Ro4ZqfiROOHxd5+GENu2dPkbNnPXZoIp8SfyleXsA4ATRZsdnSf16HDp3EYmkggMPFiZOI2dxR6tZtKA6HQ0RE3nlHpEqVGwKYNEmkRAm3/iyImDj5uj//1HLSN99cf3/PniJ164okn2QmTBAJCRE5fz7jt1qyZInkCQiQe8xmOZXNs9tWQCpbrVKuVCk5lFListlE7rtPpE4dkfj49A9+9qxIYGBqsudJixZpIaxoUZFp01J/ZEQkIkePijRuLFIYF2ThayszfN6hQ4fEZDIJMMXlSZN+LRIAsmHDBhER+ftvvf/w4TRBfPJJOtkUkWtxjpMv++8/ndfUrRvw7LPXP/b668DOncDvvwPQxpAFCujGuBlp3749fl+6FLsKFUJNiwXfAnC2NeYVAO8AaGIyId8dd2Dthg2oXLmyPvj++xrLDz9kPCl82jSdl9Cli5NHdJ1OnXR39l699MfYpg2wf7/HwyDyOkuWaKsBux2IqPAg7i27PcPn/vbbbzCZAgF0c1M07WG1lsT8+fMBaDfxggVv2J6T+9SRBzBx8lV2uy4RK1AA+Oabm/ahQ40aumPmhx8C0IbiU6YAkyfr8vyMtGnTBnsOHED7hx9GDwCVrVaMArAVQOINz70MYA2AfgDKWCwYZbFg8NCh2LxtGypWrKhPWrVKO1EOHaozstNz7py2T+jTx6k96twhb15g9GidU5+YqJuMDh0KXL1qSDhEhrLb9de2Uyddb7JuHXBb2cRMu4dHRETAbK4HIGtd/51ngd3eBJs3RwDQhS9NmgDbt6d5CrdbIU8wuuRF2fTuuzoJcufOjJ+zaZPWspMnVIqI9OsnUriwzvW8lU2bNsnTPXtKUGCgAJBAk0mqBQRInYAAqRwQICZAAEjxwoXlrbfekqNHj17/BqdO6QzOJ5/MfPyrZ08dK7t8+dZBeYDdriOfhQpp1X/ZMqMjIvKcs2dF2rXT08v06WkeuP9+kWeeyfB11avXEeB5Nw3TpXy9I4ULF089ZvfuIt26pQmid2+dFkDkRiYREaOTN8qi1at1Q9+JE3V8KTMDB2qZaedOoEIFxMfran+rVVsqFSt268PFxcVh+/btiIiIQGRkJBITExEcHIxq1aohNDQUNWvWRMCNG8LZ7UB4uG44vHlzxg0tV60C7rkHWLwY6NjRuc/vIWfOAAMGADNnajfkTz/VvZOJ/NXGjbpRdp48WpmuWzfNg717a8VpwYJ0X1u6dAWcPt0DwHtujHAcrNb+SErS+veLL2pPtqVLkx9+9FHdOuD7790YA+V23OTX15w+rX/FH38ceOaZWz///fd109+nngJWrkRQkAW//aY5TatWwLJlQNmymb9FSEgImjVrhmbNmjkf57vv6ll406aMk6aLF4HnntM5Wl6WNAFAyZJ6/u3RA+jbV0c/P/xQ50GZOchNfkREG0v27w/cey8wfXo620mWKAHs3p3he5hMJmgR2p0cMJmu/fKFhOi+4KkuXQJS5lYSuQlP/77Ebtf210WKAF9/ffO8pvTkyaOTsjduBN55BwBQoQLw1196YdaypRu6aC9frlujjx8P1KqV/nMSE3UiuM2mO4N6sfBwYNcu4OWX9atFC/2eyB9cvqzXYf36AaNGAb/8ksEe3LfdplcTGShevDiAU26LU51CoUJFU787d06bmqe6ePGGO4hcj4mTL0mp4vz0U9b2cqtZE5g6FfjgA02eRFCypG6UWaYM0KCB5mEOhwtiPHlSz8I9euhXemw2rYBFROgQXUpXYi8WFKQ//p07gcBA/Zm9/jpw5YrRkRFl3/79OnS/erWOmg8cmMn1WKFCuko3gxNFkyYNYLVGuC1WADCbI9CkybUNwg8f1j0pU50+rReWRG7ExMlXOFPFyUz37jruNHIkMGQIIIJChfSE+frrmou1bg0kb0SePTabHqdECWBcBrvfxcdrQrVwoSZNKbuC+ojq1fVnNmWK5qK1aulHIfI1P/6oW6cUK6arSe+++xYvqFQJSEoCjh1L9+FGjRrBbt8DINrVoSZLgMm0GY0bNwKgBfhdu9KcQi5cAKKi9JeUyJ2Mnp1OTjhxQqR4cZGnn875e/34o4jFIvLCC9c1o9y9W6R5c5GAAJHBg3VLAxGRc+fOydSpU+Xxxx+XGjVqSEhIiAQGBkrZsmXlf//7n/zyyy/X3nvwYO0Ovndv+sc+dEikYUNd1vfnnzn/LAY7e1b/lwAiXbpoJ3Iib5eQoKtrAZFBg0SSkpx8YWKi7lM0ZUq6D586dUqs1gABPnPTirofBIDsTT6/rFql9x85khzA/Pl6bouJyemPiChTTJy8XVKSSKtWIrVrp+49l2O//aZr7evX14wpmd2uOxYULixSubLIkiUiVqtVkNx2AIAEBQVJ3rx5r7uvY8eOcmXePD2Lffdd+secN0+kYEGRJk20FbEf+fNPkRo19G/KF19kvB0FkdGOHRO56y6RAgVE0l7zOO1//xPp2jXDhx99tJtYrVUFSHRx0uQQi+VOufvuNqnHev55PZ2kevVVkaZNs/GhiLKGiZO3GzJEqzj79rn2fSMjNSELCBAZOlQkZU850c07n3wy5YQFadCgiYwfP/7aFioicuTIEenVq1dq8vREYKD2ULnR3r0ijz6qb9avn17u+qGEBJGRI7X3TWioyJYtRkdEdL0VK7RwXbeuyMGD2XyT8eP1yiqDMtW2bdvEbLYIMMLFidM3AkCWL18uItryrVgx3WFFRLRPXM2aIq+/ns0PRuQ8Jk7ebMkSEZPJffu3pXR6LFhQvwYN0s14k61cKVK27CopWFDPl3b7zW/R59lnU5OnqLRn44MHRZ54QvfRa9hQP0su8O+/2jzQbNY8kaMGZDS7XZN6s1mkR48cFq4jI3U47KefMnzKkCFDxGSyCrDJRUnTP2Kx5Jdeva5dmA0dKlKkSJq9N5cu1Sfv2ZODD0fkHCZO3urYMb2kevZZ9x/r0iWRTz/V7t0Wi1aIvv9e5NgxuXpVdyEPDNQq+Pbt179001NPpSZOv3z5pcjo0TpZymzWTX3nzct1u+Y6HNqsvWRJkbJlRebOzXU/AvISFy6I3HuvSJ48IhMnuujf4VNPadkqvSspEYmPj5dGjZqKxVJMgJ05TJoOi9VaSapUqSYXL14UER3pDwoSGTs2zUHDwkQ6d3bBhyO6NXYO90Y2m+40GxMDbNigG8156rjz5+ved2vX6gq4ypWBu+/GuXyVMHtJIUQcKoS77y+Ebo84ELx+JXaNG4eU5sI/AXi4dGngvvt0n7z27XN1p8iLF4G33tIf5733Al99dcPSaSI3iojQfeYA4OefgdBQF73xwYPaDfbnn4EHH0z3KefPn0ebNmHYu/co7PZvADySjQMthdX6NMqWDcGaNatRvnx5JCVpr9xTp4AdO3QHBGzdqh/uzz+dWBpI5AJGZ26UjjfeEMmXT+TAAeNiiI8XWbtW5P33RTp2FGnQQByVKkl8SCGxwyRJsMhVU5B8mWai+P6ffsrwKjQ3+/tvvUAPCREZM0YXJxG5i8Oh1aU8ebTalDqc5UqPPy5SvXqm437R0dHy4INdBICYTA8LsMfpKhPwjACQNm3C5NSpU6mfq2dPndi+a1fyQRISdCpAq1Ys65LHMHHyNgsX6tkjzca83ub8yXh5tvg8AaIlKE9pASAtW7Y0Oiyvlpgo8tFHmjzVravJFJGrXbmi85jMZr3mcdt1jJMtUhwOh8yePVuKFi0pAMRiaSPAFwKsFSBagHgBLgmwUYDxYjZ3EsAk+fMXkgkTJogjORlyOETeekvEatVJ7qnefFMzqdSeBETux8TJm0RG6ozH5583OpLMDRgg9nz5pFmDsORqU5AMGrTD+X4wudjRozoVw2TS/83R0UZHRP7in380KS9e/Ibkwl2WLdN/yNOn3/KpCQkJMmvWLGnZsrUEBOS5rp1JypfFYpVGje6UKVOmyJU0lazLl0VefFEXAP/wQ5o3Xb1aj59RCxQiN+EcJ2+RlKS77sbHA+vX6x4f3mjBAuB//8PLHTrgqyVLAAAPPTQFixc/gxo1dD5P48YGx+jlRIB584BXXtFpZZ99pvscO7P1IFF65s/Xhvy1amlH8HLlPHTgYcOAjz8Glixxen5RUlIS9uzZg4MHDyI+Ph6BgYGoUqUK6tSpg6Abznv79+uWliLAxIm6TyQAYNs2oG1boHNn4Ntv+ctDnmV05kbJBgzQDor//GN0JBk7ckSkUCEZUL9+6lXiZ599JiLaFLxDB70AfOklXahHmYuJ0ZYFZrO2MPj3X6MjIl+TlKRdRAxrk2azadO34GCRxYtd+tY//qhTPVu2FDl5Ms0Df/+tlfnOnf22Lxx5NyZO3uDXX/XMl0lvFMMlJIg0aSKDSpZMTZo+/vjj657icIjMmSNSqpRImTL6cThf89a2bNGmmUFB2m+HfwvIGSdPitx9tyYXc+YYGIjdruPOFov2CMjhL31iojYBB0QGDkyzmMLhEJkxQ5O0rl2v2zKKyJOYOBktuYojL71kdCSZ69dPBgYGpiZNY8aMyfCp0dEifftq9alTJ87bdIbNJvLll1p0rFHDL7byIzf680+9QKlZ0/WbCmSLw6FtvC0WXeGWzUaUx4+LNGumvwdz56Z5IDJSS9pms84S575GZCAmTkZKruJIo0beffX0yy8yIM0kzsySprQ2bBCpV08vED/8kMvwnXH8uG4YDOiCpbNnjY6IvInDoaszLRaR7t2v2ynJO+zYoZmP1arbn5w54/RLU7aEqVMnTSeWM2e0DJsvnz6webN74ibKAiZORnr1Vd3q5PBhoyPJ2KFDMiBNpenG4blbSUrSC9G8eXWf4nXr3BSnn1m4UBu5Fy2qi5Y45EkXL4o8+KCuLvvqKy/+N2G3i0yZolmQ1aobA8+bl3rltHLlSunWrZtUqlRJ8uTJI3ny5JFChSoI0EXatv1NrkQniPzxh2aGAQH6Pu+/zzFs8hpMnIzyyy9aVsjWFuUeEh9/3ZymTz/9NNtvFRmp509A5LnndCsIytzly3rRbrGItG7tJUMyZIgdO0SqVhUpX14ruT4hPl7k5591ErfFIo6gIOlbvPh1LQiCAgIkwBx43X3dzGaxATor/IcfvLsaT7kSEycjHDqklaZ+/YyOJFORPXqknszMZrOULFky06+PPvrolu85b55IuXIiJUrodnhee9XsRXbsELnzTr34HjpU5OpVoyMiT5o+XYe727Xz4aHbkydlWp8+qeeTB4ODZU9QiFxFoFwyFZADRUrIM6VKXVutO3So0RETZSj3biRmlIQE4JFHgGrVgDFjjI4mYz/9BMeMGanfOhwOnDlzJtOvy5cv3/JtH3gA2LsXePxx4KmngHbtgH/+cePn8AN16wLr1gFjx+pXnTrAihVGR0XuFh8PPPcc8PTTwOuvA4sXA8WKGR1VNpUujW8PHgQAVKlSBe0+vYSGcgVdOiXAdu4S7jh/BpNPnkSL5EZNc5YvNzJaokwxcfK0gQOBQ4eAOXOAwECjo0nfv/8CvXqh0oABEK1KOvU1fPhwp94+f37g00+BLVuAS5c0EXj3Xc0pKX1mM9CnjzYEbNIECA/X5PPMGaMjI3c4cgRo3hyYO1cTpuHDAYvF6Khy5uTJkwAAm60e+vYNwNChwG+/AUWK6OMmkwmNk7vnOnMRRmQUJk6e9NNPwFdfATNmAJUqGR1N+uLjga5dtQXxBx+49VANGgB//w188ok2H65XD/jjD7ce0ueVLAnMnAksWwZs2gRUr64dlR0OoyMjV1m0CGjYUBOlrVuBDh2Mjsg1SpWqDAA4dmwHFi9OwpAhekGQ1ubNmwEAjRo18nR4RE5j4uQpyVUcDBgA3H+/0dFkrH9/ICpKK2IBAW4/nMUCvPiiVlLq1gXatAF69gTOnXP7oX1aeDiwcyfw8svASy8BLVsCu3YZHRXlhN0ODBmiu4g89hiwZg1QsaLRUbnG/PnApk0vAgAcjkOYOPFRHDhwIPXxyMhI9OrVC2vXrkXx4sWdrl4TGcKguVW5y9WrIvXri9x1l3c3M/rhB132tnChYSEsWiRSqZLuqDBlCiePO2PvXu0gndI65/JloyOirDpzRuSee0RCQnTRhL9IStJ/k4DIK6+IfPbZWAlM094kKChIQkJCBIDkzZtXnnrqKYmMjDQ6bKJMseLkCa+95tEqTrYcPKgzUV9/Hbj3XsPC6NQJ2LNHQ+nTR/c93rvXsHB8Qo0aOsQ5aRIwZYqOsi5aZHRU5Kz163Vo7tgxYONGnbvmD06fBsLCgHHjgNmzgS++AF599SXMnz8fJUuWBADEx8cjLi4OAJCYmIjY2FhcuHDByLCJbomJk7vNmQN8/TXw3XdA+fJGR5O+q1d1XlO9esDIkUZHg5AQnV61bZsOX9SvD7z9toZJ6TOZdIhz//5rm8Z37Qokz8clLySiyUSrVsBddwGbNwO1axsdlWusWaNzGP/7Tz/Xo48CcXFxePTRR9GpUyeUKVMGv//+O86cOYPo6Gj8+eefaNmyJebNm4fmzZtjBZeNkjczuuTl1w4c0K0C3njD6Egy9+yzIsWKiRw7ZnQkN7HbRSZO1O38qlQRWbrU6Ih8wx9/iFSvrnt+ffklt/byNjExIo88osOrn33mP0PSmW0J07dvXwEg9evXl/h0mlo6HA7p2LGjAJDKlStLAjuFk5di4uQucXEideuKNG+uA/3e6vvvdQLC778bHUmmzpwReeIJDbVbN5FTp4yOyPvFx4u8955Injy6HWJEhNERkYjI7t0i1aqJlCkjsnat0dG4zsWLIg89pI1ax469PhmMiYkRq9UqAGTSpEkZvsfy5ctT5z9t3LjRA1ETZR2H6tylXz8dJ5k9G7BajY4mffv360SiwYO9fs1ziRI62rl8ORARocvwv/6ay/AzkyePDnHu3g0ULgw0bgy8+ioQG2t0ZLnXDz9oH64yZbTVQPPmRkfkGjt3Ao0aaYuMv/7SlZ4m07XHDx48CJvNBgComMlSwbSPHTlyxG3xEuUEEyd3mDlTZ+p+9x1QrpzR0aQvLk4nwTRqBIwYYXQ0TgsL05N0v36aBDRvrt9TxqpWBZYuBb7/Hpg1SyeT//KLzrEhz0hI0GTi8cf13+6yZdqTyx98+y1w553AbbdpMnjnnTc/x5Kme+epU6cyfK8TJ06k/neBAgVcGieRqzBxcjVfqeK89JK2nf7hB++tiGUgKEhzvZ079b8bNgQGDQKuXDE6Mu9lMgHdu+s/z86dgS5dgP/9D4iMNDoy/xcVBdx9tyauCxYAo0b53K9cuuLj9VTXs6f+/v3+O1C8ePrPrV69OkJCQgAAEydOhN1uT/d548ePB6CJVpMmTdwRNlHOGT1W6FeuXBGpXVukVSvvntc0fbqIySSybJnRkeSYwyEyY4bOba9QQWTBAqMj8g3r14vUqaN9gz76yLvbi/mypUtFihYVadBA9/b2F4cPi4SGar+1xYude02/fv1S5y+Fh4fLtm3bxGazicPhkAMHDsgjjzyS+nivXr3c+wGIcoCJkys9/bRI8eIiJ04YHUnGdu/Wrdb9bPfxc+dEnnlGJ48/+KBXLhD0OomJImPGaPJUt67I338bHZH/sNtFRozQ65NevXStiL9YuFCkcGFdcHDkiPOvu3r1qnTq1Ck1OQIggYGBEhQUdN19YWFhcuXKFbfFT5RTTJxcJaWKs3y50ZFkLDZWpEYNkTZt/HZ9+l9/6UfMl0+XeXtz4c9bHDkicu+9+s/3+edFoqONjsi3nTsn0qGDSFCQyNSpRkfjOjabyJAhenHy/PO6ajM75s6dKw899JCUL19e8uTJI4GBgVKmTBm57777ZPbs2eLwl94M5LdMIpwimmN79uiSpUGDvHeitQjQo4fOSt2+HShVyuiI3CYxUTcNfu89oGZN4JtvdA48ZUxEJ4y/8oo2Hf38c21amHZlFN3a5s3Aww/rHKa5c7V5qz84e1bnyK1fr79PTz5pdERExuHk8Jy6cgV45BFt/TtsmNHRZGzaNF3t98MPfp00AUBgoM7N371bJ6s2baoJQUyM0ZF5L5NJJ4zv26cJ0+OP69qGQ4eMjsw3iGh7jBYtNFmKiPCfpOnvv7ULeFSUbgnDpIlyOyZOOSEC9O0LnD+vSUmaJbdeZdcu4MUXgXfe0f04cokqVXSlz8yZwI8/6jL8n3/mMvzMFCig24Bs2gScO6dbgLz/vlbxKH1XrgBPPaULVd99F5g3DyhUyOiock4E+PJLXRHYtCmwZQtQp47RUREZj0N1OTF1KvDss8CKFUCbNkZHk77YWB1GLF8eWLLEe5M7N7t4UatQEyYAHTvqxqOVKhkdlXez2fTn9Pbb+s9nwgT9I0rXHDiglbpz57TXbevWRkfkGrGxQO/eOtw4ZgzQvz+HbYlSsOKUXWmrON6aNIkAzz+vY1TeXBHzgEKFgPHjddjhxAmd+zRmDJCUZHRk3stq1WaN+/Zpta5VK+CZZ7TASlq9bNxYu7Jv3eo/SdPevdrdfM0aYPVq4LXXmDQRpcXEKTtiY7XrdosWwJAhRkeTsUmT9DJ41izds4RShxzee0/n8YeGajJFGStXTisPv/0GrFyp293MmJF7hzyTkjSZ6NoVeO45YNUq3ULFH8yapUlTqVKaDLZsaXRERN6HiVNW+UoVZ/t2nRH93ntaKqBUViswYIBeWVeqBDRrph2Qo6ONjsy7de6sP7OnnwZ69dLpcvv3Gx2VZ504oQXmyZO14vTxx0BAgNFR5VxiIvDyy8Bjj+lcreXL/X4NCVG2cY5TVk2cCLzwgl5memtCEhOjpZQqVYDFiwEz8+OMiADz5+sfjaQk4LPPdNk1hyYyt2OHXj9s3Qq88YbOHwsKMjoq91q1Sv9tlCihFbg77jA6Itc4dkyrZ/v3675z999vdERE3o1/UbPCF6o4Ijph/epV3WSYSVOmTCbgwQd1Hs9jj+lS63btgH//NToy71avHrBuna7A+/JLXW21YoXRUbmHwwF88AEQHg60bw9s2OA/SdOyZdpqICFBWygwaSK6Nf5VdVZMjF6WtWkDvPmm0dFkbMIEvRyePTvjHTfpJvnza7Vp82ZdgVe7tubHCQlGR+a9zGatOu3fr5Okw8OBJ54A/vvP6MhcJzpaN0MePlwXF8yYAeTNa3RUOedwaOuEDh2ABx7QxpZVqhgdFZFv4FCdM0S0Rr92rVadihUzOqL/t3fnYVGW6x/AvzPDIiqIuz+X0szIAHO3rJRyqdxSy0rL3eq0eFq1UjNKj9miV6fSo5Wi5lJaekyTJE0zL8MNRWXJI27hCgIqMArD3L8/bhBN0FFnmOGd7+e65jKGYd57iHnnfu/nee6nZHFx2ojz/fd1/ISuS0GBfkiOHQvUq6e5qKcWGD1JTExxW7MPP9Tl7OW54Lljh7YasNt1PpNRus+fOqWV1XXrtN3EsGHujoiofCnHp7UyNGOGnjm/+85zk6bTp7Ui1rmzbv1C181i0TlPSUlaeYqI0AnR6enujsyzde1a3KXjpZd0Rdbu3e6O6vrMmqXXILffrkNYRkmatm4FWrbU/lObNjFpIroeTJyuJi4OeOUVYNIk4J573B1NyUR0mVN+vs7uLM+X+R6kXj1gyRLgp5+A9ev1QzQqynuX4TsiIACYOFEnj/v46If0W28BubnujswxVqsmE888oxXHlSuB6tXdHdWNE9Hrv4u3hGnRwt1REZVPHKq7ktOn9czftCnw44+em5B8/rk2ltmwQS+Tyelyc3UEdMoUbV8wY4b+WVDpRIA5c7QAGhiow0Ldurk7qtLt26cb9Kamaj+jLl3cHZFz5OToXLSFC/X6b9Qozz2VEZUHfPuU5uIqzty5nnum2bpVmxJNnsykyYUqVtRfcVyc/knceSfwzjtaoaCSmUw6xJmcrMOd3bvraPLRo+6O7HLLl+twXIUKOrfJKEnT3r3AXXfp/LM1a3Tqo6eeyojKC76FSvPFF3o2/e47z63VZ2YCjz+um6+99pq7o/EK4eG6RuCLL/QWHq7NAql0NWroEOe6dTrn6fbb9XdXUODuyHQ/vjff1JVlgwZp0bZBA3dH5Rw//KDJYJUqmgx66s5QROUNE6eSlIcqjohezheNh7BjY5kxm3WrjeRkvZrv2lV7QB0/7u7IPFtEhM59GjUKeOMN/d3FxbkvnuPHtbI0bZoOzX32GeDn5754nCU/X09fjz2mc7XWrTPOljBEnoCJ09+VlyrOp59qV/DFi3WXUSpztWsD8+drxWnrVq2kzJihy9epZP7+OsS5e7duvNymDfDqq7r9Y1n6/Xedvnj8OLBlC/Dkk2V7fFc5elS3wvnqK13YMGWKMbaEIfIkTJwuVl6qOJs3A6NHAx99pDtyklt17qyJwMsva2P5e+8Fdu1yd1SerUkTnXfzzTc6afmOO3TrG1cT0WTi/vuBDh00abrjDtcftyysX68r5bKydCPrxx5zd0RExsTE6WLloYqTkaEVsZ499ZOaPEKFCsB772nC5Oen1YzRo3VFE5XMZNIhzuRknTjep4926T582DXHO31ak4m33tIu8YsW6Wq/8s5u11kFnTrpsLGRtoQh8kRsR1Bk82YtFXzyiecmJCL6ybJnj04OCQ52d0RUAhFtp/X660DlyjoRukcPd0fl+TZtAp57DjhwQJPQl1/WXlDOsHu3dgHPzdUhLE+dunitMjOBwYOB1at138DnnvPcQjmRUbDiBBRXcXr10rEWTzVlip4hFy9m0uTBTCb9MPvzT60C9OypH9qpqe6OzLO1b6/XA+PH6zyo1q31euZGffMN0K4dcPPNurrMKEnTjh1Aq1Y64X7jRu3VxKSJyPWYOIkAQ4boPhuzZnnumWfTJh1jmDLFOPs/GFz16von9dtvun1L06a6cssTluF7Kl9fHeJMTATq19ck54UXdN7OtTp3TpOJQYO0+vfzz8bZ97poS5iQEE0227Rxd0RE3oNDdZ98onsrbNqkl2+eKD1dZ33efbf2lfLU5I5KlZcHfPyxbkcSGgrMnOm5f26eQgRYulSLwHa7TkF8/HHH/vwPHtT5TPv3a8Wpe3dXR1s2rFbdBzAqSoczx45lQ0uisubdb7mLqzie+ilmt+sls7+/rjFm0lQu+fnph9yePVqJattW5/CcOePuyDyXyaRDnElJ2nG8f3/tErJ//5V/btUqnZwPaDXGKElTSooOZy5frtWzd95h0kTkDt77tktPB554AujbV7dz91QffQT8+qvOaK1Sxd3R0A1q3Fg/9BYs0OJh06ba4dnL675XFBSkQ5xbtgBpaVqxmzRJq3gXKyjQ+VHdu2tlauNGoGFDt4TsdMuX67Wdv78mg127ujsiIu/lnYlTeani/P47MG6cjlFwK3PDMJm04WJysq5H6NdPJ5AfPOjuyDxb0WTxyZOBDz7Qt8Tvv+v30tK0GvXJJ7q15IwZ2iKivLPZtCjeuzcwcKBuCXPTTe6Oisi7eeccp8mTgchI4I8/PDchOXlSY+vQQTsEempyRzcsNlaXke/bp3+Wr7zCbs9Xk5qqc5+WLdNWD9u3A5UqafWuWTN3R+ccJ05ogr1lC/D11zpUSUTu532J0++/a9vgL77QJTeeyG7Xy+cDB/QTwQhd+uiK8vO1D8+77+pw3syZxlk27yoimnB+9ZXOITNSH6ONG3W4sUoVTQaN0t2cyAi8a6ju5Em9hOvXT8+wnuqDD7Qmv2QJkyYv4eurG98mJuq8nHvu0bw+M9PdkXmm7GytwMyeDfzrX8DIkbrarFMn7Z9VXokAU6fqhshG2xKGyCi8p+JUVMU5eFA3cvLUhGT9ej37z5ihW5uT1xHRfdtGjtRK1Kefar5vhEqKMyQm6mq7rCydYN+hg94fH6/XQzt26Lygt98uX/OczpwBhg3TieBTp2oiyP/nRJ7HeypO5aGKc+KEXkb37w+MGOHuaMhNTCbdty0pSf8Unn4aePBBnQPl7b79Vls51KqlCVJR0gQAd96pHUb+/W+9NWsGrF3rvlivxe7dOvk9NlZPUyNHMmki8lTekTitX6/rlD//3HNnjhYUAE89pVupzJjBsyYhMFCrTVu26K5AYWHaQPP8eXdHVvby8jSZ6N9fu4esXQvUqXP548xmHeJMTtbl+50762q0kyfLPmZHGXVLGCKjMv5Q3YkTQPPmegadN89zE5L33gM+/FA/JcPC3B0NeZiCAmD6dG2iWa+e5tYdO7o7qrLx1186UToxUVsN9O7t+M+uXq1btoSEAAMG6LWJp5wCzp/XFZQzZmjXkchI3fmJiDybsStOF1dx/vMfzzlj/t3atZo4TZvGpIlKZLFoxSUpSf9EIiKAoUO1j6uR/fKLdgHPzdUFpteSNAE6xLlnjxaaBw/W5MkTKnYHDwL33qtztFauBCZMYNJEVF4Yu+J0lSrOkSNHsG3bNuzcuRMZGRkAgGrVqqF58+Zo3bo16tWr5/oYjx3TitjDDwNz5rj+eGQIP/2kQ1bZ2dr0cfBgz70uuB52u66We/ddfW3TpgEVK97Yc27cqA1H27TRPfAqVXJOrNcqOlrnrTVqBHz/vXG6mxN5DTGqNWtETCaR2bMvudtqtcrcuXOlXatWAkAASE0fHwnz9ZUwX1+p6eNz4f52rVrJ3LlzxWq1uibG/HyRiAiRO+4Qyc52zTHIsLKzRUaPFrFYRDp2FElKcndEzpGeLvLwwyL+/iJffSVitzvvuXftEqldW6R9e5HMTOc9ryNsNpF33tHT0nPPibjqtEJErmXMilMpVZx169Zh+ODBOPDXX+hqNmO43Y72AOoBKLpYFwBHAGwCMMtsRozdjkYNGmD2vHmIiIhwbpzjx+sGw1u3slkLXbfdu3UZ/rZtwJtvAmPGAAEB7o7q+sTHaz+rlBStxhRt1lvk7Nmz2LFjB5KTk2G1WuHr64uGDRuiVatWqF27tkPH2LdPpzw2agSsWVM2Q2Tp6TpMuHGjzmkaNMj1xyQiF3F35uZ0NpvI0KGXVHEKCgrktVdfFQDSwWyWJG2V49AtsfBnAMjrr70mBQUFzolz9Wq99Jw71znPR16toEBk5kyR4GCRxo1FYmLcHdG1i4kRqVhR5PHHRTIyiu/PycmRWbNmSYsWbcRkMhVWhM1iNgeIyVRcIW7QoJFMmDBBjh07dtVj7dkjUqGCyKRJLnxBhf74Q6R+fZFbbxWJj3f98YjItYyXOH30kZ4Rd+8WEU2aBg0cKGaTSaYCUnANSVPRrQCQKYCYABk8aNCNJ09HjojUrCkybJgTXjBRsePHRQYM0D/dAQP06/Jg506RypX1LWGz6X12u12++eYbCQ6uLoBJzObuAswWYJcA+YVvT7sABwRYIsAIMZsrio+Pr4wZM0bOnTt3xWNOmybi4yOyZYtrXpPdLvL55yK+viJ9+ohkZbnmOERUtoyVOKWl6SXrxx9fuGvMmDFiAmThdSRMf78tKEyexo4de/0x5ueL3HefSFiYSE6OE1400eViYrTCERwsMmOGVqQ81V9/idSrp/Oa8vP1vqysLOnRo5cAEJNpgAD7HXybZgoQKSaTr4SEhEpCQkKpx7XbRXr2FGnSpPi4znL2rMiTT+r8s08+ce48LSJyL2MlTuPGidSpI5KbKyIisbGxYjaZZKITkqai20RAzCaTbN68+fpifPttkUqVjDOTlzxWbq5ORvb1Fbn7bp0Y7WnsdpGuXUWaNRM5c0bvO3XqlISHtxCLJViAZdf5Vo0XiyVUqlSpJnFxcaUe/6+/tOq0aJHzXlNiokjTpnoq+u035z0vEXkG4yROWVkiVapcqDYVFBRIaEiItLFYJN+JiVM+IK0tFgkNCbn2IbtVq/R5Fixw/usnKkVioq66s1hERo3yrAWcK1boW6LoOiQvL0/atWsvFkt1AeJv8O2aIRZLa6lataYcOnSo1BgGDRJp2dI5VaFFi/S6qEMHEQemWhFROWScxGnhQl2/XHjZumrVKgEgm5yYNBXdNkEno0ZHRzse3+HDItWrizz7rIt+AUSls9tFoqL0T/Dmm0VWrnR3RCLnz4vcdpvIwIHF902YMEFMJosAfzjp7ZomPj71pHPnrmIvJTOKj9fH/vrrjb2WkSP1eUaPdv7QHxF5DuO0I3jmGWD//gu7evbs3h1HV6/GtoICOLsvoABo5eODel27YsVPP139B/LztdVzTg7wxx/ld604lXvp6cDo0UBUFPDoo7oZbln0eS3Jjz/qZsaHDgH16wNJSUlo1uxO2GyjAUx04pGiAXRDVFQUhgwZUuIjOnfWjYMXLrz2Z09NBfr1u74tYYio/DHOliu//go88AAAIC8vDzExMRjogqQJ0J5Pg2w2xMTEIC8v7+o/MHasNttZsoRJE7lVjRrA7Nm673VCAtC0KfDZZ7o7UVlbvFjfsvXr69dTpkwFUBvAO04+0sMA+mLixMko7TqxVy/t6WS3X9szr1kDtGhx/VvCEFH5Y4zE6fRprTbddRcAYM+ePciz2dDOhYdsCyDPZkNCQsKVH7hyJfDxx8DXXwNNmrgwIiLHdewI7Nyp1afRo4F27fSDv6xYrcDy5bp5LwBkZWVh/vwFsNn+AcDfBUf8J1JS/sS6detK/G6nTkBamu4F6Ai7HZg4EejaFejRQwvJt97qxHCJyGMZJ3ECgOrVAQC7du0CANzpwkM2L/w3Pj6+9AcdPqwtgl94ofgTgshD+PsD48bpJrjVqgFt2wKvvAKcPev6Y2/ZovvsPfKIfv3zzz/j/HkrgKEuOmIH+Pjciu+//77E795+u+5d50jymJEB9OypidOXX2oF70b30SOi8sNYiVOVKgCAM2fOoILZDFeeyyoCqGA248yZMyU/IC8PeOIJ3ddh6lQXRkJ0Y269FVi9Gpg/H/j2Wx2+W7pUp1a7SmKizimqVUu/3rZtG3x9GwKo66IjmmCz3Y3Nm0vOjCwW3fUoOfnKz7Jtm24Dk5gIbNoEjBhhrM2ViejqjJE45eTov4WXfWazGWUx490uAktpG129/baeXRcv1kt7Ig9mMgH9++tQVY8eOnG8Vy+duO0Khw8Dt9xS/PX27TuRn9+y9B9wipbYvTseBaVM6KpcWYcQSyICzJwJ3HMPEB4OxMVdvo8eEXkHYyRONWvqvydPAgBq1aqF83Y70lx4yDQAeSKoVXTJfLHly7XKNHs20LixC6Mgcq6qVXUT2k2bNGm64w6dopef79zjnDqlw4NF0tMzoBPDXak28vPPw1pKdlShAnDu3OX35+YCQ4boiPu77+rbu2pV10ZKRJ7LGIlT/fpaa9+/HwDQsvBSMM6Fhywq+Lf8+2XngQN6lh05Ui/bicqhu+/W+T6RkXpr3RqIjXXe81euXFwo9hQBAZcnTv/7n645iY4GYmKAMWMAszHOmkR0nYxxCvD31xVrO3cCABo3boyqQUH4zYWH3ACgalAQbrl4vKFoXlOTJnqZTlSO+foCo0bpiHODBkD79sDzzwNZWTf+3NWq6STrIjVqVANw4saf+IpOwNfXHwGltASx2S79eulSTRgDA4EdO3TlHRGRMRInQNcFL1sGADCZTOj/9NOI8vGBk0cYAAB5AKJ8fDBg4ECYLp4ZOmqUXqJ+9x3nNZFh3HwzsGKFtiH78UddgbZo0Y1NHq9WTZf/F2nVqjl8fV1ZIwaAOISH31nqvMTkZCAkRIcl33hDC8bDh2vPK3c1CSUiz2OcxGnAACA+Xi+PATz//PM4brPhWxcc6jsAx202PP/888V3/vCDdhKMitKVdEQGYjJpIpGUpEXVp58GHnoISEm5vudr2RI4fvzC6Dpat26N/PyDAI46K+S/Efj4/IF27VqV+N1z54B9+4A6dbSyNHOmruuYOlUrb0RERYyTOLVtq8t05s4FAISFheHRPn3wusXi1EniaQBet1jwaJ8+CA0N1TtTUoBhw4BXX2XrYDK0oCDdpmXLFp3gHRYG/OtfOkp9LVq31u4hv/yiXz/00EPw9w8AEOX0mNUG2Gz78Nhjj5X43b17tanlG2/oEOK2bbqNChHR3xlnrzoA+OILHS5LSgIaNsSJEydwR0gI7jtzBj+IoJTGAQ4rAPCoyYSNVaogITkZtWvXBs6f18kfvr7Ahg2An58zXgmRxysoAKZN0x2FGjTQ1XgdOjj+8337arLy3//q1yNGPIO5c3+GzbYPzu4ebjI9iltuScD//pd06fA6dMixd28dhuzfH/jqK22GSURUEuNUnADgH//Qidmvvw4AqF27NmbPnYsVAJ6DJj7XqwDAswBWAJg9d64mTYAe68ABndfEpIm8iMUC/POfep3StKlu4zJsmFaiHDFwoM6d2rtXv3799degE8QnODnSaIgsxbhxb12WNGVl6UbDP/4I3HcfsGABkyYiugoxmvXrRQCRBQsu3DVv3jwxm0zykNksqXqBeU23VEAeMpvFbDLJvHnzio+1eLFItWoiK1a44YUSeZYVK0RuukmkRg2ROXNE7PYrP76gQCQ8XGTQoOL7JkyYICaTRYA/rvVtWsotTXx86knnzl3F/reAdu4UadxYpE4dfezmzS74pRCR4RgvcRIRGTdOxNdXZO3aC3dFR0fL/9WsKVUsFvk3IKcdOOueBuRTQKpYLPJ/NWtKdHR08TG2bhUJCBB5992yf31EHio7W2TUKBGLRSQiQiQp6cqPX7JEH7trl36dl5cn7dq1F4ulugDxN5g0ZYjF0lqqVq0phw4duuS4UVEiFSqIPPigyLPPijRtevVEj4hIxKiJk90uMmSISFDQJZeRGRkZMmzoULGYzVLJbJYhgHwJyDZA/iq8bSu8bwgglcxmsZjNMmzoUMnIyCh+/pgYkcqVRfr0EbHZ3PACiTxbfLzIXXfp9cs774hYrSU/rqBA5P77RcLCRHJy9L5Tp05JeHgLsViCBVh6nUlTvFgsoRIcXF3i4uIuHM9qFRkxQsRkEomMFElJ0QRq+vQy+KUQkSEYM3ESEcnLE+nbV8TfX2T27EsuJ1NTUyUyMlLCQkLEbDYLgEtuZrNZwkJCJDIyUlJTU4uf024XmTVLxMdH5JlnRPLz3fDCiMqHggKR//xHpEoVkVtvFfnll5Ifl5oqUrOmyBNPFL9Ns7KypEePXgJATKYBAux3MGHKFCBSTCZfuf32MElISLhwnJQUkRYtdHT955/1vr59RUJD+VYmIscZN3ES0TN3ZKSI2axnyOTkyx6Sk5MjsbGxsmrVKlm1apXExsZKTtGl78USEkQ6ddJL1fffZ12fyEHHjon076+JzVNPiRw/fvljNm4U8fMTGTBA5Nw5vc9ut8v8+fMlOLi6ACYxm7sJMLtwCC+/MFGyFyZViwUYLmZzgPj4+MrYsWPlXNETic6/Cg4WadtWpGjU7rvv9O28YUMZ/BKIyDCMnTgV2bhRpFkzPUv26yeyZYsmVVdjs+k8qaFDdSJG+/Yi27e7Pl4iA1q9WidjBweLzJx5+VtwwwaRqlVFOnYUuXhkPCcnR2bPni0tWrQRk8lUWBk2idkcUDiRXCvFDRo0kokTJ8qxY8cu/GxensikSZq0vfBCcVIWF6cj+a+84vrXTUTGYqw+TlciAqxcqd36Nm8GatYE7r8fuPdeoFYt7cYXGKhrqQ8eBHbtAlatAo4d0z5NL7yg3cn/tpyZiBxntQKTJgEffgi0aaO9n8LDi7+fnAx066advD/4QFsWXLyp7tmzZ7Fz504kJSXBarXCz88PDRs2RMuWLYtbhBTatk3bJRw5AkyerD2aio5x3326ee/SpewMTkTXxnsSpyIiui3Lr7/qbfNmIDOzeFt0k0k3pgoN1cY0Tz7JLVSInCwpSduubdoEvPYaMH58cf+kzEzg/fe1n22LFsCbb2oyVcrevJcQ0bf0hAl63dOhA/D119reDdBrovvuAxo3BqKjHXtOIqKLeV/iVCgxMRHLli3D9u3bkZycjLS0NGRlZaFSpUpo0qQJunbtihdffBF169Z1d6hEhiQCzJmjzf4DA7ULebduxd9PTgbGjNEmmf7+QK9ewAMP6CbD9esDFSpokpWZqQnRmjW6hUtqKhARoclYRERxkXj5ct2095Zb9LFBQWX/momo/PPaxCkyMhLvvffeha/9/PwQEBCA06dPX7ivcuXKWLhwIXr27OmOEIm8Qnq6Jk9z5gCPPaYb6zZoUPz9U6d0W5YlS3SPvMzMy5/D318rSV26AA8+CNx5Z/H3cnO1wf+MGcCLLwIff8xKExFdP69NnJYuXYo///wT99xzD8LDw1G1alUAgNVqRXR0NEaPHo2UlBRUrFgRCQkJaNiwoXsDJjK4334DpkzREfS33tIkp/BteYGIJlpHj+roerVqegsO1i1gLpaTA0RF6XNmZ+t/9+hRZi+HiAzKaxOnq9m7dy9CQkIAABMnTsTYsWPdHBGR8eXl6ZDd++/rRPLevYEhQ4CjR+dg+PChV/35L7/8Ch06jMA33wDTpwP5+cCzz2pFq04dl4dPRF7Ax90BeKrbbrsNVatWRWZmJlJTU90dDpFX8PMDXn0VeO45YNkyHb7r1g2oWFG/bzKZERhY88JKu6K2l3Y7YLMBb71VERkZQN26WrV69lmtRhEROQsTp1IkJCQgs3AyRePGjd0cDZF3qVgReOopvR0+DIwdC8yfD/j5NUCFCgdx8qRO+g4I0EniwcG6Aq9tW6BzZ6B580vbGBAROQsTp4vk5+fjxIkTWLt2LcaPHw8AqFatGoYMGeLewIi82E03AZ06aeJUp46uoMvPB3x82FaNiMoeEycA9evXx5EjRy67PzQ0FAsXLkSNGjXcEBURlYZNK4nIXZg4AahVqxZsNhusVivOnDkDAGjevDmmTp2KZs2auTk6IiIi8hScBQAgLi4Ox48fx+nTp5Geno6vv/4aaWlpeOCBBzB8+HDYbDZ3h0hEANLS0tC6dWsEBgYiICAADRs2xBNPPIHo6Gh3h0ZEXoLtCEpx6NAhhIWFITs7G59//jleeukld4dE5LXmzJmDoUOL2xEEBwfDarXi/PnzF+575JFHsHDhQlQsWoJHROQCrDiV4uabb0bfvn0BAF9++aWboyHybnXr1sX48eOxc+dOWK1WZGZmwmq1Yvv27Xj00UcBAMuXL8fTTz/t5kiJyOhYcbqCMWPG4IMPPkBAQAByc3PdHQ4RleLFF1/E9OnTAQDr1q1DRESEewMiIsNixekK9u/fDwAIDAx0cyREdCWTJ09GhQoVAADLli1zczREZGRemTiJCOx2+xUfk5iYiOXLlwMAr16JPFxgYCDCwsIAACkpKW6OhoiMzCsTp9OnTyM0NBSfffYZ9u7de0kSdeLECUyfPh0dO3bEuXPn4O/vf6EZJhEREXk3r+3jlJycjJdffhkA4Ovri6CgIOTl5eHs2bMXHlO7dm3Mnz8foaGh7gqTiByQnZ2NPXv2AAAaNWrk5miIyMi8MnEKCgrCsmXLsH79esTGxuLIkSNIS0uDyWRCvXr1EB4ejm7dumHw4MEICgpyd7hEXk1EYLrK3irjxo3DuXPnAAC9e/cug6iIyFtxVR0RebSDBw+iX79+GDZsGLp06YLGjRvDZDJBRLBr1y58+OGHWLRoEQCge/fuWLlypZsjJiIjY+JERB7t4MGDlwy/+fn5ISgoCNnZ2ReqTADQq1cvLFiwAJUrV3ZHmETkJZg4EZFHs1qtmDVrFmJjY7Fjxw6kpaUhKysLfn5+qFu3Lu666y4MHDgQXbp0cXeoROQFmDgREREROcgr2xEQERERXQ8mTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQOYuJERERE5CAmTkREREQO+n/a1KAABuSGtAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label = [str(i) for i in range(small_mhg.num_v)]\n", + "e_color = ['r'] * 4 + ['b'] * 4\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label, v_color=v_color, e_color=e_color)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Multilayer hypergraph constructing...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "small_v_label_temp = [str(i) for i in range(small_mhg_temp.num_v)]\n", + "e_color = ['r'] * 7 + ['b'] * 8\n", + "v_color = ['r'] * 5 + ['b'] * 5\n", + "small_mhg.draw(v_label=small_v_label_temp, v_color=v_color, e_color=e_color)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dhg_cuda117", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/structure/test_multilayer_hypergraph.py b/tests/structure/test_multilayer_hypergraph.py new file mode 100644 index 0000000..24bd98f --- /dev/null +++ b/tests/structure/test_multilayer_hypergraph.py @@ -0,0 +1,62 @@ +import torch +import pytest +import numpy as np +from dhg import Hypergraph, MultilayerHypergraph +import matplotlib.pyplot as plt + +# from dhg.random.hypergraph import hypergraph_Gnm + + +@pytest.fixture() +def g1(): + e_list = [(0, 1, 2, 5), (0, 1), (2, 3, 4), (3, 2, 4)] + g = Hypergraph(6, e_list) + return g + + +@pytest.fixture() +def g2(): + e_list = [(1, 2, 3), (0, 1, 3), (0, 1), (2, 4, 3), (2, 3)] + e_weight = [0.5, 1, 0.5, 1, 0.5] + g = Hypergraph(5, e_list, e_weight) + return g + + +def test_save(g1, tmp_path): + from dhg import load_structure + + g1.save(tmp_path / "g1") + g2 = load_structure(tmp_path / "g1") + + for e1, e2 in zip(g1.e[0], g2.e[0]): + assert e1 == e2 + for w1, w2 in zip(g1.e[1], g2.e[1]): + assert w1 == w2 + + +# test adjacency matrix +def test_adjacency_matrix(g1): + adj = g1.A + assert adj.shape == (6, 6) + assert np.allclose(adj[0, 1], 1) + assert np.allclose(adj[0, 2], 1) + assert np.allclose(adj[0, 3], 0) + assert np.allclose(adj[0, 4], 0) + assert np.allclose(adj[0, 5], 1) +# test construction +def test_construct_multilayer_hypergraph(): + g1 = g1() + g2 = g2() + + mhg = MultilayerHypergraph(11, 2, [g1, g2]) + assert mhg.num_layers == 2 + assert mhg.layers_list[0] == g1 + assert mhg.layers_list[1] == g2 + assert mhg.num_v == 11 + assert mhg.prob_inner_layer_connect == 0 + assert mhg.device == torch.device('cpu') + +def test_draw(mhg): + mhg.draw() + plt.show() +